Ich habe zwei ArrayLists vom Typ Answer(selbstgemachte Klasse).

Ich möchte die beiden Listen vergleichen, um festzustellen, ob sie denselben Inhalt enthalten, jedoch ohne dass die Reihenfolge von Bedeutung ist.

Beispiel:

//These should be equal.
ArrayList<String> listA = {"a", "b", "c"}
ArrayList<String> listB = {"b", "c", "a"}

List.equalsgibt an, dass zwei Listen gleich sind, wenn sie dieselbe Größe, denselben Inhalt und dieselbe Reihenfolge von Elementen enthalten. Ich möchte das Gleiche, aber ohne dass die Reihenfolge von Bedeutung ist.

Gibt es eine einfache Möglichkeit, dies zu tun? Oder muss ich eine verschachtelte for-Schleife erstellen und jeden Index beider Listen manuell überprüfen?

Hinweis: Ich kann sie nicht von ArrayListeinem anderen Listentyp ändern , das müssen sie bleiben.

Sie können beide Listen mit Collections.sort()der Methode equals sortieren und dann verwenden. Eine etwas bessere Lösung besteht darin, vor der Bestellung zu überprüfen, ob sie gleich lang sind. Wenn dies nicht der Fall ist, sind sie nicht gleich, sortieren und verwenden dann gleich. Wenn Sie beispielsweise zwei Listen mit Zeichenfolgen hätten, wäre dies ungefähr so:

public  boolean equalLists(List<String> one, List<String> two){     
    if (one == null && two == null){
        return true;
    }

    if((one == null && two != null) 
      || one != null && two == null
      || one.size() != two.size()){
        return false;
    }

    //to avoid messing the order of the lists we will use a copy
    //as noted in comments by A. R. S.
    one = new ArrayList<String>(one); 
    two = new ArrayList<String>(two);   

    Collections.sort(one);
    Collections.sort(two);      
    return one.equals(two);
}

Der wahrscheinlich einfachste Weg für eine Liste wäre:

listA.containsAll(listB) && listB.containsAll(listA)

Apache Commons Sammlungen zur Rettung noch einmal:

List<String> listA = Arrays.asList("a", "b", "b", "c");
List<String> listB = Arrays.asList("b", "c", "a", "b");
System.out.println(CollectionUtils.isEqualCollection(listA, listB)); // true

List<String> listC = Arrays.asList("a", "b", "c");
List<String> listD = Arrays.asList("a", "b", "c", "c");
System.out.println(CollectionUtils.isEqualCollection(listC, listD)); // false

Docs:

org.apache.commons.collections4.CollectionUtils

public static boolean isEqualCollection(java.util.Collection a,
                                        java.util.Collection b)

Gibt zurück, truewenn die angegebenen Collections genau dieselben Elemente mit genau denselben Kardinalitäten enthalten.

Das heißt, wenn die Kardinalität von e in a gleich der Kardinalität von e in b ist , für jedes Element e in a oder b .

Parameter:

• a - Die erste Sammlung darf nicht sein null
• b - Die zweite Sammlung darf nicht sein null

Rückgabe: trueWenn die Sammlungen dieselben Elemente mit denselben Kardinalitäten enthalten.

// helper class, so we don't have to do a whole lot of autoboxing
private static class Count {
    public int count = 0;
}

public boolean haveSameElements(final List<String> list1, final List<String> list2) {
    // (list1, list1) is always true
    if (list1 == list2) return true;

    // If either list is null, or the lengths are not equal, they can't possibly match 
    if (list1 == null || list2 == null || list1.size() != list2.size())
        return false;

    // (switch the two checks above if (null, null) should return false)

    Map<String, Count> counts = new HashMap<>();

    // Count the items in list1
    for (String item : list1) {
        if (!counts.containsKey(item)) counts.put(item, new Count());
        counts.get(item).count += 1;
    }

    // Subtract the count of items in list2
    for (String item : list2) {
        // If the map doesn't contain the item here, then this item wasn't in list1
        if (!counts.containsKey(item)) return false;
        counts.get(item).count -= 1;
    }

    // If any count is nonzero at this point, then the two lists don't match
    for (Map.Entry<String, Count> entry : counts.entrySet()) {
        if (entry.getValue().count != 0) return false;
    }

    return true;
}

Ich würde sagen, diese Antworten verpassen einen Trick.

Bloch sagt in seinem wesentlichen, wunderbaren, prägnanten, effektiven Java in Punkt 47, Titel "Die Bibliotheken kennen und benutzen", "Zusammenfassend, erfinden Sie das Rad nicht neu". Und er gibt mehrere sehr klare Gründe an, warum nicht.

Hier gibt es einige Antworten, die Methoden aus CollectionUtilsder Apache Commons Collections-Bibliothek vorschlagen, aber keine hat die schönste und eleganteste Art gefunden, diese Frage zu beantworten :

Collection<Object> culprits = CollectionUtils.disjunction( list1, list2 );
if( ! culprits.isEmpty() ){
  // ... do something with the culprits, i.e. elements which are not common

}

Schuldige : dh die Elemente, die beiden nicht gemeinsam sind Lists. Die Festlegung , welche Schuldigen gehören list1und die zu list2relativ einfach verwendet CollectionUtils.intersection( list1, culprits )und CollectionUtils.intersection( list2, culprits ).
In Fällen wie {"a", "a", "b"} neigt es jedoch dazu, auseinanderzufallen.disjunction mit {"a", "b", "b"} auseinanderzufallen ... außer dies ist kein Fehler der Software, aber der Art der Feinheiten / Mehrdeutigkeiten der gewünschten Aufgabe inhärent.

Sie können den Quellcode (l. 287) jederzeit auf eine solche Aufgabe untersuchen, wie sie von den Apache-Ingenieuren erstellt wurde. Ein Vorteil der Verwendung ihres Codes besteht darin, dass er gründlich erprobt und getestet wurde und viele Randfälle und Fallstricke vorweggenommen und behandelt wurden. Sie können diesen Code bei Bedarf nach Herzenslust kopieren und optimieren.

NB Ich war zunächst enttäuscht, dass keine der CollectionUtilsMethoden eine überladene Version bietet, mit der Sie Ihre eigene auferlegen können Comparator(damit Sie sie equalsfür Ihre Zwecke neu definieren können ).

Aus Sammlungen4 4.0 gibt es jedoch eine neue Klasse, Equatordie "die Gleichheit zwischen Objekten vom Typ T bestimmt". Bei der Prüfung des Quellcodes von collection4 CollectionUtils.java scheinen sie dies mit einigen Methoden zu verwenden, aber soweit ich das beurteilen kann, gilt dies nicht für die Methoden oben in der Datei, die die CardinalityHelperKlasse ... verwenden umfassen disjunctionund intersection.

Ich vermute, dass die Apache-Leute noch nicht dazu gekommen sind, weil es nicht trivial ist: Sie müssten so etwas wie eine "AbstractEquatingCollection" -Klasse erstellen, die anstelle der inhärenten equalsund hashCodeMethoden ihrer Elemente diese verwenden müsste der Equatorfür alle grundlegenden Methoden, wie zum Beispiel add, containsusw. NB in der Tat , wenn Sie auf den Quellcode schauen, AbstractCollectionnicht implementiert add, noch seine abstrakte Subklassen wie AbstractSet... Sie bis in die konkreten Klassen wie warten HashSetund ArrayListvor addist implementiert. Ziemlich Kopfschmerzen.

In der Zwischenzeit diesen Raum beobachten, nehme ich an. Die naheliegende Zwischenlösung wäre, alle Ihre Elemente in eine maßgeschneiderte Wrapper-Klasse zu verpacken , die die gewünschte Gleichheit verwendet equalsund hashCodeimplementiert ... und dann Collectionsdiese Wrapper-Objekte zu manipulieren .

Wenn die Kardinalität von Elementen keine Rolle spielt (dh wiederholte Elemente werden als eins betrachtet), gibt es eine Möglichkeit, dies zu tun, ohne sortieren zu müssen:

boolean result = new HashSet<>(listA).equals(new HashSet<>(listB));

Dadurch wird Setaus jedem ein Out erstellt Listund dann verwendetHashSet ‚s equalsMethode , die (natürlich) missachtet Ordnung.

Wenn Kardinalität wichtig ist, müssen Sie sich auf Einrichtungen beschränken, die von bereitgestellt werden List; @ jschoens Antwort wäre in diesem Fall passender.

Das Konvertieren der Listen in Guavas Multiset funktioniert sehr gut. Sie werden unabhängig von ihrer Reihenfolge verglichen und doppelte Elemente werden ebenfalls berücksichtigt.

static <T> boolean equalsIgnoreOrder(List<T> a, List<T> b) {
    return ImmutableMultiset.copyOf(a).equals(ImmutableMultiset.copyOf(b));
}

assert equalsIgnoreOrder(ImmutableList.of(3, 1, 2), ImmutableList.of(2, 1, 3));
assert !equalsIgnoreOrder(ImmutableList.of(1), ImmutableList.of(1, 1));

Dies basiert auf der @ cHao-Lösung. Ich habe mehrere Korrekturen und Leistungsverbesserungen hinzugefügt. Dies läuft ungefähr doppelt so schnell wie die Lösung für gleich geordnete Kopien. Funktioniert für jeden Sammlungstyp. Leere Sammlungen und Null werden als gleich angesehen. Nutzen Sie zu Ihrem Vorteil;)

/**
 * Returns if both {@link Collection Collections} contains the same elements, in the same quantities, regardless of order and collection type.
 * <p>
 * Empty collections and {@code null} are regarded as equal.
 */
public static <T> boolean haveSameElements(Collection<T> col1, Collection<T> col2) {
    if (col1 == col2)
        return true;

    // If either list is null, return whether the other is empty
    if (col1 == null)
        return col2.isEmpty();
    if (col2 == null)
        return col1.isEmpty();

    // If lengths are not equal, they can't possibly match
    if (col1.size() != col2.size())
        return false;

    // Helper class, so we don't have to do a whole lot of autoboxing
    class Count
    {
        // Initialize as 1, as we would increment it anyway
        public int count = 1;
    }

    final Map<T, Count> counts = new HashMap<>();

    // Count the items in col1
    for (final T item : col1) {
        final Count count = counts.get(item);
        if (count != null)
            count.count++;
        else
            // If the map doesn't contain the item, put a new count
            counts.put(item, new Count());
    }

    // Subtract the count of items in col2
    for (final T item : col2) {
        final Count count = counts.get(item);
        // If the map doesn't contain the item, or the count is already reduced to 0, the lists are unequal 
        if (count == null || count.count == 0)
            return false;
        count.count--;
    }

    // At this point, both collections are equal.
    // Both have the same length, and for any counter to be unequal to zero, there would have to be an element in col2 which is not in col1, but this is checked in the second loop, as @holger pointed out.
    return true;
}

Überlegen Sie, wie Sie dies selbst tun würden, wenn Sie keinen Computer oder keine Programmiersprache hätten. Ich gebe Ihnen zwei Listen von Elementen, und Sie müssen mir sagen, ob sie die gleichen Elemente enthalten. Wie würdest du es machen?

Wie oben erwähnt, besteht ein Ansatz darin, die Listen zu sortieren und dann Element für Element zu prüfen, ob sie gleich sind (was auch der List.equalsFall ist). Dies bedeutet, dass Sie entweder die Listen ändern oder kopieren dürfen - und ohne die Zuordnung zu kennen, kann ich nicht wissen, ob eine oder beide zulässig sind.

Ein anderer Ansatz wäre, jede Liste durchzugehen und zu zählen, wie oft jedes Element erscheint. Wenn beide Listen am Ende die gleiche Anzahl haben, haben sie die gleichen Elemente. Der Code dafür wäre, jede Liste in eine Karte von zu übersetzen elem -> (# of times the elem appears in the list)und dann equalsdie beiden Karten aufzurufen . Wenn die Karten sind HashMap, ist jede dieser Übersetzungen eine O (N) -Operation, ebenso wie der Vergleich. Das gibt Ihnen einen ziemlich effizienten Algorithmus in Bezug auf die Zeit auf Kosten von zusätzlichem Speicher.

Ich hatte das gleiche Problem und fand eine andere Lösung. Dieser funktioniert auch, wenn Duplikate beteiligt sind:

public static boolean equalsWithoutOrder(List<?> fst, List<?> snd){
  if(fst != null && snd != null){
    if(fst.size() == snd.size()){
      // create copied lists so the original list is not modified
      List<?> cfst = new ArrayList<Object>(fst);
      List<?> csnd = new ArrayList<Object>(snd);

      Iterator<?> ifst = cfst.iterator();
      boolean foundEqualObject;
      while( ifst.hasNext() ){
        Iterator<?> isnd = csnd.iterator();
        foundEqualObject = false;
        while( isnd.hasNext() ){
          if( ifst.next().equals(isnd.next()) ){
            ifst.remove();
            isnd.remove();
            foundEqualObject = true;
            break;
          }
        }

        if( !foundEqualObject ){
          // fail early
          break;
        }
      }
      if(cfst.isEmpty()){ //both temporary lists have the same size
        return true;
      }
    }
  }else if( fst == null && snd == null ){
    return true;
  }
  return false;
}

Vorteile gegenüber einigen anderen Lösungen:

• weniger als O (N²) -Komplexität (obwohl ich die tatsächliche Leistung im Vergleich zu Lösungen in anderen Antworten hier nicht getestet habe);
• geht früh;
• prüft auf null;
• funktioniert auch, wenn Duplikate beteiligt sind: Wenn Sie ein Array [1,2,3,3]und ein anderes Array [1,2,2,3]haben, sagen Ihnen die meisten Lösungen hier, dass sie gleich sind, wenn Sie die Reihenfolge nicht berücksichtigen. Diese Lösung vermeidet dies, indem gleiche Elemente aus den temporären Listen entfernt werden.
• verwendet semantische Gleichheit ( equals) und nicht Referenzgleichheit ( ==);
• sortiert itens nicht, daher müssen sie nicht sortierbar sein, damit implement Comparablediese Lösung funktioniert.

Wenn Sie nicht hoffen, die Sammlungen zu sortieren, und Sie das Ergebnis benötigen, dass ["A" "B" "C"] nicht gleich ["B" "B" "A" "C"] ist,

l1.containsAll(l2)&&l2.containsAll(l1)

ist nicht genug, Sie müssen wahrscheinlich auch die Größe überprüfen:

    List<String> l1 =Arrays.asList("A","A","B","C");
    List<String> l2 =Arrays.asList("A","B","C");
    List<String> l3 =Arrays.asList("A","B","C");

    System.out.println(l1.containsAll(l2)&&l2.containsAll(l1));//cautions, this will be true
    System.out.println(isListEqualsWithoutOrder(l1,l2));//false as expected

    System.out.println(l3.containsAll(l2)&&l2.containsAll(l3));//true as expected
    System.out.println(isListEqualsWithoutOrder(l2,l3));//true as expected


    public static boolean isListEqualsWithoutOrder(List<String> l1, List<String> l2) {
        return l1.size()==l2.size() && l1.containsAll(l2)&&l2.containsAll(l1);
}

Lösung, die die Subtraktionsmethode CollectionUtils nutzt:

import static org.apache.commons.collections15.CollectionUtils.subtract;

public class CollectionUtils {
  static public <T> boolean equals(Collection<? extends T> a, Collection<? extends T> b) {
    if (a == null && b == null)
      return true;
    if (a == null || b == null || a.size() != b.size())
      return false;
    return subtract(a, b).size() == 0 && subtract(a, b).size() == 0;
  }
}

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

list1.equals(list2)

Wenn es Ihnen egal ist, bestellen Sie diese

Collections.sort(list1);
Collections.sort(list2);      
list1.equals(list2)

Das Beste aus beiden Welten [@DiddiZ, @Chalkos]: Diese basiert hauptsächlich auf der @ Chalkos-Methode, behebt jedoch einen Fehler (ifst.next ()) und verbessert die anfänglichen Überprüfungen (aus @DiddiZ) sowie die Notwendigkeit Kopieren Sie die erste Sammlung (entfernt nur Elemente aus einer Kopie der zweiten Sammlung).

Dies ist die bisher effizienteste Implementierung, die keine Hashing-Funktion oder Sortierung erfordert und eine frühzeitige Existenz bei Ungleichheit ermöglicht. Es sei denn, Sie haben eine Sammlungslänge von Tausenden oder mehr und eine sehr einfache Hashing-Funktion.

public static <T> boolean isCollectionMatch(Collection<T> one, Collection<T> two) {
    if (one == two)
        return true;

    // If either list is null, return whether the other is empty
    if (one == null)
        return two.isEmpty();
    if (two == null)
        return one.isEmpty();

    // If lengths are not equal, they can't possibly match
    if (one.size() != two.size())
        return false;

    // copy the second list, so it can be modified
    final List<T> ctwo = new ArrayList<>(two);

    for (T itm : one) {
        Iterator<T> it = ctwo.iterator();
        boolean gotEq = false;
        while (it.hasNext()) {
            if (itm.equals(it.next())) {
                it.remove();
                gotEq = true;
                break;
            }
        }
        if (!gotEq) return false;
    }
    // All elements in one were found in two, and they're the same size.
    return true;
}

Es ist eine alternative Möglichkeit, die Gleichheit von Array-Listen zu überprüfen, die Nullwerte enthalten können:

List listA = Arrays.asList(null, "b", "c");
List listB = Arrays.asList("b", "c", null);

System.out.println(checkEquality(listA, listB)); // will return TRUE


private List<String> getSortedArrayList(List<String> arrayList)
{
    String[] array = arrayList.toArray(new String[arrayList.size()]);

    Arrays.sort(array, new Comparator<String>()
    {
        @Override
        public int compare(String o1, String o2)
        {
            if (o1 == null && o2 == null)
            {
                return 0;
            }
            if (o1 == null)
            {
                return 1;
            }
            if (o2 == null)
            {
                return -1;
            }
            return o1.compareTo(o2);
        }
    });

    return new ArrayList(Arrays.asList(array));
}

private Boolean checkEquality(List<String> listA, List<String> listB)
{
    listA = getSortedArrayList(listA);
    listB = getSortedArrayList(listB);

    String[] arrayA = listA.toArray(new String[listA.size()]);
    String[] arrayB = listB.toArray(new String[listB.size()]);

    return Arrays.deepEquals(arrayA, arrayB);
}

Meine Lösung dafür. Es ist nicht so cool, funktioniert aber gut.

public static boolean isEqualCollection(List<?> a, List<?> b) {

    if (a == null || b == null) {
        throw new NullPointerException("The list a and b must be not null.");
    }

    if (a.size() != b.size()) {
        return false;
    }

    List<?> bCopy = new ArrayList<Object>(b);

    for (int i = 0; i < a.size(); i++) {

        for (int j = 0; j < bCopy.size(); j++) {
            if (a.get(i).equals(bCopy.get(j))) {
                bCopy.remove(j);
                break;
            }
        }
    }

    return bCopy.isEmpty();
}

In diesem Fall sind die Listen {"a", "b"} und {"b", "a"} gleich. Und {"a", "b"} und {"b", "a", "c"} sind nicht gleich. Wenn Sie die Liste von komplexen Objekten verwenden, denken Sie daran, Überschreibung gleich Methode, wie containsAll es im Inneren verwendet.

if (oneList.size() == secondList.size() && oneList.containsAll(secondList)){
        areEqual = true;
}