На Java 7 равно () и deepEquals()

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) );

Вернется

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

Как получается, что" неглубокие " equals методы возвращают false? Это происходит потому, что в Java, для массивов, равенство определяется идентичностью объекта . В этом примере firstArray и secondArray являются различными объектами.

Выполнение String[] secondArray = firstArray вместо этого вернет true для всех четырех тестов.

Прилагаю очень хороший пример, который я нашел на 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));
} 

}

Вывод: Сравнение массива int i1: [1, 2, 3, 4] и i1: [1, 2, 3, 4] Равны ли массивы i1 и i2: true

Сравнение массива int i2: [1, 2, 3, 4] и i3: [0, 2, 3, 4] Равны ли массивы i2 и i3: false

Сравнение двойного массива d1: [1.5, 2.4, 3.2, 4.0, 1.0] и d2: [1.5, 2.4, 3.2, 4.0, 1.0] Является ли двойной массив d1 и d2 равными: true

Сравнение двойного массива d2: [1.5, 2.4, 3.2, 4.0, 1.0] и d3: [0.0, 2.4, 3.2, 4.0, 1.0] Является ли двойной массив d2 и d3 одинаковыми: false

Сравнение двух строковых массивов s1: [один, два, три] и s2: [один, два, три] Оба массива строк S1 и S2 равны : истинные

Сравнение двух строковых массивов s2: [один, два, три] и s3: [ноль, два, три] Являются ли оба строковых массива s2 и s3 равными: false

Массив объектов o1: [one, [Ljava.яз..String;@19821f] и o2: [one, [Ljava.яз..Строка;@addbf1] Сравнение Объекта Массив o1 и o2 с массивами.равно: ложь Сравнение массива объектов o1 и o2 с массивами.deepEquals: true

DeepEquals() используется с вложенными массивами произвольной глубины.
equals() используется с простыми примитивными типами данных.
Например:

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
    }
}