On Java 7's equals() and deepEquals()

Question

Method description says:

Returns true if the arguments are deeply equal to each other and false otherwise... Equality is determined by using the equals method of the first argument.

Which (to me) suggests that Objects are deeply equal if every object they maintain references to are also equal using the equals() method. And every objects they have a reference to are also equal. And ..

So .. equality is determined by using the equals method of the first argument.

How is this different from .equals()? Assuming that we describe equals appropriately where, objects is equal to another object is every field of the object is equal to it as well.

Can you please provide an example illustrating the difference between Objects.deepEquals() and Objects.equals()?

Answer 1

If at least one of the arguments of deepEquals method is not an array, then Objects.deepEquals and Objects.equals are same.

Answer 2

String[] firstArray  = {"a", "b", "c"};
String[] secondArray = {"a", "b", "c"};

System.out.println("Are they equal 1    ? " + firstArray.equals(secondArray) );
System.out.println("Are they equal 2    ? " + Objects.equals(firstArray, secondArray) );

System.out.println("Are they deepEqual 1? " + Arrays.deepEquals(firstArray, secondArray) );
System.out.println("Are they deepEqual 2? " + Objects.deepEquals(firstArray, secondArray) );

will return

Are they equal 1    ? false
Are they equal 2    ? false
Are they deepEqual 1? true
Are they deepEqual 2? true

How come the "shallow" equals methods return false? This is because in Java, for arrays, equality is determined by object identity. In this example, firstArray and secondArray are distinct objects.

Doing String[] secondArray = firstArray instead will therefore return true for all four tests.

Answer 3

deepEquals() is used with nested arrays of arbitrary depth.
equals() is used with simple primitive data types.
For ex:

public class TwoDArray {
    public static void main(String args[]) {
        int a[][] = new int[2][2];
        int b[][] = new int[2][2];
        for(int i=0;i<2;i++)
            for(int j=0;j<2;j++) {
                a[i][j] = i+j;
                b[i][j] = i+j;  
            }
        System.out.println(Arrays.deepEquals(a,b));//return true
        System.out.println(Arrays.equals(a, b));//return false
    }
}

Answer 4

Attaching a very good example i found on javarevisited.blogspot.in

public class ArrayCompareTest {

public static void main(String args[]) {

   //comparing primitive int arrays in Java
    int[] i1 = new int[] {1,2,3,4};
    int[] i2 = new int[] {1,2,3,4};
    int[] i3 = new int[] {0,2,3,4};

    //Arrays.equals() compare Array and return true if both array are equal
    //i..e either both of them are null or they are identical in length, and each pair
    //match each other e.g. i[0]=i2[0], i[1]=i2[1] and so on

    //i1 and i2 should be equal as both contains same elements
    boolean result = Arrays.equals(i1, i2);
    System.out.println("Comparing int array i1: " + Arrays.toString(i1)
                        + " and i1: " + Arrays.toString(i2));
    System.out.println("Does array i1 and i2 are equal : " + result);

    //array ii2 and i3 are not equals as only length is same, first pair is not same
    result = Arrays.equals(i2, i3);
    System.out.println("Comparing int array i2: " + Arrays.toString(i2)
                        + " and i3: " + Arrays.toString(i3));
    System.out.println("Does array i2 and i3 are equal : " + result);

    //comparing floating point or double arrays in Java
    double[] d1 = new double[] {1.5, 2.4, 3.2, 4,1};
    double[] d2 = new double[] {1.5, 2.4, 3.2, 4,1};
    double[] d3 = new double[] {0.0, 2.4, 3.2, 4,1};

    //Comparing two floating-point arrays using Arrays.equals() in Java

    //double array d1 and d2 should be equal - length same, each index matches
    result = Arrays.equals(d1, d2);
    System.out.println("Comparing double array d1: " + Arrays.toString(d1)
                        + " and d2: " + Arrays.toString(d2));
    System.out.println("Does double array d1 and d2 are equal : " + result);

    //double array d2 and d3 is not equal - length same, first pair does not match
    result = Arrays.equals(d2, d3);
    System.out.println("Comparing double array d2: " + Arrays.toString(d2)
                        + " and d3: " + Arrays.toString(d3));
    System.out.println("Does double array d2 and d3 are same : " + result);

    //comparing Object array, here we will use String array
    String[] s1 = new String[]{"One", "Two", "Three"};
    String[] s2 = new String[]{"One", "Two", "Three"};
    String[] s3 = new String[]{"zero", "Two", "Three"};

    //String array s1 and s2 is equal - length same, each pair matches
    result = Arrays.equals(s1, s2);
    System.out.println("Comparing two String array s1: " + Arrays.toString(s1)
                        + " and s2: " + Arrays.toString(s2));

    System.out.println("Are both String array s1 and s2 are equal : " + result);

    //String array s2 and s3 is not equal - length same, first pair different
    result = Arrays.equals(d2, d3);
    System.out.println("Comparing two String array s2: " + Arrays.toString(s2)
                         + " and s3: " + Arrays.toString(s3));

    System.out.println("Are both String array s2 and s3 are equal : " + result);

    //Comparing nested arrays with equals and deepEquals method
    //Arrays.equals() method does not compare recursively,
    //while deepEquals() compare recursively
    //if any element inside Array is type of Array itself,
    //as here second element is String array

    Object[] o1 = new Object[]{"one", new String[]{"two"}};
    Object[] o2 = new Object[]{"one", new String[]{"two"}};

    System.out.println("Object array o1: " + Arrays.toString(o1) + " and o2: "
                        + Arrays.toString(o2));
    System.out.println("Comparing Object Array o1 and o2 with Arrays.equals : "
                        + Arrays.equals(o1, o2));
    System.out.println("Comparing Object Array o1 and o2 with Arrays.deepEquals : "
                        + Arrays.deepEquals(o1, o2));
} 

}

Output: Comparing int array i1: [1, 2, 3, 4] and i1: [1, 2, 3, 4] Does array i1 and i2 are equal : true

Comparing int array i2: [1, 2, 3, 4] and i3: [0, 2, 3, 4] Does array i2 and i3 are equal : false

Comparing double array d1: [1.5, 2.4, 3.2, 4.0, 1.0] and d2: [1.5, 2.4, 3.2, 4.0, 1.0] Does double array d1 and d2 are equal : true

Comparing double array d2: [1.5, 2.4, 3.2, 4.0, 1.0] and d3: [0.0, 2.4, 3.2, 4.0, 1.0] Does double array d2 and d3 are same : false

Comparing two String array s1: [One, Two, Three] and s2: [One, Two, Three] Are both String array s1 and s2 are equal : true

Comparing two String array s2: [One, Two, Three] and s3: [zero, Two, Three] Are both String array s2 and s3 are equal : false

Object array o1: [one, [Ljava.lang.String;@19821f] and o2: [one, [Ljava.lang.String;@addbf1] Comparing Object Array o1 and o2 with Arrays.equals : false Comparing Object Array o1 and o2 with Arrays.deepEquals : true

Answer 5

Example:

import java.util.Arrays;
import java.util.Objects;

public class Main {
    public static void main(String[] args) {
        Integer[] x = { 1, 2 };
        Integer[] y = { 1, 2 };
        System.out.println(Objects.equals(x, y));       // false
        System.out.println(Objects.deepEquals(x, y));   // true
        System.out.println(Arrays.equals(x, y));        // true
        System.out.println(Arrays.deepEquals(x, y));    // true
        System.out.println();

        int[][] a = { { 1, 2 }, { 3, 4 } };
        int[][] b = { { 1, 2 }, { 3, 4 } };
        System.out.println(Objects.equals(a, b));       // false
        System.out.println(Objects.deepEquals(a, b));   // true
        System.out.println(Arrays.equals(a, b));        // false
        System.out.println(Arrays.deepEquals(a, b));    // true
    }
}

Documentation and decompiled code:

Objects#equals(Object a, Object b): Returns true if the arguments are equal to each other and false otherwise. Consequently, if both arguments are null, true is returned and if exactly one argument is null, false is returned. Otherwise, equality is determined by using the equals method of the first argument.

public static boolean equals(Object a, Object b) {
    return (a == b) || (a != null && a.equals(b));
}

Objects#deepEquals(Object a, Object b): Returns true if the arguments are deeply equal to each other and false otherwise. Two null values are deeply equal. If both arguments are arrays, the algorithm in Arrays.deepEquals is used to determine equality. Otherwise, equality is determined by using the equals method of the first argument.

public static boolean deepEquals(Object a, Object b) {
    if (a == b)
        return true;
    else if (a == null || b == null)
        return false;
    else
        return Arrays.deepEquals0(a, b);
}

Arrays#equals(Object[] a, Object[] a2): Returns true if the two specified arrays of Objects are equal to one another. The two arrays are considered equal if both arrays contain the same number of elements, and all corresponding pairs of elements in the two arrays are equal.

public static boolean equals(Object[] a, Object[] a2) {
    if (a==a2)
        return true;
    if (a==null || a2==null)
        return false;

    int length = a.length;
    if (a2.length != length)
        return false;

    for (int i=0; i<length; i++) {
        if (!Objects.equals(a[i], a2[i]))
            return false;
    }

    return true;
}

Arrays#deepEquals(Object[] a1, Object[] a2): Returns true if the two specified arrays are deeply equal to one another. Unlike the equals(Object[],Object[]) method, this method is appropriate for use with nested arrays of arbitrary depth.

public static boolean deepEquals(Object[] a1, Object[] a2) {
    if (a1 == a2)
        return true;
    if (a1 == null || a2==null)
        return false;
    int length = a1.length;
    if (a2.length != length)
        return false;

    for (int i = 0; i < length; i++) {
        Object e1 = a1[i];
        Object e2 = a2[i];

        if (e1 == e2)
            continue;
        if (e1 == null)
            return false;

        // Figure out whether the two elements are equal
        boolean eq = deepEquals0(e1, e2);

        if (!eq)
            return false;
    }
    return true;
}

static boolean deepEquals0(Object e1, Object e2) {
    assert e1 != null;
    boolean eq;
    if (e1 instanceof Object[] && e2 instanceof Object[])
        eq = deepEquals ((Object[]) e1, (Object[]) e2);
    else if (e1 instanceof byte[] && e2 instanceof byte[])
        eq = equals((byte[]) e1, (byte[]) e2);
    else if (e1 instanceof short[] && e2 instanceof short[])
        eq = equals((short[]) e1, (short[]) e2);
    else if (e1 instanceof int[] && e2 instanceof int[])
        eq = equals((int[]) e1, (int[]) e2);
    else if (e1 instanceof long[] && e2 instanceof long[])
        eq = equals((long[]) e1, (long[]) e2);
    else if (e1 instanceof char[] && e2 instanceof char[])
        eq = equals((char[]) e1, (char[]) e2);
    else if (e1 instanceof float[] && e2 instanceof float[])
        eq = equals((float[]) e1, (float[]) e2);
    else if (e1 instanceof double[] && e2 instanceof double[])
        eq = equals((double[]) e1, (double[]) e2);
    else if (e1 instanceof boolean[] && e2 instanceof boolean[])
        eq = equals((boolean[]) e1, (boolean[]) e2);
    else
        eq = e1.equals(e2);
    return eq;
}