Note. Array Equality

[comp1110-73]
  • Fabian Muehlboeck

We've seen earlier that String Equality requires special attention compared to the more common equality operator ==. This is because the operator == expresses sameness, either of a numerical value, or of something larger within computer memory. Sameness implies equality, but not necessarily the other way around. We will look at the technical reasons for this later in the course.

Similar to Strings, Arrays are also larger things in computer memory. But in contrast to Strings, the contents of arrays can change. What that means is that if your idea of equality is that two arrays contain equal values in the same order, then that may be true at one point in your program, and false at a different point, as the contents of one or both of the arrays may change in the meantime. This means that the identity of each array matters a lot more than it does for Strings.

For that reason, a.equals(b) on arrays is the same as a == b. However, the Java Standard Libraries contain a number of standard functions dealing with arrays, among them a suitable equality function. To use it, you need to add an import declaration for java.util.Arrays to the top of your file. You can then use the expression Arrays.equals(a,b) to compare two arrays for equality based on the equality of their elements.

Context

    Introduction to Arrays

    [comp1110-71]
    • Fabian Muehlboeck

    Definition. Arrays

    [comp1110-15]
    • Liam O'Connor

    Arrays are a primary way to store linear, ordered collections of data. The elements of an array must all have the same type. An array type is written by appending [] to the type of the array elements. For example, the type of an array of int values is written as int[], whereas the type of an array of String values is written String[]. We create an array with the new keyword, like so:

    int[] arr = new int[50];

    The above code makes space in memory (called allocating) for a sequence of 50 int values, and stores the location of that space in memory in the newly-created variable arr.

    By default, all ints in our array will be set to zero. If we wish to initialise our array with other values, we can include them in the new invocation like so:

    // size no longer needed as javac will count the elements int[] arr = new int[]{10,100,-2,8,0};

    We can access the contents of an array by index. The ith element of the array a (starting counting at zero) can be retreived using the notation a[i], for example:

    int first = arr[0]; IO.println(first + " is the first (index 0) element!");

    We can also update elements of an array using this notation:

    arr[0] = first + 1; IO.println("The first element is now: " + arr[0]); // prints 11

    To get the length of an array a, we can write a.length:

    int len = arr.length; IO.println("The array arr has " + len + " elements.");

    Warning. 

    • Liam O'Connor

    For Strings, we write str.length() (i.e. calling a method, with the parentheses), but for arrays, we just write arr.length.

    Example. Printing Array Elements (In reverse order)

    [comp1110-72]
    • Fabian Muehlboeck

    In the lecture, we went through the following example of looping through an array. Note that, in contrast to earlier, we start our counter variable at the end (i = arr.length), and reduce it before we use it in the body of the loop.

    void main() { int x = 6; int[] arr = new int[]{5, 93, -2, 0, 1000000, -1}; int y = arr[0]; int i = arr.length; while(i != 0) { // INV: all elements of arr[i..arr.length-1] have been printed i = i - 1; IO.println(arr[i]); } // i == 0 // INV: all elements of arr[0..arr.length-1] have been printed // all elements of arr have been printed }

    It is always a good idea to sanity-check your indices to prevent off-by-one errors (which would crash your program). Often, it suffices to look at the first and last index values.

    In this case, i starts as arr.length, but the first valid index from the back is arr.length - 1. Since we assign i to be i - 1 before looking at the array, that works out fine.

    For the last index, the loop will end when i == 0, so the last time it could run is when i == 1. In that case, because we again reduce i before accessing the array, the last index we will look at is 0, which is both a valid index if the array is not empty (in which case, we would not be in the loop to begin with), and also the last index we want to look at.

    Finally, the loop invariant (§ [comp1110-0W]) tracks the property that we wanted, which is that all elements of the array within a certain range have been printed, in such a way that the range coincides with the full array at the end of the loop.

    Example. Searching for an Element in an Array, Generally

    [comp1110-16]
    • Liam O'Connor, Fabian Muehlboeck
     boolean contains(int[] haystack, int needle) { int i = 0; while(i < haystack.length) { // i <= haystack.length && forall 0 <= j < i, haystack[j] != needle if(needle == haystack[i]) { return true; } i = i + 1; } // i == haystack.length // forall 0 <= j < haystack.length, haystack[j] != needle return false; }

    Construction. import declarations

    [comp1110-75]
    • Fabian Muehlboeck

    Writing a program that does something new and amazing is great! But even in that best-case scenario, you will usually need your program to execute many little steps that are very common.

    The most common of those are part of the core of your programming language, like numbers, Strings, and basic arithmetic operations. Other common things are often contained in a Standard Library, usually part of a standard language distribution, as in the case of the Java Development Kit (JDK) which you installed as part of our standard software setup. Finally, other people and organizations may publish their own libraries of code that you may be able to include in your own program.

    Java's import declaration lets you "import" a library (or parts of it) so you can use its functionality in your code. You typically put them at the top of any code file that uses them. For example, to import the array-related part of the java.util library, you would write:

    import java.util.Arrays;

    You can also import everything in a particular library using * as the last part of your imported library path, as in:

    import java.util.*;

    This may look convenient, but can easily cause name clashes and other maintenance issues, and as such is usually not a good idea.

    Note. Array Equality

    [comp1110-73]
    • Fabian Muehlboeck

    We've seen earlier that String Equality requires special attention compared to the more common equality operator ==. This is because the operator == expresses sameness, either of a numerical value, or of something larger within computer memory. Sameness implies equality, but not necessarily the other way around. We will look at the technical reasons for this later in the course.

    Similar to Strings, Arrays are also larger things in computer memory. But in contrast to Strings, the contents of arrays can change. What that means is that if your idea of equality is that two arrays contain equal values in the same order, then that may be true at one point in your program, and false at a different point, as the contents of one or both of the arrays may change in the meantime. This means that the identity of each array matters a lot more than it does for Strings.

    For that reason, a.equals(b) on arrays is the same as a == b. However, the Java Standard Libraries contain a number of standard functions dealing with arrays, among them a suitable equality function. To use it, you need to add an import declaration for java.util.Arrays to the top of your file. You can then use the expression Arrays.equals(a,b) to compare two arrays for equality based on the equality of their elements.

    Example. Arrays.equals

    [comp1110-74]
    • Fabian Muehlboeck
     import java.util.Arrays; void main() { int[] a1 = new int[]{1,2,3,4}; int[] a2 = new int[]{1,2,3,4}; IO.println(a1 == a2); // not the same, hence false IO.println(a1.equals(a2)); // not the same, hence false // contain equal elements, hence true IO.println(Arrays.equals(a1,a2)); a1[0] = 5; // do not contain equal elements, hence false IO.println(Arrays.equals(a1,a2)); int[] a3 = a2; // a3 is now the same as a2 IO.println(a2 == a3); // the same, hence true // the same, hence contain equal elements, hence true IO.println(Arrays.equals(a2,a3)); a2[0] = 10; // this modification affects both a2 and a3 // still the same, hence still contain equal elements, hence true IO.println(Arrays.equals(a2,a3)); }

    Construction. Command Line Parameters

    [comp1110-1L]
    • Liam O'Connor, Fabian Muehlboeck

    When we invoke our program, we can pass it command line arguments:

    $ java MyProgram argument anotherArgument "this is a multi-word parameter"

    If we add a parameter to our main function that has type String[], that array will contain each of those arguments:

    void main(String[] args) { int i = 0; while(i < args.length) { IO.println(args[i]); i = i + 1; } }

    When called as above, the above program will print the arguments in order, each on one line:

    $ java MyProgram argument anotherArgument "this is a multi-word parameter" argument anotherArgument this is a multi-word parameter

    Backlinks

      Reference vs. Value Equality

      [comp1110-1T]
      • Liam O'Connor, Fabian Muehlboeck

      The difference between value types and reference types explains the differences between == and other methods to decide equality.

      For value types, == happens to capture regular equality - for example, there are no two int values that represent the number 32 but are somehow different.

      On the other hand, for reference types, == describes reference equality, identifying whether two references point to the same object in memory. Since there may be two different objects representing the same value, == is too strict in many cases. We have seen this for String equality and Array equality. It is the same way in general for objects of arbitrary classes, except that for those, by default, no other notion of equality comparison exists. We'll see later how to define our own equality comparison.

      Finally, Enums are a special case: they are a reference type, but with a guarantee that each case of a Enum refers to the same object in memory. As such, comparing the references to Enum values using == is fine - as for ints, there are no two distinct values representing the same case.

      Construction. Static methods

      [comp1110-4F]
      • Liam O'Connor, Fabian Muehlboeck

      A static method belongs to the class itself rather than to any particular instance. It is declared with the static keyword and called on the class name rather than on an object:

      public class MathUtils { public static int square(int x) { return x * x; } } // called on the class, not an instance: int result = MathUtils.square(5);

      Because a static method has no associated instance, it cannot access instance fields or call instance (non-static) methods. It can only work with its arguments and other static members of the class — it is essentially a function.

      Static methods are useful for utility functions that are logically associated with a class but do not depend on any particular object's state. You have already seen examples of this in the standard library, such as the utility functions for characters or array comparison.

      Related

        Warning. String comparisons

        [comp1110-0H]
        • July 30, 2026
        • Liam O'Connor, Fabian Muehlboeck

        If you are familiar with other programming languages, you might be wondering why we compared strings in Example [comp1110-0G] using a.equals(b) instead of something like a == b. While a == b is indeed the normal way to compare (e.g.) numbers, in Java equality for Strings is a little more complicated. In Example [comp1110-0G], a comparison answer == "yes" would always fail, even if the contents of answer were identical to the contents of the string "yes", because the two strings themselves have different identities, and exist at different locations in memory. Using the notation answer.equals("yes") instead compares the contents of the strings rather than their location, which is usually the functionality that we want.

        Definition. Arrays

        [comp1110-15]
        • Liam O'Connor

        Arrays are a primary way to store linear, ordered collections of data. The elements of an array must all have the same type. An array type is written by appending [] to the type of the array elements. For example, the type of an array of int values is written as int[], whereas the type of an array of String values is written String[]. We create an array with the new keyword, like so:

        int[] arr = new int[50];

        The above code makes space in memory (called allocating) for a sequence of 50 int values, and stores the location of that space in memory in the newly-created variable arr.

        By default, all ints in our array will be set to zero. If we wish to initialise our array with other values, we can include them in the new invocation like so:

        // size no longer needed as javac will count the elements int[] arr = new int[]{10,100,-2,8,0};

        We can access the contents of an array by index. The ith element of the array a (starting counting at zero) can be retreived using the notation a[i], for example:

        int first = arr[0]; IO.println(first + " is the first (index 0) element!");

        We can also update elements of an array using this notation:

        arr[0] = first + 1; IO.println("The first element is now: " + arr[0]); // prints 11

        To get the length of an array a, we can write a.length:

        int len = arr.length; IO.println("The array arr has " + len + " elements.");

        Warning. 

        • Liam O'Connor

        For Strings, we write str.length() (i.e. calling a method, with the parentheses), but for arrays, we just write arr.length.

        Construction. import declarations

        [comp1110-75]
        • Fabian Muehlboeck

        Writing a program that does something new and amazing is great! But even in that best-case scenario, you will usually need your program to execute many little steps that are very common.

        The most common of those are part of the core of your programming language, like numbers, Strings, and basic arithmetic operations. Other common things are often contained in a Standard Library, usually part of a standard language distribution, as in the case of the Java Development Kit (JDK) which you installed as part of our standard software setup. Finally, other people and organizations may publish their own libraries of code that you may be able to include in your own program.

        Java's import declaration lets you "import" a library (or parts of it) so you can use its functionality in your code. You typically put them at the top of any code file that uses them. For example, to import the array-related part of the java.util library, you would write:

        import java.util.Arrays;

        You can also import everything in a particular library using * as the last part of your imported library path, as in:

        import java.util.*;

        This may look convenient, but can easily cause name clashes and other maintenance issues, and as such is usually not a good idea.

        bars magnifying-glass caret-down plus minus arrow-right xmark