array1.equals(array2)与array1 == array2相同，也就是说，它是同一个数组吗？As @alf points out这不是大多数人所期望的。
Arrays.equals(array1, array2)比较数组的内容。
类似地，array.toString()可能不是很有用，您需要使用Arrays.toString(array)。

这是个臭名昭著的问题：数组的.equals()是严重损坏的，请不要使用它。
也就是说，它并不是“某人以一种非常错误的方式做了这件事”那样的“坏”--它只是做了定义好的事情，而不是通常期望的事情。它是完美的，这也意味着，* 永远不要用它 *
现在equals的预期行为是比较数据，默认行为是比较身份，因为Object没有任何数据（对于纯粹主义者：是的，它有，但这不是重点）;假设，如果你在子类中需要equals，你会实现它，在数组中，没有适合你的实现，所以你不应该使用它。
因此，不同之处在于，Arrays.equals(array1, array2)的工作方式 * 正如您所期望的 *（即比较内容），x1m5 n1福尔斯到Object.equals实现，后者反过来比较身份，因此最好替换为==（对于纯粹主义者来说：是的，我知道null）。
问题是，如果数组的元素不能正确实现equals，那么即使Arrays.equals(array1, array2)也会让你大吃一惊。我知道这是一个非常天真的说法，但有一个非常重要的不太明显的情况：考虑2D阵列。
Java中的2D数组是数组的数组，数组的equals是坏的（或者如果你愿意的话是无用的），所以Arrays.equals(array1, array2)不会像你期望的那样在2D数组上工作。

深入了解这两种方法的实现，以深入理解它们：

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);
}

同时：
一个二个一个一个

唉，早在70年代，我是IBM 370系统的“系统程序员”（sysadmin），我的雇主是IBM用户组SHARE的成员。有时会发生这样的情况，有人提交了一份关于CMS命令的意外行为的APAR（bug report），IBM会回复NOTABUG：该命令执行它被设计来执行的操作（以及文档所说的操作）。
SHARE想出了一个对策：坏--按设计破坏。我想这可能适用于数组的equals的实现。
Object. equals的实现没有任何问题。Object没有数据成员，因此没有什么可比较的。两个“Object“是相等的，当且仅当它们实际上是同一个Object（内部地址和长度相同）。
但是这种逻辑不适用于数组，数组有数据，你期望比较（通过equals）来比较数据，理想情况下，Arrays.deepEquals是这样做的，但至少Arrays.equals是这样做的（元素的浅层比较）。
所以问题是array（作为一个内置对象）不覆盖Object. equals。String（作为一个命名类）* 不 * 覆盖Object.equals并给予您期望的结果。
其他答案正确：[...].equals（[....]）只是比较指针而不是内容。也许有一天会有人纠正这一点。也可能不会：如果[...].equals实际比较元素，有多少现有程序会崩溃？我怀疑不是很多，但超过零。

数组从Object继承equals()，因此只有在数组与自身比较时，compare才返回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().

数组的equals()继承自Object，因此它不查看数组的内容，它只认为每个数组等于其自身。
Arrays.equals()方法比较数组的内容，所有的原语类型都有重载，对象的重载使用对象自己的equals()方法。

Arrays.equals(array1, array2)：
检查两个数组是否包含相同数量的元素，以及两个数组中所有对应的元素对是否相等。
array1.equals(array2)：
将对象与另一个对象进行比较，仅当两个对象的引用相同时才返回true，如Object.equals()中所示

import java.util.Arrays;
public class ArrayDemo {
   public static void main(String[] args) {
   // initializing three object arrays
   Object[] array1 = new Object[] { 1, 123 };
   Object[] array2 = new Object[] { 1, 123, 22, 4 };
   Object[] array3 = new Object[] { 1, 123 };

   // comparing array1 and array2
   boolean retval=Arrays.equals(array1, array2);
   System.out.println("array1 and array2 equal: " + retval);
   System.out.println("array1 and array2 equal: " + array1.equals(array2));

   // comparing array1 and array3
   boolean retval2=Arrays.equals(array1, array3);
   System.out.println("array1 and array3 equal: " + retval2);
   System.out.println("array1 and array3 equal: " + array1.equals(array3));

   }
}

下面是输出：

array1 and array2 equal: false
    array1 and array2 equal: false

    array1 and array3 equal: true
    array1 and array3 equal: false

看到这种问题，我个人会按照你的问题选择Arrays.equals(array1, array2)，以避免混淆。

我认为Objects.deepEquals（Obj1，Obj2）是这里最好的统一解决方案，如果Obj1和Obj2是两个int数组，它会为你调用Arrays.deepEquals0（a，b）方法，如果你不是比较字符串，它只会使用“.equals”（“==”）传统方法，所以在比较字符串的时候也是非常有用的。
它将涵盖那些正常的用法，如butter，不需要记住什么时候使用（）.equals（），Arrays.equals，（String a）.equals（（String b））或任何东西。
这个Objects.deepEquals操作的时间复杂度是O（n）。

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);
    }

常见用法如下：比较整数数组，哇：

int[] num1 = { 1, 2, 3, 4 };
int[] num2 = { 1, 2, 3, 4 };
System.out.println(Objects.deepEquals(num1, num2));

还可以比较2D数组，非常好：

int[][] nums1 = { { 1, 2 }, { 2, 3 }, { 3, 4 } };
int[][] nums2 = { { 1, 2 }, { 2, 3 }, { 3, 4 } };
System.out.println(Objects.deepEquals(nums1, nums2));

比较字符串，甚至更大：

String s1 = "sasfd!";
String s2 = "sasfd" + "!";
System.out.println(Objects.deepEquals(s1, s2));

我喜欢普遍适用的方法