Einfacher Weg, um herauszufinden, ob zwei verschiedene Listen genau die gleichen Elemente enthalten?

Was ist der einfachste Weg, um festzustellen, ob zwei Listen in den Standard-Java-Bibliotheken genau dieselben Elemente enthalten?

Es sollte keine Rolle spielen, ob die beiden Listen dieselbe Instanz sind oder nicht, und es sollte keine Rolle spielen, ob die Typparameter der Listen unterschiedlich sind.

z.B

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

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

Wahrscheinlich starrt mich etwas ins Gesicht, das ich kenne :-)

EDIT: Zur Verdeutlichung habe ich nach genau den gleichen Elementen und der gleichen Anzahl von Elementen gesucht.

Wenn Sie sich für Ordnung interessieren, verwenden Sie einfach die Methode equals:

list1.equals(list2)

Aus dem Javadoc:

Vergleicht das angegebene Objekt mit dieser Liste auf Gleichheit. Gibt nur dann true zurück, wenn das angegebene Objekt auch eine Liste ist, beide Listen dieselbe Größe haben und alle entsprechenden Elementpaare in den beiden Listen gleich sind. (Zwei Elemente e1 und e2 sind gleich, wenn (e1 == null? E2 == null: e1.equals (e2)).) Mit anderen Worten, zwei Listen werden als gleich definiert, wenn sie dieselben Elemente in derselben Reihenfolge enthalten . Diese Definition stellt sicher, dass die Methode equals in verschiedenen Implementierungen der List-Schnittstelle ordnungsgemäß funktioniert.

Wenn Sie unabhängig von der Reihenfolge prüfen möchten, können Sie alle Elemente in Sets kopieren und für die resultierenden Sets Gleichheit verwenden:

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

Eine Einschränkung dieses Ansatzes besteht darin, dass nicht nur die Reihenfolge, sondern auch die Häufigkeit doppelter Elemente ignoriert wird. Wenn beispielsweise list1["A", "B", "A"] und list2["A", "B", "B"] Setwäre, würde der Ansatz sie als gleich betrachten.

Wenn Sie unempfindlich gegenüber Bestellungen sein müssen, aber empfindlich gegenüber der Häufigkeit von Duplikaten, können Sie entweder:

• Sortieren Sie beide Listen (oder Kopien), bevor Sie sie vergleichen, wie in dieser Antwort auf eine andere Frage beschrieben
• oder kopieren Sie alle Elemente in ein Multiset

Ich habe ein paar Dinge in Kommentaren gepostet, von denen ich denke, dass sie eine eigene Antwort rechtfertigen.

Wie jeder hier sagt, hängt die Verwendung von equals () von der Reihenfolge ab. Wenn Sie sich nicht für die Bestellung interessieren, haben Sie 3 Möglichkeiten.

Option 1

Verwenden Sie containsAll(). Diese Option ist meiner Meinung nach nicht ideal, da sie die Worst-Case-Leistung O (n ^ 2) bietet.

Option 2

Hierfür gibt es zwei Variationen:

2a) Wenn Sie die Reihenfolge Ihrer Listen nicht beibehalten möchten, verwenden Sie sie Collections.sort()für beide Listen. Dann benutzen Sie dieequals() . Dies ist O (nlogn), weil Sie zwei Sortierungen und dann einen O (n) -Vergleich durchführen.

2b) Wenn Sie die Reihenfolge der Listen beibehalten müssen, können Sie beide Listen zuerst kopieren. DANN können Sie Lösung 2a verwenden für beide kopierten Listen verwenden. Dies kann jedoch unattraktiv sein, wenn das Kopieren sehr teuer ist.

Dies führt zu:

Option 3

Wenn Ihre Anforderungen mit denen von Teil 2b übereinstimmen , das Kopieren jedoch zu teuer ist. Sie können ein TreeSet verwenden, um die Sortierung für Sie durchzuführen. Speichern Sie jede Liste in einem eigenen TreeSet. Es wird im Set sortiert und die ursprünglichen Listen bleiben erhalten. Führen Sie dann einen equals()Vergleich für beide TreeSets durch. Das TreeSetss kann in O (nlogn) -Zeit erstellt werden, und das equals()ist O (n).

Treffen Sie Ihre Wahl :-).

EDIT: Ich habe fast die gleiche Einschränkung vergessen, auf die Laurence Gonsalves hinweist. Die TreeSet-Implementierung eliminiert Duplikate. Wenn Sie sich für Duplikate interessieren, benötigen Sie eine Art sortiertes Multiset.

Wenn Sie Apache Commons-Sammlungen verwenden (oder gerne verwenden), können Sie CollectionUtils.isEqualCollection verwenden, die "true zurückgibt, wenn die angegebenen Sammlungen genau dieselben Elemente mit genau denselben Kardinalitäten enthalten".

Sehr spät zur Party, wollte aber diesen Null-Safe-Check hinzufügen:

Objects.equals(list1, list2)

Ich weiß, dass dies ein alter Thread ist, aber keine der anderen Antworten hat meinen Anwendungsfall vollständig gelöst (ich denke, Guava Multiset könnte dasselbe tun, aber hier gibt es kein Beispiel). Bitte entschuldigen Sie meine Formatierung. Ich bin noch neu im Stack Exchange. Lassen Sie mich außerdem wissen, wenn Fehler vorliegen

Nehmen wir an, Sie haben List<T>a und List<T>b und möchten überprüfen, ob sie den folgenden Bedingungen entsprechen:

1) O (n) erwartete Laufzeit
2) Gleichheit ist definiert als: Für alle Elemente in a oder b ist die Häufigkeit, mit der das Element in a auftritt, gleich der Häufigkeit, mit der das Element in b auftritt. Elementgleichheit ist definiert als 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;
}

Die Laufzeit beträgt O (n), da O (2 * n) in eine Hashmap eingefügt und O (3 * n) ausgewählt wird. Ich habe diesen Code nicht vollständig getestet, also Vorsicht :)

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

Probieren Sie diese Version aus, für die keine gleiche Reihenfolge erforderlich ist, die jedoch mehrere gleiche Werte unterstützt. Sie stimmen nur überein, wenn jede die gleiche Menge eines Wertes hat.

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

Die Methode equals in List führt dies aus. Listen werden geordnet. Um gleich zu sein, müssen zwei Listen dieselben Elemente in derselben Reihenfolge haben.

return list1.equals(list2);

Lösung für den Fall, dass zwei Listen dieselben Elemente, aber unterschiedliche Reihenfolge haben:

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

Toms Antwort ist ausgezeichnet. Ich stimme seinen Antworten voll und ganz zu!

Ein interessanter Aspekt dieser Frage ist, ob Sie die brauchen List Typ selbst und seine inhärente Reihenfolge .

Wenn nicht, können Sie Datenstrukturen, die nach der Einfügezeit sortiert sind, und nicht zu dem Zeitpunkt, zu dem Sie sie überprüfen möchten, verschlechtern Iterableoder Collectionflexibel weitergeben.

Wenn die Reihenfolge keine Rolle spielt (und Sie keine doppelten Elemente haben), sollten Sie a verwenden Set.

Wenn die Reihenfolge wichtig ist, aber durch LinkedHashSetdie Einfügezeit definiert ist (und Sie keine Duplikate haben), berücksichtigen Sie eine, die einem TreeSet ähnelt, aber nach der Einfügezeit sortiert ist (Duplikate werden nicht gezählt). Dies gibt Ihnen auch einen O(1)amortisierten Zugriff O(log n).

Beispielcode:

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

Zusätzlich zu Laurences Antwort, wenn Sie es auch null-sicher machen möchten:

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

Wenn Ihre Liste eine benutzerdefinierte Klasse MyClass enthält, muss diese Klasse die equalsFunktion überschreiben .

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

Hinweis: Wenn Sie Equals auf einer java.util.Set anstelle von a testen möchten, java.util.Listmuss Ihr Objekt die hashCode Funktion überschreiben .

List.equals ()

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

Sie können die Bibliothek org.apache.commons.collections von Apache verwenden: http://commons.apache.org/collections/apidocs/org/apache/commons/collections/ListUtils.html

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

Überprüfen Sie, ob beide Listen keine Nullen sind. Wenn ihre Größen unterschiedlich sind, sind diese Listen nicht gleich. Erstellen Sie Karten, die aus den Elementen der Listen als Schlüssel und deren Wiederholungen als Werte bestehen, und vergleichen Sie die Karten.

Annahmen, wenn beide Listen Nullen sind, halte ich sie für gleich.

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

Bitte beachten Sie, dass für diese Objekte die Methode equals richtig definiert werden sollte. https://stackoverflow.com/a/24814634/4587961

Dies hängt davon ab, welche konkrete List-Klasse Sie verwenden. Die abstrakte Klasse AbstractCollection verfügt über eine Methode namens includesAll (Collection), die eine andere Sammlung (eine Liste ist eine Sammlung) verwendet, und:

Gibt true zurück, wenn diese Auflistung alle Elemente in der angegebenen Auflistung enthält.

Wenn also eine ArrayList übergeben wird, können Sie diese Methode aufrufen, um festzustellen, ob sie genau gleich sind.

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

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

    foo.containsAll(bar);

Der Grund für includesAll () ist, dass die erste Liste durchlaufen wird, um nach der Übereinstimmung in der zweiten Liste zu suchen. Wenn sie also nicht in Ordnung sind, wird equals () sie nicht abholen.

BEARBEITEN: Ich möchte hier nur einen Kommentar zur amortisierten Laufzeit der Ausführung der verschiedenen angebotenen Optionen abgeben. Ist die Laufzeit wichtig? Sicher. Ist es das einzige, was Sie berücksichtigen sollten? Nein.

Die Kosten für das Kopieren JEDES einzelnen Elements aus Ihren Listen in andere Listen nehmen Zeit in Anspruch und beanspruchen außerdem einen guten Speicherplatz (wodurch der von Ihnen verwendete Speicher effektiv verdoppelt wird).

Wenn der Speicher in Ihrer JVM kein Problem darstellt (was im Allgemeinen der Fall sein sollte), müssen Sie dennoch die Zeit berücksichtigen, die erforderlich ist, um jedes Element aus zwei Listen in zwei TreeSets zu kopieren. Denken Sie daran, dass jedes Element beim Eintritt sortiert wird.

Mein letzter Rat? Sie müssen Ihren Datensatz und die Anzahl der Elemente in Ihrem Datensatz sowie die Größe jedes Objekts in Ihrem Datensatz berücksichtigen, bevor Sie hier eine gute Entscheidung treffen können. Spielen Sie mit ihnen herum, erstellen Sie eine in jede Richtung und sehen Sie, welche schneller läuft. Es ist eine gute Übung.