Na równych Java 7 jest() i() deepEquals

Question

opis Metoda mówi:

Zwraca true, jeśli argumenty są głęboko sobie równe i false inaczej ... Równość jest określana za pomocą metody equals pierwszego argumentu.

Który (jak dla mnie) sugeruje, że Obiekty są głęboko równe, jeśli każdy obiekt, do którego odnoszą się odniesienia, jest również równy, używając metody equals(). I wszystkie obiekty, do których się odnoszą, są równe. I ..

Więc .. equality is determined by using the equals method of the first argument.

Czym się to różni od .equals()? Zakładając, że opisujemy to w odpowiedni sposób tam, gdzie obiekty są równe innemu obiektowi, każde pole obiektu jest równe jemu.

Czy możesz podać przykład ilustrujący różnicę między Objects.deepEquals() i Objects.equals()?

Answer 1

Jeśli co najmniej jeden z argumentów metody deepEquals nie jest tablicą, wówczas Objects.deepEquals i Objects.equals są takie 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)); 

powróci

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

Jak przyjść "płytkie" equals metody powrotu false? To dlatego, że in Java, for arrays, equality is determined by object identity. W tym przykładzie firstArray i secondArray są odrębnymi obiektami.

Wykonanie String[] secondArray = firstArray zamiast tego spowoduje zwrócenie true dla wszystkich czterech testów.

Answer 3

Mocowanie bardzo dobry przykład I znaleziono w 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)); 
} 

}

wyjściowa: Porównując Int tablicy i1: [1, 2, 3, 4] I1 [ 1, 2, 3, 4] Czy tablica i1 i i2 są równe true

Porównując Int tablica I2: [1, 2, 3, 4] I3 [0, 2, 3, 4] Czy tablica i2 i i3 są równe: false

Porównując dwukrotnie Tablica D1: [1.5, 2.4, 3.2, 4.0, 1.0], D2 [1,5, 2,4, 3,2, 4,0, 1,0] działa dwukrotnie D1 tablicy i D2 są jednakowe true

Porównując podwójne tablica d2: [1.5, 2.4, 3.2, 4.0, 1.0] i d3: [0.0, 2.4, 3.2, 4.0, 1.0] Czy podwójne d2 tablica i D3 są takie same: false

Porównując dwa String tablicą S1: [Jeden, dwa, trzy] i S2: [Jeden, dwa, trzy] Są zarówno s1 tablica String i s2 są równe : true

Porównując dwa String tablicą s2: [Jeden, dwa, trzy] i S3: [zero, dwa, trzy] są zarówno s2 tablica String i S3 są równe false

Object array o1: [ jeden, [Ljava.lang.String; @ 19821f] i o2: [jeden, [Ljava.lang.String; @ addbf1] Porównanie obiektu Array o1 i o2 z Arrayys.equals: false Porównanie obiektu Array o1 i o2 z Arrays.deepEquals: true

Answer 4

Funkcja deepEquals() jest używana z zagnieżdżonymi tablicami o dowolnej głębokości.
Funkcja equals() jest używana z prostymi typami danych pierwotnych.
Dla 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 
    } 
}