iguales de Java 7() y() deepEquals

Question

Descripción Método dice:

devuelve verdadero si los argumentos son profundamente iguales entre sí y falso lo contrario ... Igualdad se determina usando el método equals del primer argumento.

Qué (para mí) sugiere que los objetos son profundamente iguales si todos los objetos que mantienen referencias a son también iguales utilizando el método() iguales. Y todos los objetos a los que tienen referencia son también iguales. Y ..

Así que .. equality is determined by using the equals method of the first argument.

¿Cómo es esto diferente de .equals()? Suponiendo que describimos equals apropiadamente donde, objects es igual a otro objeto, cada campo del objeto es igual a él también.

¿Puede proporcionar un ejemplo que ilustra la diferencia entre Objects.deepEquals() y Objects.equals()?

Answer 1

Si al menos uno de los argumentos del método deepEquals no es una matriz, entonces Objects.deepEquals y Objects.equals son los mismos.

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

volverá

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

¿Cómo es que la "superficial" equals métodos devuelven false? Esto es porque in Java, for arrays, equality is determined by object identity. En este ejemplo, firstArray y secondArray son objetos distintos.

En su lugar, el String[] secondArray = firstArray devolverá true para las cuatro pruebas.

Answer 3

Colocación de un ejemplo muy bueno i encontrado en 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)); 
} 

}

de salida: Comparando int array i1: [1, 2, 3, 4] y i1: [ 1, 2, 3, 4] ¿El array i1 e i2 son iguales: true

Comparando i2 int array: [1, 2, 3, 4] y i3: [0, 2, 3, 4] ¿El array i2 e i3 son iguales: falso

Comparando doble matriz D1: [1,5, 2,4, 3,2, 4,0, 1,0] y d2: [1,5, 2,4, 3,2, 4,0, 1,0] cumple una doble d1 matriz y d2 son iguales: true

Comparando doble array d2: [1.5, 2.4, 3.2, 4.0, 1.0] y d3: [0.0, 2.4, 3.2, 4.0, 1.0] cumple una doble d2 matriz y D3 son los mismos: falsos

comparar dos Array cadena s1: [Uno, dos, tres] y S2: [Uno, dos, tres] son tanto de tipo Alfa S1 y S2 son iguales : verdadera

comparar dos array cadena s2: [Uno, dos, tres] y s3: [cero, dos, tres] son ambos de tipo Alfa S2 y S3 son iguales: falsa

objeto de matriz o1: [ uno, [Ljava.lang.String; @ 19821f] y o2: [uno, [Ljava.lang.String; @ addbf1] Comparación de la matriz de objetos o1 y o2 con Arrays.equals: false Comparación de la matriz de objetos o1 y o2 con Arrays.deepEquals: true

Answer 4

deepEquals() se utiliza con matrices anidadas de profundidad arbitraria.
equals() se usa con tipos de datos primitivos simples.
Por ejemplo:

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