web-dev-qa-db-ja.com

Javaにおけるequals vs Arrays.equals

Javaで配列を比較するとき、次の2つのステートメントに違いはありますか？

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

そしてもしそうなら、彼らは何ですか？

javaarraysequality
195
PandaConda

array1.equals(array2)はarray1 == array2と同じ、つまり同じ配列です。 @ alfが指摘するように、それはほとんどの人が期待するものではありません。

Arrays.equals(array1, array2)は配列の内容を比較します。

同様にarray.toString()はそれほど便利ではないかもしれず、あなたはArrays.toString(array)を使う必要があります。

281
Peter Lawrey

これは悪名高い問題です。配列の.equals()はひどく壊れています。決して使わないでください。

それは言った、「誰かが本当に間違った方法でそれをやった」のように「壊れて」いるのではありません - それは定義されたことをやっているだけで通常は期待されていることではありません。純粋主義者のために：それは完全に素晴らしいです、そしてそれはまた、意味しています決して、それを使わないでください

equalsの期待される動作はデータの比較です。 Objectはデータを持っていないので、デフォルトの振る舞いはアイデンティティを比較することです（純粋主義者のために：はい、持っていますが、それは重要ではありません）。あなたがサブクラスでequalsを必要とするならば、あなたはそれを実行すると仮定します。配列には実装はありませんので、使うべきではありません。

違いはArrays.equals(array1, array2)はうまくいく期待どおり（つまり内容を比較する）、array1.equals(array2)はObject.equalsの実装にフォールバックし、それが今度はアイデンティティーを比較するので、==に置き換えられたほうがよい（純粋主義者のために：はい） null）について.

問題は、arrayの要素がequalsを適切に実装していない場合、Arrays.equals(array1, array2)でさえ難しくなることです。私は知っていますが、これは非常に素朴な文ですが、あまり重要ではないが明白なケースがあります。2次元配列を考えてみましょう。

Javaの2D配列は配列の配列であり、配列のequalsは壊れています（またはお望みであれば役に立ちません）。したがって、Arrays.equals(array1, array2)は2D配列では期待通りに動作しません。

それが役立つことを願っています。

80
alf

それらを深く理解するために2つの方法の実装を見てください。

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;
}
16
Eng.Fouad

ため息70年代に私はIBM 370システムの「システム・プログラマー」（sysadmin）であり、私の雇用者はIBMユーザー・グループSHAREのメンバーでした。 CMSコマンドの予期しない動作についてAPAR（バグレポート）が送信されることもあります。IBMはNOTABUGと応答します。このコマンドは実行するように設計されたもの（およびドキュメントに記載されているもの）を実行します。

SHAREはこれに対するカウンターを思い付いた：悪い - 設計どおりに壊れた。これは、配列に対するequalsのこの実装にも当てはまると思います。

Object.equalsの実装に問題はありません。オブジェクトにはデータメンバがないため、比較するものはありません。 2つの「オブジェクト」は、実際には同じオブジェクト（内部的には同じアドレスと長さ）である場合に限り、等しくなります。

しかし、その論理は配列には当てはまりません。配列にはデータがあり、データを比較するためには（equalsを介して）比較する必要があります。理想的には、Arrays.deepEqualsが行う方法ですが、少なくともArrays.equalsが行う方法（要素の浅い比較）は理想的です。

問題は、（組み込みオブジェクトとしての）配列がObject.equalsをオーバーライドしないことです。文字列（名前付きクラスとして）する Object.equalsをオーバーライドしてあなたが期待する結果を返す。

与えられた他の答えは正しいです：[...]。equals（[....]）は単にポインタではなく内容を比較します。たぶんいつか誰かがこれを修正するでしょう。それともそうではないかもしれません：[...]が実際に要素を比較した場合、いくつの既存のプログラムが壊れるのでしょうか。多くはありませんが、ゼロ以上です。

10
A. P. Damien

配列は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() 。

5
Adam Zalcman

Arrays.equals(array1, array2)：

両方の配列が同じ数の要素を含み、2つの配列内の対応する要素のペアがすべて等しいかどうかを確認します。

array1.equals(array2)：

そのオブジェクトを別のオブジェクトと比較し、2つのオブジェクトの参照がObject.equals()のように等しい場合にのみtrueを返します。

1
aleroot

配列のequals()はObjectから継承されているので、配列の内容は調べず、各配列をそれ自体と等しいと見なすだけです。

Arrays.equals()メソッドdoは配列の内容を比較します。すべてのプリミティブ型にはオーバーロードがあり、オブジェクト用のものはオブジェクト自身のequals()メソッドを使用します。

0
Michael Borgwardt
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)に個人的に行きます。

0
Tayyab