2つの異なるリストにまったく同じ要素が含まれているかどうかを確認する簡単な方法は？

標準Javaライブラリで、2つのリストにまったく同じ要素が含まれているかどうかを確認する最も簡単な方法は何ですか？

2つのリストが同じインスタンスであるかどうかは関係ありません。また、リストのtypeパラメータが異なるかどうかは関係ありません。

例えば

List list1
List<String> list2; 
// ... construct etc

list1.add("A");
list2.add("A"); 
// the function, given these two lists, should return true

おそらく私が知っている顔に私を見つめている何かがあるでしょう:-)

編集：明確にするために、正確に同じ要素と要素の数を順番に探していました。

順序を気にする場合は、equalsメソッドを使用します。

list1.equals(list2)

javadocから：

指定されたオブジェクトがこのリストと等しいかどうかを比較します。指定されたオブジェクトもリストであり、両方のリストのサイズが同じで、2つのリスト内の対応する要素のペアがすべて等しい場合にのみ、trueを返します。（（e1 == null？e2 == null：e1.equals（e2））の場合、2つの要素e1とe2は等しくなります。つまり、同じ要素が同じ順序で含まれている場合、2つのリストは等しいと定義されます。 。この定義により、equalsメソッドがListインターフェースのさまざまな実装にわたって適切に機能することが保証されます。

順序に関係なくチェックしたい場合は、すべての要素をセットにコピーし、結果のセットで等号を使用できます。

public static <T> boolean listEqualsIgnoreOrder(List<T> list1, List<T> list2) {
    return new HashSet<>(list1).equals(new HashSet<>(list2));
}

このアプローチの制限は、順序だけでなく重複要素の頻度も無視することです。たとえば、list1["A"、 "B"、 "A"]であり、list2["A"、 "B"、 "B"]の場合、Setアプローチはそれらが等しいと見なします。

順序に敏感ではないが重複の頻度に敏感である必要がある場合は、次のいずれかを実行できます。

• 別の質問に対するこの回答で行ったように、比較する前に両方のリスト（またはコピー）を並べ替えます
• またはすべての要素をマルチセットにコピーする

私はコメントでたくさんのものを投稿しました。

誰もがここで言うように、equals（）の使用は順序に依存します。順序を気にしない場合は、3つのオプションがあります。

オプション1

を使用しcontainsAll()ます。このオプションは、最悪の場合のパフォーマンスO（n ^ 2）を提供するため、私の意見では理想的ではありません。

オプション2

これには2つのバリエーションがあります。

2a）リストの順序を維持する必要がない場合はCollections.sort()、両方のリストで使用します。次にを使用しequals()ます。これはO（nlogn）です。これは、2つのソートを実行してからO（n）の比較を行うためです。

2b）リストの順序を維持する必要がある場合は、最初に両方のリストをコピーできます。次に、ソリューション2aを使用できます次に、コピーした両方のリストでをます。ただし、コピーが非常に高価な場合、これは魅力的でない場合があります。

これはにつながります：

オプション3

要件がパート2bと同じであるが、コピーが高すぎる場合。TreeSetを使用してソートを実行できます。各リストを独自のTreeSetにダンプします。セットでソートされ、元のリストはそのまま残ります。次にequals()、両方ので比較を実行しますTreeSet。TreeSetsSはO（nlogn）時間で構築することができ、equals() O（N）です。

好きなのを選びな ：-）。

編集：ローレンス・ゴンサルベスが指摘したのと同じ警告をほとんど忘れていました。TreeSet実装は重複を排除します。重複が気になる場合は、ソートされたマルチセットのようなものが必要になります。

Apache Commonsコレクションを使用している（または使用したい）場合は、CollectionUtils.isEqualCollectionを使用できます。これは、「特定のコレクションにまったく同じ要素がまったく同じカーディナリティで含まれている場合にtrueを返します」。

パーティーに非常に遅れましたが、このヌルセーフチェックを追加したいと思いました：

Objects.equals(list1, list2)

私はこれが古いスレッドであることを知っていますが、他のどの回答も私のユースケースを完全に解決しませんでした（Guava Multisetでも同じことができると思いますが、ここには例はありません）。申し訳ありませんがフォーマットしてください。私はまだスタック交換に投稿するのは初めてです。さらに、エラーがある場合はお知らせください

あなたが持ってList<T>いるとしましょうList<T> Bを、あなたは、彼らが次の条件と同等であるかどうかを確認したいです：

1）O（n）予想実行時間
2）等式は次のように定義されます：aまたはbのすべての要素について、aでの要素の出現回数は、bでの要素の出現回数と同じです。要素の等価性はT.equals（）として定義されます

private boolean listsAreEquivelent(List<? extends Object> a, List<? extends Object> b) {
    if(a==null) {
        if(b==null) {
            //Here 2 null lists are equivelent. You may want to change this.
            return true;
        } else {
            return false;
        }
    }
    if(b==null) {
        return false;
    }
    Map<Object, Integer> tempMap = new HashMap<>();
    for(Object element : a) {
        Integer currentCount = tempMap.get(element);
        if(currentCount == null) {
            tempMap.put(element, 1);
        } else {
            tempMap.put(element, currentCount+1);
        }
    }
    for(Object element : b) {
        Integer currentCount = tempMap.get(element);
        if(currentCount == null) {
            return false;
        } else {
            tempMap.put(element, currentCount-1);
        }
    }
    for(Integer count : tempMap.values()) {
        if(count != 0) {
            return false;
        }
    }
    return true;
}

ハッシュマップへのO（2 * n）挿入とO（3 * n）ハッシュマップ選択を実行しているため、実行時間はO（n）です。私はこのコードを完全にテストしていないので、注意してください:)

//Returns true:
listsAreEquivelent(Arrays.asList("A","A","B"),Arrays.asList("B","A","A"));
listsAreEquivelent(null,null);
//Returns false:
listsAreEquivelent(Arrays.asList("A","A","B"),Arrays.asList("B","A","B"));
listsAreEquivelent(Arrays.asList("A","A","B"),Arrays.asList("A","B"));
listsAreEquivelent(Arrays.asList("A","A","B"),null);

同じである必要はないが、同じ値を複数持つことをサポートするこのバージョンを試してください。それぞれが同じ量の値を持つ場合にのみ一致します。

public boolean arraysMatch(List<String> elements1, List<String> elements2) {
    // Optional quick test since size must match
    if (elements1.size() != elements2.size()) {
        return false;
    }
    List<String> work = newArrayList(elements2);
    for (String element : elements1) {
        if (!work.remove(element)) {
            return false;
        }
    }
    return work.isEmpty();
}

リストのequalsメソッドがこれを行います。リストは順序付けされているため、2つのリストが同じになるには、同じ要素が同じ順序である必要があります。

return list1.equals(list2);

2つのリストの要素が同じで順序が異なる場合の解決策：

public boolean isDifferentLists(List<Integer> listOne, List<Integer> listTwo) {
    if(isNullLists(listOne, listTwo)) {
        return false;
    }

    if (hasDifferentSize(listOne, listTwo)) {
        return true;
    }

    List<Integer> listOneCopy = Lists.newArrayList(listOne);
    List<Integer> listTwoCopy = Lists.newArrayList(listTwo);
    listOneCopy.removeAll(listTwoCopy);

    return CollectionUtils.isNotEmpty(listOneCopy);
}

private boolean isNullLists(List<Integer> listOne, List<Integer> listTwo) {
    return listOne == null && listTwo == null;
}

private boolean hasDifferentSize(List<Integer> listOne, List<Integer> listTwo) {
    return (listOne == null && listTwo != null) || (listOne != null && listTwo == null) || (listOne.size() != listTwo.size());
}

トムの答えは素晴らしいです私は彼の答えに完全に同意します！

この質問の興味深い側面は、List型自体とその固有の順序が必要かどうかです。

そうでない場合は、低下させることができるIterableか、またはCollection確認したいときではなく、挿入時にソートされたデータ構造を通過する際にある程度の柔軟性が得られます。

順序が重要でない場合（および要素が重複していない場合）、の使用を検討してくださいSet。

順序が重要であるが挿入時間によって定義されている場合（および重複がない場合）LinkedHashSet、TreeSetのようなものであるが、挿入時間によって順序付けられている（重複はカウントされない）と考えてください。これにより、にO(1)組み込まれた償却済みアクセスも提供されますO(log n)。

サンプルコード：

public static '<'T'>' boolean isListDifferent(List'<'T'>' previousList,
        List'<'T'>' newList) {

    int sizePrevoisList = -1;
    int sizeNewList = -1;

    if (previousList != null && !previousList.isEmpty()) {
        sizePrevoisList = previousList.size();
    }
    if (newList != null && !newList.isEmpty()) {
        sizeNewList = newList.size();
    }

    if ((sizePrevoisList == -1) && (sizeNewList == -1)) {
        return false;
    }

    if (sizeNewList != sizePrevoisList) {
        return true;
    }

    List n_prevois = new ArrayList(previousList);
    List n_new = new ArrayList(newList);

    try {
        Collections.sort(n_prevois);
        Collections.sort(n_new);
    } catch (ClassCastException exp) {
        return true;
    }

    for (int i = 0; i < sizeNewList; i++) {
        Object obj_prevois = n_prevois.get(i);
        Object obj_new = n_new.get(i);
        if (obj_new.equals(obj_prevois)) {
            // Object are same
        } else {
            return true;
        }
    }

    return false;
}

ローレンスの答えに加えて、ヌルセーフにしたい場合：

private static <T> boolean listEqualsIgnoreOrder(List<T> list1, List<T> list2) {
    if (list1 == null)
        return list2==null;
    if (list2 == null)
        return list1 == null;
    return new HashSet<>(list1).equals(new HashSet<>(list2));
}

list1.equals(list2);

リストにカスタムクラスMyClassが含まれている場合、このクラスはequals関数をオーバーライドする必要があります。

 class MyClass
  {
  int field=0;
  @0verride
  public boolean equals(Object other)
        {
        if(this==other) return true;
        if(other==null || !(other instanceof MyClass)) return false;
        return this.field== MyClass.class.cast(other).field;
        }
  }

注：ではなくjava.util.Setで同等をテストする場合は、java.util.ListオブジェクトでhashCode 関数をオーバーライドする必要があります。

List.equals（）

http://java.sun.com/j2se/1.5/docs/api/java/util/List.html#equals(java.lang.Object）

Apacheのorg.apache.commons.collectionsライブラリを使用できます。http： //commons.apache.org/collections/apidocs/org/apache/commons/collections/ListUtils.html

public static boolean isEqualList(java.util.Collection list1,
                              java.util.Collection list2)

両方のリストがnullでないことを確認してください。サイズが異なる場合、これらのリストは等しくありません。キーとしてのリストの要素と値としてのリピートで構成されるマップを作成し、マップを比較します。

仮定、両方のリストがnullの場合、それらは等しいと見なします。

private boolean compareLists(List<?> l1, List<?> l2) {
    if (l1 == null && l2 == null) {
        return true;
    } else if (l1 == null || l2 == null) {
        return false;
    }

    if (l1.size() != l2.size()) {
        return false;
    }

    Map<?, Integer> m1 = toMap(l1);
    Map<?, Integer> m2 = toMap(l2);

    return m1.equals(m2);
}

private Map<Object, Integer> toMap(List<?> list) {
    //Effective size, not to resize in the future.
    int mapSize = (int) (list.size() / 0.75 + 1);
    Map<Object, Integer> map = new HashMap<>(mapSize);

    for (Object o : list) {
        Integer count = map.get(o);
        if (count == null) {
            map.put(o, 1);
        } else {
            map.put(o, ++count);
        }
    }

    System.out.println(map);
    return map;
}

注意してください、これらのオブジェクトに対して等しいメソッドが適切に定義されている必要があります。 https://stackoverflow.com/a/24814634/4587961

使用している具象リストクラスによって異なります。抽象クラスAbstractCollectionには、別のコレクションを取得するcontainsAll（Collection）というメソッドがあります（リストはコレクションです）。

このコレクションに、指定されたコレクションのすべての要素が含まれている場合にtrueを返します。

したがって、ArrayListが渡されている場合は、このメソッドを呼び出して、それらがまったく同じかどうかを確認できます。

       List foo = new ArrayList();
    List bar = new ArrayList();
    String str = "foobar";

    foo.add(str);
    bar.add(str);

    foo.containsAll(bar);

containsAll（）の理由は、最初のリストを繰り返し処理して、2番目のリストで一致するものを探すためです。したがって、それらが順不同である場合、equals（）はそれを取得しません。

編集：私はここで、提供されているさまざまなオプションを実行するための償却実行時間についてコメントしたいと思います。実行時間は重要ですか？承知しました。あなたが考慮すべき唯一のことですか？番号。

すべての単一の要素をリストから他のリストにコピーするコストは時間がかかり、かなりの量のメモリを消費します（使用しているメモリを事実上2倍にします）。

したがって、JVMのメモリが問題にならない場合（通常は問題になるはずです）、2つのリストから2つのTreeSetにすべての要素をコピーするのにかかる時間を考慮する必要があります。要素に入るときにすべての要素をソートすることを忘れないでください。

最後のアドバイスは？ここで適切な決定を下す前に、データセットとデータセット内の要素の数、およびデータセット内の各オブジェクトの大きさを考慮する必要があります。それらをいじって、片道ずつ作成し、どれがより速く実行されるかを確認してください。それは良い運動です。