Sul pari di Java 7() e deepEquals()

Question

Descrizione del metodo dice:

Restituisce vero se gli argomenti sono profondamente uguali tra loro e falso altrimenti ... uguaglianza è determinato utilizzando il metodo equals del primo argomento.

Il che (per me) suggerisce che gli oggetti sono profondamente uguali se ogni oggetto mantengono riferimenti sono uguali utilizzando il metodo() pari. E anche tutti gli oggetti a cui hanno un riferimento sono uguali. E ..

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

Come è diverso da .equals()? Supponendo che descriviamo equamente in modo appropriato dove, gli oggetti sono uguali a un altro oggetto, ogni campo dell'oggetto è uguale ad esso.

Può per favore fornire un esempio che illustri la differenza tra Objects.deepEquals() e Objects.equals()?

Answer 1

Se almeno uno degli argomenti del metodo deepEquals non è un array, quindi Objects.deepEquals e Objects.equals sono uguali.

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

tornerà

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

Come mai il "superficiale" equals metodi restituiscono false? Questo perché in Java, for arrays, equality is determined by object identity. In questo esempio, firstArray e secondArray sono oggetti distinti.

Effettuare String[] secondArray = firstArray invece restituirà true per tutti e quattro i test.

Answer 3

Collegamento un ottimo esempio ho trovato su 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)); 
} 

}

uscita: confronto int matrice i1: [1, 2, 3, 4] e i1: [ 1, 2, 3, 4] fa matrice i1 e i2 sono uguali: true

Confrontando i2 int matrice: [1, 2, 3, 4] e i3: [0, 2, 3, 4] fa array i2 e i3 sono uguali: false

Confrontando doppio array d1: [1.5, 2.4, 3.2, 4.0, 1.0] e d2: [1.5, 2.4, 3.2, 4.0, 1.0] fa il doppio d1 array e d2 sono uguali: true

Confrontando doppia array d2: [1.5, 2.4, 3.2, 4.0, 1.0] e d3: [0.0, 2.4, 3.2, 4.0, 1.0] fa il doppio d2 array e d3 sono gli stessi: true

confronto di due String serie S1: [Uno, Due, Tre] e s2: [Uno, Due, Tre] Sono entrambi s1 array di stringhe e s2 sono uguali : true

Confrontando due corde matrice s2: [uno, due, tre] e s3: [a zero, due, tre] sono entrambi s2 array di stringhe e s3 sono uguali: false

oggetto matrice o1: [ uno, [Ljava.lang.String; @ 19821f] e o2: [uno, [Ljava.lang.String; @ addbf1] Confronto dell'array di oggetti o1 e o2 con Arrays.equals: false Confronto tra matrice di oggetti o1 e o2 con Arrays.deepEquals: true

Answer 4

deepEquals() viene utilizzato con matrici annidate di profondità arbitraria.
equals() è utilizzato con i tipi di dati primitivi semplici.
Per esempio:

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