メソッドの説明によると：
引数が互いに深く等しい場合はtrueを返し、そうでない場合はfalseを返します...最初の引数のequalsメソッドを使用して等式を決定します。
これは（私にとって）、オブジェクトが参照を維持するすべてのオブジェクトもequals（）メソッドを使用して等しい場合、オブジェクトは非常に等しいことを示唆しています。そして、それらが参照しているすべてのオブジェクトも同じです。と ..
それで ..equality is determined by using the equals method of the first argument.
これはどう違うの.equals()ですか？ここでequalsを適切に説明すると仮定すると、オブジェクトは別のオブジェクトと等しく、オブジェクトのすべてのフィールドもそれに等しくなります。
Objects.deepEquals()との違いを示す例を教えてくださいObjects.equals()。
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では、配列の場合、同等性はオブジェクトIDによって決定されるためです。この例では、firstArrayとsecondArrayは別個のオブジェクトです。
したがってString[] secondArray = firstArray、代わりに実行すると、 true4つのテストすべてに戻ります。
メソッドの引数の少なくとも1つがdeepEquals配列でない場合、Objects.deepEqualsとObjects.equalsは同じです。
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
}
}
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
}
}
Objects#equals(Object a, Object b)：引数が互いに等しい場合はtrueを返し、そうでない場合はfalseを返します。したがって、両方の引数がnullの場合はtrueが返され、1つの引数がnullの場合はfalseが返されます。それ以外の場合、等式は最初の引数のequalsメソッドを使用して決定されます。
public static boolean equals(Object a, Object b) {
return (a == b) || (a != null && a.equals(b));
}
Objects#deepEquals(Object a, Object b)：引数が互いに完全に等しい場合はtrueを返し、そうでない場合はfalseを返します。2つのnull値は完全に等しいです。両方の引数が配列の場合、Arrays.deepEqualsのアルゴリズムを使用して同等性を判断します。それ以外の場合、等式は最初の引数のequalsメソッドを使用して決定されます。
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)：指定された2つのオブジェクトの配列が互いに等しい場合にtrueを返します。両方の配列に同じ数の要素が含まれ、2つの配列の対応する要素のペアがすべて等しい場合、2つの配列は等しいと見なされます。
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)：指定された2つの配列が互いに完全に等しい場合、trueを返します。この方法とは異なりequals(Object[],Object[])、この方法は、任意の深さのネストされた配列での使用に適しています。
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;
}
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
2つの文字列配列s1：[One、Two、Three]とs2の比較：[One、Two、Three]文字列配列s1とs2はどちらも等しい：true
2つの文字列配列s2：[One、Two、Three]とs3：[zero、Two、Three]の比較文字列配列s2とs3はどちらも等しい：false
オブジェクト配列o1：[one、[Ljava.lang.String; @ 19821f]およびo2：[one、[Ljava.lang.String; @ addbf1]オブジェクト配列o1およびo2とArrays.equals：falseの比較オブジェクト配列o1とArrays.deepEqualsを使用したo2：true