17

方法描述说：

如果参数彼此高度相等，则返回 true，否则返回 false...相等性是通过使用第一个参数的 equals 方法确定的。

这（对我而言）表明，如果使用 equals() 方法维护引用的每个对象也相等，则对象是高度相等的。他们引用的每个对象也是相等的。和 ..

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

这与 有何不同.equals()？假设我们恰当地描述了equals，当对象等于另一个对象时，对象的每个字段也都等于它。

您能否提供一个示例来说明和之间的Objects.deepEquals()区别Objects.equals()？

4

5 回答 5

17 
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所有四个测试。

于 2014-10-24T21:24:49.183 回答
9

如果方法的至少一个参数deepEquals不是数组，则Objects.deepEquals和Objects.equals相同。

于 2012-07-22T00:41:40.833 回答
1

例子：

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，如果恰好一个参数为 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。两个空值非常相等。如果两个参数都是数组，则使用 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):如果两个指定的 Objects 数组彼此相等，则返回 true。如果两个数组包含相同数量的元素，并且两个数组中所有对应的元素对相等，则认为这两个数组相等。

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)：如果两个指定的数组彼此深度相等，则返回 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;
}
于 2021-03-28T07:03:13.150 回答
1

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
    }
}
于 2017-09-01T09:20:07.690 回答
0

附上我在 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 是否相同：假

比较两个字符串数组s1：[一，二，三]和s2：[一，二，三]字符串数组s1和s2是否相等：true

比较两个字符串数组s2：[一，二，三]和s3：[零，二，三]字符串数组s2和s3是否相等：false

对象数组 o1: [one, [Ljava.lang.String;@19821f] 和 o2: [one, [Ljava.lang.String;@addbf1] 将对象数组 o1 和 o2 与 Arrays.equals 进行比较：false 比较对象数组 o1 和o2 与 Arrays.deepEquals : true

于 2016-04-28T15:42:42.810 回答