等于Java中的Arrays.equals

在Java中比较数组时，以下两个语句之间是否有区别？

array1.equals(array2); Arrays.equals(array1, array2); 

如果是的话，他们是什么？

Answer 1

array1.equals(array2)和array1 == array2是一样的，也就是说它是相同的数组。 正如@alf指出，这不是大多数人的期望。

Arrays.equals(array1, array2)比较数组的内容。

---

同样， array.toString()可能不是很有用，你需要使用Arrays.toString(array) 。

Answer 2

这是一个臭名昭着的问题：数组的.equals()被严重破坏，只是不要使用它。

也就是说，这并不是像“某人以一种非常错误的方式做到的那样”“破碎”的 – 它只是在做所定义的事情，而不是通常所期望的事情。 所以对于纯粹主义者来说：这是完美的，也意味着， 不要使用它。

现在equals的预期行为是比较数据。 默认行为是比较身份，因为Object没有任何数据（纯粹主义者：是的，但它不是重点）; 假设是，如果你需要在子类中的equals ，你会实现它。 在数组中，没有实现，所以你不应该使用它。

所以区别在于， Arrays.equals(array1, array2) 按照你所期望的那样工作 （即比较内容）， array1.equals(array2)回落到Object.equals实现，这反过来又比较了identity，因此更好地被== （纯粹主义者：是的，我知道关于null ）。

问题是，即使Arrays.equals(array1, array2)会咬你硬如果数组的元素不正确地实现equals 。 我知道这是一个非常天真的声明，但是有一个非常重要的不太明显的情况：考虑一个二维数组。

Java中的2D数组是数组的数组，并且数组的equals是断开的（或者如果您愿意，也是无用的），所以Arrays.equals(array1, array2)将无法像您期望的那样工作在2D数组上。

希望有所帮助。

Answer 3

深入了解这两种方法的实施情况：

 array1.equals(array2); 

 /** * Indicates whether some other object is "equal to" this one. * <p> * The {@code equals} method implements an equivalence relation * on non-null object references: * <ul> * <li>It is <i>reflexive</i>: for any non-null reference value * {@code x}, {@code x.equals(x)} should return * {@code true}. * <li>It is <i>symmetric</i>: for any non-null reference values * {@code x} and {@code y}, {@code x.equals(y)} * should return {@code true} if and only if * {@code y.equals(x)} returns {@code true}. * <li>It is <i>transitive</i>: for any non-null reference values * {@code x}, {@code y}, and {@code z}, if * {@code x.equals(y)} returns {@code true} and * {@code y.equals(z)} returns {@code true}, then * {@code x.equals(z)} should return {@code true}. * <li>It is <i>consistent</i>: for any non-null reference values * {@code x} and {@code y}, multiple invocations of * {@code x.equals(y)} consistently return {@code true} * or consistently return {@code false}, provided no * information used in {@code equals} comparisons on the * objects is modified. * <li>For any non-null reference value {@code x}, * {@code x.equals(null)} should return {@code false}. * </ul> * <p> * The {@code equals} method for class {@code Object} implements * the most discriminating possible equivalence relation on objects; * that is, for any non-null reference values {@code x} and * {@code y}, this method returns {@code true} if and only * if {@code x} and {@code y} refer to the same object * ({@code x == y} has the value {@code true}). * <p> * Note that it is generally necessary to override the {@code hashCode} * method whenever this method is overridden, so as to maintain the * general contract for the {@code hashCode} method, which states * that equal objects must have equal hash codes. * * @param obj the reference object with which to compare. * @return {@code true} if this object is the same as the obj * argument; {@code false} otherwise. * @see #hashCode() * @see java.util.HashMap */ public boolean equals(Object obj) { return (this == obj); } 

而：

 Arrays.equals(array1, array2); 

 /** * Returns <tt>true</tt> if the two specified arrays of Objects are * <i>equal</i> to one another. The two arrays are considered equal if * both arrays contain the same number of elements, and all corresponding * pairs of elements in the two arrays are equal. Two objects <tt>e1</tt> * and <tt>e2</tt> are considered <i>equal</i> if <tt>(e1==null ? e2==null * : e1.equals(e2))</tt>. In other words, the two arrays are equal if * they contain the same elements in the same order. Also, two array * references are considered equal if both are <tt>null</tt>.<p> * * @param a one array to be tested for equality * @param a2 the other array to be tested for equality * @return <tt>true</tt> if the two arrays are equal */ 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++) { Object o1 = a[i]; Object o2 = a2[i]; if (!(o1==null ? o2==null : o1.equals(o2))) return false; } return true; } 

Answer 4

叹。 早在70年代，我就是IBM 370系统的“系统程序员”（sysadmin），而我的雇主是IBM用户组SHARE的成员。 有时会发生某人提交了某个CMS命令的某些意外行为的APAR（错误报告），IBM会回应NOTABUG：该命令执行了它devise要做的事情（以及文档说的）。

SHARE提出反对这个：坏 – devise破碎。 我想这可能适用于这个数组的equals实现。

Object.equals的实现没有任何问题。 对象没有数据成员，所以没有什么可比较的。 当且仅当两个“对象”实际上是相同的对象（在内部，相同的地址和长度）时是相等的。

但是这个逻辑不适用于数组。 数组有数据，并且您希望比较（通过等于）比较数据。 理想情况下，Arrays.deepEquals的方式，但至less是Arrays.equals的方式（元素的浅层比较）。

所以问题是数组（作为内置对象）不会覆盖Object.equals。 string（作为一个命名的类） 不重写Object.equals并给出你期望的结果。

其他答案是正确的：[…]。equals（[…]）只是比较指针而不是内容。 也许有一天有人会纠正这一点。 或者可能不是：如果equals实际上比较了这些元素，那么现有的程序将会中断多less？ 我怀疑不是很多，但超过零。

Answer 5

数组从Objectinheritanceequals() ，因此比较仅在比较数组和自身时返回true。

另一方面， Arrays.equals比较数组的元素。

这个片段阐明了这个区别：

 Object o1 = new Object(); Object o2 = new Object(); Object[] a1 = { o1, o2 }; Object[] a2 = { o1, o2 }; System.out.println(a1.equals(a2)); // prints false System.out.println(Arrays.equals(a1, a2)); // prints true 

另请参阅Arrays.equals() 。 另一个静态方法也可能是有趣的： Arrays.deepEquals() 。

Answer 6

Arrays.equals(array1, array2) ：

检查两个数组是否包含相同数量的元素，并且两个数组中的所有相应元素对是否相等。

array1.equals(array2) ：

将该对象与另一个对象进行比较，并且只有在两个对象的引用相同（如Object.equals()时才返回true。

Answer 7

数组的equals()是从Objectinheritance的，所以它不会看arrrays的内容，它只考虑每个数组等于它自己。

Arrays.equals()方法可以比较数组的内容。 所有原始types都有重载，而对象使用对象自己的equals()方法。