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

我只是想知道-为什么array.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");

double[]a，b；
int size=5；
a=新的双[尺寸][尺寸]；
b=新的双[尺寸][尺寸]；
对于（int i=0；i

返回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");

double[]a，b；
int size=5；
a=新的双[尺寸]；
b=新的双[尺寸]；
对于（int i=0；i

返回true并打印“Equal”。该方法是否仅适用于单个尺寸？如果是这样，Java中的多维数组是否也有类似的功能？

使用

如果指定的两个数组彼此非常相等，则返回

true

由于

int[]

是对象的

实例

，因此

int[][]

是对象的

实例

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

---

至于为什么

Arrays.equals

对二维数组不“起作用”，可以逐步解释如下：

对于数组，

equals

是根据对象标识定义的 这是因为数组从它们的公共超类继承了它们的

equals

当然，通常我们确实希望数组的值相等，这就是为什么

java.util.arrays

提供

static

实用方法

equals（int[]，int[]）

Java中的数组数组

• int[]

  是对象的

  实例

• int[][]

  是对象[]

• int[][]

  不是

  int[]

  instanceof int[]

Java实际上没有二维数组。它甚至没有真正的多维数组。Java有数组数组

java.util.array.equals

是“浅层的”

现在考虑这个片段：

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

事实如下：

• 每个参数都是一个

  对象[]

  • 索引0处的元素是

    int[]{1}

  • 索引1处的元素是

    int[]{2,3}

• 有两个

  Object[]

  实例
• 有四个

  int[]

  实例

从上一点可以清楚地看到，这会调用重载。从API：

如果指定的两个

对象数组

相等，则返回

true

。如果两个数组包含相同数量的元素，并且两个数组中所有对应的元素对都相等，则认为这两个数组是相等的。如果

（e1==null？e2==null:e1.equals（e2））

，则认为两个对象

e1

和

e2

相等

现在应该清楚了，为什么上面的代码片段会显示“false”；这是因为根据上述定义，

Object[]

数组的元素不相等（因为

int[]

的

等于对象标识定义的
）

java.util.Arrays.deepEquals
是“deep”
相比之下，以下是它的作用：

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


在
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]]"

同样，推理也是类似的：
array.toString（Object[]）
将每个元素视为一个
对象，只需调用其
toString（）
方法即可。数组从其公共超类
对象继承其
toString（）

如果你想用代码> java .UTI.java数组/代码>来考虑嵌套数组，你需要使用 Debug字符串> /Cuth>，就像你需要使用<代码> DePiQuals。
 < P> Java实际上并没有多维数组。取而代之的是，它只有一维数组，而多维数组将是这个一维数组的数组。String.equals（）只能对基本的单块数组执行，因此它不适用于多维数组。
解释得很好。。。我之前确实尝试过点击它，但被要求等待10分钟：）。。。阿基里斯：我尽力做到最好。我很乐意帮忙。事实上：很好的解释+1还有deepHashCode（），它对于创建“值对象”非常有用，您可以在其中同时实现“equals（）”和“hashCode（）”。如专业人士所述！谢谢你的详细解释
System.out.println(
    java.util.Arrays.deepEquals(
        new int[][] {
            { 1 },
            { 2, 3 },
        },
        new int[][] {
            { 1 },
            { 2, 3 },
        }
    )
); // prints "true"

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]]"