Java Arrays.equals（）对于二维数组返回false

Question

我只是想知道-为什么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并输出“等于”。该方法仅适用于单个尺寸吗？如果是这样，Java中的多维数组是否有类似的东西？

Answer 1

使用deepEquals(Object[], Object[])。

true如果两个指定的数组彼此深度相等，则返回。

由于an int[]是an instanceof Object，所以an int[][]是an instanceof Object[]。

至于为什么 Arrays.equals不能对二维数组“起作用”，可以逐步解释如下：

对于数组，equals是根据对象标识定义的

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

这是因为数组equals从其公共超类继承Object。

当然，我们通常经常真的想要数组的值相等，这就是为什么要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中的数组数组

安int[]是一个instanceof Object
安int[][]是一个instanceof Object[]
一个int[][]是不是一个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"

这是事实：

每个参数都是 Object[]
索引为0的元素是 int[] { 1 }
索引1处的元素是int[] { 2, 3 }。
有两种Object[]情况
有四个int[]实例
从上一点应该清楚的是，这会引起Arrays.equals(Object[], Object[])过载。从API：

返回true两个指定的数组是否Objects彼此相等。如果两个数组都equal包含相同数量的元素，并且两个数组中所有对应的元素对均相等，则考虑这两个数组。如果e1 ，e2则两个对象和相等(e1==null ? e2==null : e1.equals(e2))。

现在应该清楚为什么上面的片段会打印”false”; 这是因为所述的元件Object[]阵列是不是由上面的定义相同（因为一个int[]具有其equals由对象标识定义）。

java.util.Arrays.deepEquals 是“深”
相反，这是做什么的Arrays.deepEquals(Object[], Object[])：

true如果两个指定的数组彼此深度相等，则返回。与equals(Object[],Object[])方法不同，此方法适用于任意深度的嵌套数组。

System.out.println(
    java.util.Arrays.deepEquals(
        new int[][] {
            { 1 },
            { 2, 3 },
        },
        new int[][] {
            { 1 },
            { 2, 3 },
        }
    )
); // prints "true"
在Arrays.toString和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。