View source for Book:ThinkJava/07 Arrays and References

{{sidebar box|[[Book:ThinkJava|Table of contents]]}}


= Arrays and References =

Up to this point, the only variables we have used were for individual values such as numbers or strings. In this chapter, we’ll learn how to store multiple values of the same type using a single variable. This language feature will enable you to write programs that manipulate larger amounts of data.

For example, Exercise [[#doubloon|[doubloon]]] asked you to check whether every letter in a string appears exactly twice. One algorithm (which hopefully you already discovered) is to loop through the string 26 times, once for each lowercase letter:

<source lang="java">// outer loop: for each lowercase letter
for (char c = 'a'; c <= 'z'; c++) {
    // inner loop: count how many times the letter appears
    for (int i = 0; i < str.length(); i++) {
        ...
    // if the count is not 0 or 2, return false</source>
This “nested loops” approach is inefficient, especially when the string is long. For example, there are more than 3 million characters in <span>''War and Peace''</span>; to process the whole book, the nested loop would run about 80 million times.

Another algorithm would initialize 26 variables to zero, loop through the string <span>''one time''</span>, and use a giant <code>if</code> statement to update the variable for each letter. But who wants to declare 26 variables?

That’s where arrays come in. We can use a single variable to store 26 integers. Rather than use an <code>if</code> statement to update each value, we can use arithmetic to update the <math display="inline">n</math>th value directly. We will present this algorithm at the end of the chapter.

== Creating Arrays ==

An <span>'''array'''</span> is a sequence of values; the values in the array are called <span>'''elements'''</span>. You can make an array of <code>int</code>s, <code>double</code>s, <code>String</code>s, or any other type, but all the values in an array must have the same type.

To create an array, you have to declare a variable with an <span>''array type''</span> and then create the array itself. Array types look like other Java types, except they are followed by square brackets (<code>[]</code>). For example, the following lines declare that <code>counts</code> is an “integer array” and <code>values</code> is a “double array”:

<source lang="java">int[] counts;
double[] values;</source>
To create the array itself, you have to use the <code>new</code> operator, which we first saw in Section [[#scanner|[scanner]]]. The <code>new</code> operator <span>'''allocates'''</span> memory for the array and automatically initializes all of its elements to zero.

<source lang="java">counts = new int[4];
values = new double[size];</source>
The first assignment makes <code>counts</code> refer to an array of four integers. The second makes <code>values</code> refer to an array of <code>double</code>s, but the number of elements depends on the value of <code>size</code> (at the time the array is created).

Of course, you can also declare the variable and create the array with a single line of code:

<source lang="java">int[] counts = new int[4];
double[] values = new double[size];</source>
You can use any integer expression for the size of an array, as long as the value is nonnegative. If you try to create an array with <code>-4</code> elements, for example, you will get a <code>NegativeArraySizeException</code>. An array with zero elements is allowed, and there are special uses for such arrays.

You can initialize an array with an <span>'''array literal'''</span>, which is a comma-separated sequence of elements enclosed in braces, like this:

<source lang="java">int[] a = {1, 2, 3, 4};</source>
This statement creates an array variable, <code>a</code>, and makes it refer to an array with four elements.

== Accessing Elements ==

When you create an array with the <code>new</code> operator, the elements are initialized to zero. Figure [[#fig.array|1.1]] shows a memory diagram of the <code>counts</code> array so far.

[[File:array_java.png |frame|none|alt=|caption Memory diagram of an <code>int</code> array.<span label="fig.array"></span>]]

The arrow indicates that the value of <code>counts</code> is a <span>'''reference'''</span> to the array. You should think of <span>''the array''</span> and <span>''the variable''</span> that refers to it as two different things. As we’ll soon see, we can assign a different variable to refer to the same array, and we can change the value of <code>counts</code> to refer to a different array.

The boldface numbers inside the boxes are the elements of the array. The lighter numbers outside the boxes are the <span>'''indexes'''</span> used to identify each location in the array. As with strings, the index of the first element is 0, not 1. For this reason, we sometimes refer to the first element as the “zeroth” element.

The <code>[]</code> operator selects elements from an array:

<source lang="java">System.out.println("The zeroth element is " + counts[0]);</source>
You can use the <code>[]</code> operator anywhere in an expression:

<source lang="java">counts[0] = 7;
counts[1] = counts[0] * 2;
counts[2]++;
counts[3] -= 60;</source>
Figure [[#fig.array2|1.2]] shows the result of these statements.

[[File:array2_java.png |frame|none|alt=|caption Memory diagram after several assignment statements.<span label="fig.array2"></span>]]

You can use any expression as an index, as long as it has type <code>int</code>. One of the most common ways to index an array is with a loop variable. For example:

<source lang="java">int i = 0;
while (i < 4) {
    System.out.println(counts[i]);
    i++;
}</source>
This <code>while</code> loop counts up from 0 to 4. When <code>i</code> is 4, the condition fails and the loop terminates. So the body of the loop is only executed when <code>i</code> is 0, 1, 2, and 3. In this context, the variable name <code>i</code> is short for “index”.

Each time through the loop we use <code>i</code> as an index into the array, displaying the <math display="inline">i</math>th element. This type of array processing is usually written as a <code>for</code> loop.

<source lang="java">for (int i = 0; i < 4; i++) {
    System.out.println(counts[i]);
}</source>
For the <code>counts</code> array, the only legal indexes are 0, 1, 2, and 3. If the index is negative or greater than 3, the result is an <code>ArrayIndexOutOfBoundsException</code>.

== Displaying Arrays ==

You can use <code>println</code> to display an array, but it probably doesn’t do what you would like. For example, if you print an array like this:

<source lang="java">int[] a = {1, 2, 3, 4};
System.out.println(a);</source>
The output is something like:

<source lang="java">[I@bf3f7e0</source>
The bracket indicates that the value is an array, <code>I</code> stands for “integer”, and the rest represents the address of the array in memory.

If we want to display the elements of the array, we can do it ourselves:

<source lang="java">public static void printArray(int[] a) {
    System.out.print("{" + a[0]);
    for (int i = 1; i < a.length; i++) {
        System.out.print(", " + a[i]);
    }
    System.out.println("}");
}</source>
Given the previous array, the output of <code>printArray</code> is:

<source lang="java">{1, 2, 3, 4}</source>
The Java library includes a class, <code>java.util.Arrays</code>, that provides methods for working with arrays. One of them, <code>toString</code>, returns a string representation of an array. After importing <code>Arrays</code>, we can invoke <code>toString</code> like this:

<source lang="java">System.out.println(Arrays.toString(a));</source>
And the output is:

<source lang="java">[1, 2, 3, 4]</source>
Notice that <code>Arrays.toString</code> uses square brackets instead of curly braces. But it beats writing your own <code>printArray</code> method.

== Copying Arrays ==

As explained in Section [[#elements|1.2]], array variables contain <span>''references''</span> to arrays. When you make an assignment to an array variable, it simply copies the reference. But it doesn’t copy the array itself. For example:

<source lang="java">double[] a = new double[3];
double[] b = a;</source>
These statements create an array of three <code>double</code>s and make two different variables refer to it, as shown in Figure [[#fig.array3|1.3]].

[[File:array3_java.png |frame|none|alt=|caption Memory diagram of two variables referring to the same array.<span label="fig.array3"></span>]]

Any changes made through either variable will be seen by the other. For example, if we set <code>a[0] = 17.0</code>, and then display <code>b[0]</code>, the result is <span>17.0</span>. Because <code>a</code> and <code>b</code> are different names for the same thing, they are sometimes called <span>'''aliases'''</span>.

If you actually want to copy the array, not just the reference, you have to create a new array and copy the elements from one to the other, like this:

<source lang="java">double[] b = new double[3];
for (int i = 0; i < 3; i++) {
    b[i] = a[i];
}</source>
<code>java.util.Arrays</code> provides a method named <code>copyOf</code> that performs this task for you. So you can replace the previous code with one line:

<source lang="java">double[] b = Arrays.copyOf(a, 3);</source>
The second parameter is the number of elements you want to copy, so <code>copyOf</code> can also be used to copy part of an array. Figure [[#fig.array4|1.4]] shows the state of the array variables after invoking <code>Arrays.copyOf</code>.

[[File:array4_java.png |frame|none|alt=|caption Memory diagram of two variables referring to different arrays.<span label="fig.array4"></span>]]

The examples so far only work if the array has three elements. It is better to generalize the code to work with arrays of any size. We can do that by replacing the magic number, <code>3</code>, with <code>a.length</code>:

<source lang="java">double[] b = new double[a.length];
for (int i = 0; i < a.length; i++) {
    b[i] = a[i];
}</source>
All arrays have a built-in constant, <code>length</code>, that stores the number of elements. In contrast to <code>String.length()</code>, which is a method, <code>a.length</code> is a constant. The expression <code>a.length</code> may look like a method invocation, but there are no parentheses and no arguments.

The last time the loop gets executed, <code>i</code> is <code>a.length - 1</code>, which is the index of the last element. When <code>i</code> is equal to <code>a.length</code>, the condition fails and the body is not executed—which is a good thing, because trying to access <code>a[a.length]</code> would throw an exception.

Of course we can replace the loop altogether by using <code>Arrays.copyOf</code> and <code>a.length</code> for the second argument. The following line produces the same result shown in Figure [[#fig.array4|1.4]].

<source lang="java">double[] b = Arrays.copyOf(a, a.length);</source>
The <code>Arrays</code> class provides many other useful methods like <code>Arrays.compare</code>, <code>Arrays.equals</code>, <code>Arrays.fill</code>, and <code>Arrays.sort</code>. Take a moment to read the documentation by searching the web for <code>java.util.Arrays</code>.

== Array Traversal ==

Many computations can be implemented by looping through the elements of an array and performing an operation on each element. Looping through the elements of an array is called a <span>'''traversal'''</span>.

<source lang="java">int[] a = {1, 2, 3, 4, 5};
for (int i = 0; i < a.length; i++) {
    a[i] *= a[i];
}</source>
This example traverses an array and squares each element. At the end of the loop, the array has the values <code>{1, 4, 9, 16, 25}</code>.

Another common pattern is a <span>'''search'''</span>, which involves traversing an array and “searching” for a particular element. For example, the following method takes an array and a value, and it returns the index where the value appears:

<source lang="java">public static int search(double[] array, double target) {
    for (int i = 0; i < array.length; i++) {
        if (array[i] == target) {
            return i;
        }
    }
    return -1;  // not found
}</source>
If we find the target value in the array, we return its index immediately. If the loop exits without finding the target, it returns <code>-1</code>, a special value chosen to indicate a failed search. (This code is essentially what the <code>String.indexOf</code> method does.)

The following code searches an array for the value <code>1.23</code>, which is the third element. Because array indexes start at zero, the output is <code>2</code>.

<source lang="java">double[] array = {3.14, -55.0, 1.23, -0.8};
int index = search(array, 1.23);
System.out.println(index);</source>
Another common traversal is a <span>'''reduce'''</span> operation, which “reduces” an array of values down to a single value. Examples include the sum or product of the elements, the minimum, and the maximum. The following method takes an array and returns the sum of its elements:

<source lang="java">public static double sum(double[] array) {
    double total = 0.0;
    for (int i = 0; i < array.length; i++) {
        total += array[i];
    }
    return total;
}</source>
Before the loop, we initialize <code>total</code> to zero. Each time through the loop, we update <code>total</code> by adding one element from the array. At the end of the loop, <code>total</code> contains the sum of the elements. A variable used this way is sometimes called an <span>'''accumulator'''</span>, because it “accumulates” the running total.

== Random Numbers ==

Most computer programs do the same thing every time they run; programs like that are called <span>'''deterministic'''</span>. Usually determinism is a good thing, since we expect the same calculation to yield the same result. But for some applications, we want the computer to be unpredictable. Games are an obvious example, but there are many others, like scientific simulations.

Making a program <span>'''nondeterministic'''</span> turns out to be hard, because it’s impossible for a computer to generate truly random numbers. But there are algorithms that generate unpredictable sequences called <span>'''pseudorandom'''</span> numbers. For most applications, they are as good as random.

If you did Exercise [[#guess|[guess]]], you have already seen <code>java.util.Random</code>, which generates pseudorandom numbers. The method <code>nextInt</code> takes an integer argument, <code>n</code>, and returns a random integer between <code>0</code> and <code>n - 1</code> (inclusive).

If you generate a long series of random numbers, every value should appear, at least approximately, the same number of times. One way to test this behavior of <code>nextInt</code> is to generate a large number of values, store them in an array, and count the number of times each value occurs.

The following method creates an <code>int</code> array and fills it with random numbers between 0 and 99. The argument specifies the desired size of the array, and the return value is a reference to the new array.

<source lang="java">public static int[] randomArray(int size) {
    Random random = new Random();
    int[] a = new int[size];
    for (int i = 0; i < a.length; i++) {
        a[i] = random.nextInt(100);
    }
    return a;
}</source>
The following <code>main</code> method generates an array and displays it using <code>printArray</code> from Section [[#printarray|1.3]]. We could have used <code>Arrays.toString</code>, but we like seeing curly braces instead of square brackets.

<source lang="java">public static void main(String[] args) {
    int[] array = randomArray(8);
    printArray(array);
}</source>
Each time you run the program, you should get different values. The output will look something like this:

<source lang="java">{15, 62, 46, 74, 67, 52, 51, 10}</source>
== Building a Histogram ==

If these values were exam scores—and they would be pretty bad exam scores in that case—the teacher might present them to the class in the form of a <span>'''histogram'''</span>. In statistics, a histogram is a set of counters that keeps track of the number of times each value appears.

For exam scores, we might have ten counters to keep track of how many students scored in the 90s, the 80s, etc. To do that, we can traverse the array and count the number of elements that fall in a given range.

The following method takes an array and two integers. It returns the number of elements that fall in the range from <code>low</code> to <code>high - 1</code>.

<source lang="java">public static int inRange(int[] a, int low, int high) {
    int count = 0;
    for (int i = 0; i < a.length; i++) {
        if (a[i] >= low &amp;&amp; a[i] < high) {
            count++;
        }
    }
    return count;
}</source>
This pattern should look familiar: it is another reduce operation. Notice that <code>low</code> is included in the range (<code>>=</code>), but <code>high</code> is excluded (<code><</code>). This design keeps us from counting any scores twice.

Now we can count the number of scores in each grade range. We add the following code to our <code>main</code> method:

<source lang="java">int[] scores = randomArray(30);
int a = inRange(scores, 90, 100);
int b = inRange(scores, 80, 90);
int c = inRange(scores, 70, 80);
int d = inRange(scores, 60, 70);
int f = inRange(scores, 0, 60);</source>
This code is repetitive, but it is acceptable as long as the number of ranges is small. Suppose we wanted to keep track of the number of times each individual score appears. Then we would have to write 100 lines of code:

<source lang="java">int count0 = inRange(scores, 0, 1);
int count1 = inRange(scores, 1, 2);
int count2 = inRange(scores, 2, 3);
...
int count99 = inRange(scores, 99, 100);</source>
What we need is a way to store 100 counters, preferably so we can use an index to access them. Wait a minute, that’s exactly what an array does.

The following fragment creates an array of 100 counters, one for each possible score. It loops through the scores and uses <code>inRange</code> to count how many times each score appears. Then it stores the results in the <code>counts</code> array:

<source lang="java">int[] counts = new int[100];
for (int i = 0; i < counts.length; i++) {
    counts[i] = inRange(scores, i, i + 1);
}</source>
Notice that we are using the loop variable <code>i</code> three times: as an index into the <code>counts</code> array, and in the last two arguments of <code>inRange</code>.

The code works, but it is not as efficient as it could be. Every time the loop invokes <code>inRange</code>, it traverses the entire array. It would be better to make a single pass through the <code>scores</code> array.

For each score, we already know which range it falls in—the score itself. We can use that value to increment the corresponding counter. This code traverses the array of scores <span>''only once''</span> to generate the histogram:

<source lang="java">int[] counts = new int[100];
for (int i = 0; i < scores.length; i++) {
    int index = scores[i];
    counts[index]++;
}</source>
Each time through the loop, it selects one element from <code>scores</code> and uses it as an index to increment the corresponding element of <code>counts</code>. Because this code traverses the array of scores only once, it is much more efficient.

== The Enhanced for Loop ==

Since traversing arrays is so common, Java provides an alternative syntax that makes the code more compact. Consider a <code>for</code> loop that displays the elements of an array on separate lines:

<source lang="java">for (int i = 0; i < values.length; i++) {
    int value = values[i];
    System.out.println(value);
}</source>
We could rewrite the loop like this:

<source lang="java">for (int value : values) {
    System.out.println(value);
}</source>
This statement is called an <span>'''enhanced for loop'''</span>, also known as the “for each” loop. You can read the code as, “for each <code>value</code> in <code>values</code>”. It’s conventional to use plural nouns for array variables and singular nouns for element variables.

Notice how the single line <code>for (int value : values)</code> replaces the first two lines of the standard <code>for</code> loop. It hides the details of iterating each index of the array, and instead, focuses on the values themselves.

Using the enhanced <code>for</code> loop, and removing the temporary variable, we can write the histogram code from the previous section more concisely:

<source lang="java">int[] counts = new int[100];
for (int score : scores) {
    counts[score]++;
}</source>
Enhanced <code>for</code> loops often make the code more readable, especially for accumulating values. But they are not helpful when you need to refer to the index, as in search operations.

<source lang="java">for (double d : array) {
    if (d == target) {
        // array contains d, but we don't know where
    }
}</source>
== Counting Characters ==

We now return to the example from the beginning of the chapter and present a solution to Exercise [[#doubloon|[doubloon]]] using arrays. Here is the problem again:

<blockquote>A word is said to be a “doubloon” if every letter that appears in the word appears exactly twice. Write a method called <code>isDoubloon</code> that takes a string and checks whether it is a doubloon. To ignore case, invoke the <code>toLowerCase</code> method before checking.
</blockquote>
Based on the approach from Section [[#singlepass|1.7]], we will create an array of 26 integers to count how many times each letter appears. We convert the string to lowercase, so that we can treat <code>’A’</code> and <code>’a’</code> (for example) as the same latter.

<source lang="java">int[] counts = new int[26];
String lower = s.toLowerCase();</source>
We can use a <code>for</code> loop to iterate each character in the string. To update the <code>counts</code> array, we need to compute the index that corresponds to each character. Fortunately, Java allows you to perform arithmetic on characters.

<source lang="java">for (int i = 0; i < lower.length(); i++) {
    char letter = lower.charAt(i);
    int index = letter - 'a';
    counts[index]++;
}</source>
If <code>letter</code> is <code>’a’</code>, the value of <code>index</code> is <code>0</code>; if <code>letter</code> is <code>’b’</code>, the value of <code>index</code> is <code>1</code>, and so on.

Then we use <code>index</code> to increment the corresponding element of <code>counts</code>. At the end of the loop, <code>counts</code> contains a histogram of the letters in the string <code>lower</code>.

We can simplify this code with an enhanced <code>for</code> loop, but it doesn’t work with strings; we have to convert <code>lower</code> to an array of characters, like this:

<source lang="java">for (char letter : lower.toCharArray()) {
    int index = letter - 'a';
    counts[index]++;
}</source>
Once we have the counts, we can use a second <code>for</code> loop to check whether each letter appears 0 or 2 times.

<source lang="java">for (int count : counts) {
    if (count != 0 &amp;&amp; count != 2) {
        return false;  // not a doubloon
    }
}
return true;  // is a doubloon</source>
If we find a count that is neither 0 or 2, we know the word is not a doubloon and we can return immediately. If we make it all the way through the <code>for</code> loop, we know that all counts are 0 or 2, which means the word is a doubloon.

Pulling together the code fragments, and adding some comments and test cases, here’s the entire program.

<source lang="java">{Doubloon.java}
public class Doubloon {

    public static boolean isDoubloon(String s) {
        // count the number of times each letter appears
        int[] counts = new int[26];
        String lower = s.toLowerCase();
        for (char letter : lower.toCharArray()) {
            int index = letter - 'a';
            counts[index]++;
        }
        // determine whether the given word is a doubloon
        for (int count : counts) {
            if (count != 0 &amp;&amp; count != 2) {
                return false;
            }
        }
        return true;
    }

    public static void main(String[] args) {
        System.out.println(isDoubloon("Mama"));  // true
        System.out.println(isDoubloon("Lama"));  // false
    }
}</source>
This example uses methods, <code>if</code> statements, <code>for</code> loops, arithmetic and logical operators, integers, characters, strings, booleans, and arrays. We hope you’ll take a second to appreciate how much you’ve learned!

== Vocabulary ==

A collection of values, where all the values have the same type, and each value is identified by an index.

One of the values in an array. The <code>[]</code> operator selects elements.

An integer variable or value used to indicate an element of an array.

To reserve memory for an array or other object. In Java, the <code>new</code> operator allocates memory.

A value that indicates a storage location. In a memory diagram, a reference appears as an arrow.

A variable that refers to the same object as another variable.

Looping through the elements of an array (or other collection).

A traversal pattern used to find a particular element of an array.

A traversal pattern that combines the elements of an array into a single value.

A variable used to accumulate results during a traversal.

A program that does the same thing every time it is run.

A program that always behaves differently, even when run multiple times with the same input.

A sequence of numbers that appear to be random, but which are actually the product of a deterministic computation.

An array of integers where each integer counts the number of values that fall into a certain range.

An alternative syntax for traversing the elements of an array (or other collection).

== Exercises ==

The code for this chapter is in the <span>ch07</span> directory of <span>ThinkJavaCode2</span>. See page  for instructions on how to download the repository. Before you start the exercises, we recommend that you compile and run the examples.

If you haven’t already, take a look at Appendix [[#debugging|[debugging]]] where we’ve collected some of our favorite debugging advice. It refers to language features we haven’t yet covered, but it’s good for you to know what’s available when you need it.

The purpose of this exercise is to practice reading code and recognizing the traversal patterns in this chapter. The following methods are hard to read, because instead of using meaningful names for the variables and methods, they use names of fruit.

For each method, write one sentence that describes what the method does, without getting into the details of how it works. And for each variable, identify the role it plays.

<source lang="java">public static int banana(int[] a) {
    int kiwi = 1;
    int i = 0;
    while (i < a.length) {
        kiwi = kiwi * a[i];
        i++;
    }
    return kiwi;
}</source>
<source lang="java">public static int grapefruit(int[] a, int grape) {
    for (int i = 0; i < a.length; i++) {
        if (a[i] == grape) {
            return i;
        }
    }
    return -1;
}</source>
<source lang="java">public static int pineapple(int[] a, int apple) {
    int pear = 0;
    for (int pine: a) {
        if (pine == apple) {
            pear++;
        }
    }
    return pear;
}</source>
What is the output of the following program? Describe in a few words what <code>mus</code> does. Draw a stack diagram just before <code>mus</code> returns.

<source lang="java">public static int[] make(int n) {
    int[] a = new int[n];
    for (int i = 0; i < n; i++) {
        a[i] = i + 1;
    }
    return a;
}</source>
<source lang="java">public static void dub(int[] jub) {
    for (int i = 0; i < jub.length; i++) {
        jub[i] *= 2;
    }
}</source>
<source lang="java">public static int mus(int[] zoo) {
    int fus = 0;
    for (int i = 0; i < zoo.length; i++) {
        fus += zoo[i];
    }
    return fus;
}</source>
<source lang="java">public static void main(String[] args) {
    int[] bob = make(5);
    dub(bob);
    System.out.println(mus(bob));
}</source>
Write a method called <code>indexOfMax</code> that takes an array of integers and returns the index of the largest element. Can you write this method using an enhanced <code>for</code> loop? Why or why not?

The Sieve of Eratosthenes is “a simple, ancient algorithm for finding all prime numbers up to any given limit,” which you can read about at https://en.wikipedia.org/wiki/Sieve_of_Eratosthenes.

Write a method called <code>sieve</code> that takes an integer parameter, <code>n</code>, and returns a <code>boolean</code> array that indicates, for each number from <code>0</code> to <code>n - 1</code>, whether the number is prime.

Write a method named <code>areFactors</code> that takes an integer <code>n</code> and an array of integers, and that returns <code>true</code> if the numbers in the array are all factors of <code>n</code> (which is to say that <code>n</code> is divisible by all of them).

Write a method named <code>arePrimeFactors</code> that takes an integer <code>n</code> and an array of integers, and that returns <code>true</code> if the numbers in the array are all prime <span>''and''</span> their product is <code>n</code>.

Write a method called <code>letterHist</code> that takes a string as a parameter and returns a histogram of the letters in the string. The zeroth element of the histogram should contain the number of a’s in the string (upper- and lowercase); the 25th element should contain the number of z’s. Your solution should only traverse the string once.

Two words are anagrams if they contain the same letters and the same number of each letter. For example, “stop” is an anagram of “pots”, “allen downey” is an anagram of “well annoyed”, and “christopher mayfield” is an anagram of “hi prof the camel is dry”. Write a method that takes two strings and checks whether they are anagrams of each other.