Java Arrays.equals() 对于二维数组返回 false

我只是想知道 - 为什么 Arrays.equals(double[][], double[][]) 返回 false？事实上，数组具有相同数量的元素并且每个元素都相同？

例如我进行了以下测试。

double[][] a,  b;
int size =5;

a=new double[size][size];
b=new double[size][size];

for( int i = 0; i < size; i++ )
    for( int j = 0; j < size; j++ ) {
        a[i][j]=1.0;
        b[i][j]=1.0;
    }

if(Arrays.equals(a, b))
    System.out.println("Equal");
else
    System.out.println("Not-equal");

返回 false 并打印“不等于”。

另一方面，如果我有这样的事情：

double[] a,  b;
int size =5;

a=new double[size];
b=new double[size];

for( int i = 0; i < size; i++ ){
    a[i]=1.0;
    b[i]=1.0;
} 

if(Arrays.equals(a, b))
    System.out.println("Equal");
else
    System.out.println("Not-equal");

返回 true 并打印“Equal”。该方法仅适用于单一维度吗？如果是这样，Java中的多维数组是否有类似的东西？

Use deepEquals(Object[], Object[]) http://java.sun.com/javase/6/docs/api/java/util/Arrays.html#deepEquals%28java.lang.Object%5B%5D,%20java.lang.Object%5B%5D%29.

Returns true如果两个指定的数组是深度平等彼此。

自从int[] is an instanceof Object, an int[][] is an instanceof Object[].

As to why Arrays.equals对于二维数组不起作用，可以逐步解释如下：

对于数组来说，equals根据对象身份定义

System.out.println(
    (new int[] {1,2}).equals(new int[] {1,2})
); // prints "false"

这是因为数组继承了它们的equals来自他们共同的超类，Object http://java.sun.com/javase/6/docs/api/java/lang/Object.html#equals%28java.lang.Object%29.

当然，通常我们确实希望数组的值相等，这就是为什么java.util.Arrays提供了static实用方法equals(int[], int[]).

System.out.println(
    java.util.Arrays.equals(
        new int[] {1,2},
        new int[] {1,2}
    )
); // prints "true"

Java 中的数组数组

• An int[] is an instanceof Object
• An int[][] is an instanceof Object[]
• An int[][] is NOT an instanceof int[]

Java 并没有真正的二维数组。它甚至没有真正的多维数组。 Java 有数组的数组。

java.util.Arrays.equals是“浅”

现在考虑这个片段：

System.out.println(
    java.util.Arrays.equals(
        new int[][] {
            { 1 },
            { 2, 3 },
        },
        new int[][] {
            { 1 },
            { 2, 3 },
        }
    )
); // prints "false"

以下是事实：

• Each argument is an Object[]
  • 索引 0 处的元素是int[] { 1 }
  • 索引 1 处的元素是int[] { 2, 3 }.
• 那里有两个Object[]实例
• 有四个int[]实例

从上一点应该可以清楚地看出，这会调用Arrays.equals(Object[], Object[]) http://java.sun.com/javase/6/docs/api/java/util/Arrays.html#equals%28java.lang.Object%5B%5D,%20java.lang.Object%5B%5D%29超载。从API：

Returns true如果两个指定的数组Objects彼此相等。考虑两个数组equal如果两个数组包含相同数量的元素，并且两个数组中所有对应的元素对都相等。两个物体e1 and e2被认为是相等的，如果(e1==null ? e2==null : e1.equals(e2)).

现在应该清楚为什么上面的代码片段会打印了"false";这是因为Object[]根据上面的定义，数组不相等（因为int[]有它的equals由对象标识定义）。

java.util.Arrays.deepEquals是“深”

相比之下，这是Arrays.deepEquals(Object[], Object[]) http://java.sun.com/javase/6/docs/api/java/util/Arrays.html#deepEquals%28java.lang.Object%5B%5D,%20java.lang.Object%5B%5D%29 does:

Returns true如果两个指定的数组是deeply彼此平等。不像equals(Object[],Object[])方法，此方法适用于任意深度的嵌套数组。

System.out.println(
    java.util.Arrays.deepEquals(
        new int[][] {
            { 1 },
            { 2, 3 },
        },
        new int[][] {
            { 1 },
            { 2, 3 },
        }
    )
); // prints "true"

On Arrays.toString and Arrays.deepToString

值得注意的是这两种方法与我们迄今为止讨论的有关嵌套数组的类比。

System.out.println(
    java.util.Arrays.toString(
        new int[][] {
            { 1 },
            { 2, 3 },
        }
    )
); // prints "[[I@187aeca, [I@e48e1b]"

System.out.println(
    java.util.Arrays.deepToString(
        new int[][] {
            { 1 },
            { 2, 3 },
        }
    )
); // prints "[[1], [2, 3]]"

同样，推理是相似的：Arrays.toString(Object[])将每个元素视为Object，然后调用它的toString()方法。数组继承它的toString()来自他们共同的超类Object.

如果你想java.util.Arrays要考虑嵌套数组，您需要使用deepToString，就像你需要使用deepEquals.