Modo semplice per scoprire se due elenchi diversi contengono esattamente gli stessi elementi?

Qual è il modo più semplice per trovare se due elenchi contengono esattamente gli stessi elementi, nelle librerie Java standard?

Non dovrebbe importare se le due liste sono la stessa istanza o meno, e non dovrebbe importare se il parametro type degli elenchi è diverso.

per esempio

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

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

Probabilmente c'è qualcosa che mi fissa in faccia che conosco :-)

EDIT: Per chiarire, stavo cercando gli ESATTI stessi elementi e numero di elementi, in ordine.

Se ti interessa l'ordine, usa semplicemente il metodo equals:

list1.equals(list2)

Dal javadoc:

Confronta l'oggetto specificato con questo elenco per l'uguaglianza. Restituisce vero se e solo se l'oggetto specificato è anche un elenco, entrambi gli elenchi hanno le stesse dimensioni e tutte le coppie corrispondenti di elementi nei due elenchi sono uguali. (Due elementi e1 ed e2 sono uguali se (e1 == null? E2 == null: e1.equals (e2)). In altre parole, due elenchi sono definiti uguali se contengono gli stessi elementi nello stesso ordine . Questa definizione garantisce che il metodo equals funzioni correttamente in diverse implementazioni dell'interfaccia Elenco.

Se si desidera verificare indipendentemente dall'ordine, è possibile copiare tutti gli elementi in Set e utilizzare uguali sui Set risultanti:

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

Una limitazione di questo approccio è che non solo ignora l'ordine, ma anche la frequenza di elementi duplicati. Ad esempio, se list1fosse ["A", "B", "A"] e list2[[A "," B "," B "] l' Setapproccio li considererebbe uguali.

Se devi essere insensibile all'ordine ma sensibile alla frequenza dei duplicati puoi:

• ordina entrambi gli elenchi (o le copie) prima di confrontarli, come fatto in questa risposta a un'altra domanda
• oppure copia tutti gli elementi in un Multiset

Ho pubblicato un sacco di cose nei commenti, penso che meriti la sua risposta.

Come tutti dicono qui, usare equals () dipende dall'ordine. Se non ti interessa l'ordine, hai 3 opzioni.

opzione 1

Uso containsAll() . Questa opzione non è l'ideale, secondo me, perché offre le prestazioni peggiori, O (n ^ 2).

opzione 2

Ci sono due varianti a questo:

2a) Se non ti interessa mantenere l'ordine dei tuoi elenchi ... usa Collections.sort()entrambi gli elenchi. Quindi utilizzare il equals(). Questo è O (nlogn), perché fai due tipi, quindi un confronto O (n).

2b) Se è necessario mantenere l'ordine delle liste, è possibile prima copiare entrambe le liste. ALLORA puoi usare la soluzione 2a su entrambi gli elenchi copiati. Tuttavia, ciò potrebbe non essere attraente se la copia è molto costosa.

Questo porta a:

Opzione 3

Se i requisiti sono gli stessi della parte 2b , ma la copia è troppo costosa. È possibile utilizzare un TreeSet per eseguire l'ordinamento per te. Scarica ogni elenco nel proprio TreeSet. Sarà ordinato nel set e gli elenchi originali rimarranno intatti. Quindi eseguire un equals()confronto su entrambi TreeSet. Le TreeSetss possono essere costruite in tempo O (nlogn), eequals() is O (n).

Fai la tua scelta :-).

EDIT: ho quasi dimenticato lo stesso avvertimento che Laurence Gonsalves sottolinea. L'implementazione di TreeSet eliminerà i duplicati. Se ti interessano i duplicati, avrai bisogno di una sorta di multiset ordinato.

Se stai usando (o sei felice di usare) le raccolte Apache Commons, puoi usare CollectionUtils.isEqualCollection che "restituisce vero se le raccolte indicate contengono esattamente gli stessi elementi con esattamente le stesse cardinalità".

Molto tardi alla festa, ma volevo aggiungere questo controllo null sicuro:

Objects.equals(list1, list2)

So che questo è un vecchio thread, ma nessuna delle altre risposte ha risolto completamente il mio caso d'uso (suppongo che Guava Multiset potrebbe fare lo stesso, ma qui non c'è alcun esempio). Mi scusi per la mia formattazione. Sono ancora nuovo a pubblicare post sullo scambio di stack. Fammi sapere se ci sono errori

Diciamo che hai List<T>a e List<T>b e vuoi verificare se sono uguali alle seguenti condizioni:

1) O (n) tempo di esecuzione previsto
2) L'uguaglianza è definita come: Per tutti gli elementi in a o b, il numero di volte in cui l'elemento si presenta in è uguale al numero di volte in cui si verifica l'elemento in b. L'uguaglianza degli elementi è definita come 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;
}

Il tempo di esecuzione è O (n) perché stiamo eseguendo inserimenti O (2 * n) in una hashmap e O (3 * n) seleziona hashmap. Non ho testato completamente questo codice, quindi attenzione :)

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

Prova questa versione che non richiede che l'ordine sia uguale ma che supporta multipli dello stesso valore. Corrispondono solo se ognuno ha la stessa quantità di qualsiasi valore.

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

Il metodo uguale su Elenco farà questo, le liste sono ordinate, quindi per essere uguali due liste devono avere gli stessi elementi nello stesso ordine.

return list1.equals(list2);

Soluzione per caso in cui due elenchi hanno gli stessi elementi, ma un ordine diverso:

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

La risposta di Tom è eccellente, concordo pienamente con le sue risposte!

Un aspetto interessante di questa domanda è se hai bisogno di List tipo stesso e del suo ordinamento intrinseco.

Altrimenti puoi degradare a IterableoCollection che ti dà una certa flessibilità nel passare attorno alle strutture di dati che sono ordinate al momento dell'inserimento, piuttosto che nel momento in cui vuoi controllare.

Se l'ordine non ha mai importanza (e non hai elementi duplicati), considera l'utilizzo di a Set.

Se l'ordine conta ma è definito dal tempo di inserimento (e non hai duplicati) considera un LinkedHashSetche è come un TreeSet ma è ordinato dal tempo di inserimento (i duplicati non vengono conteggiati). Questo ti dà anche O(1)accesso ammortizzato O(log n).

Codice di esempio:

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

Oltre alla risposta di Laurence, se vuoi anche renderlo null-sicuro:

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

Se l'elenco contiene una classe MyClass personalizzata, questa classe deve sovrascrivere la equalsfunzione.

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

Nota: se si desidera testare equivale a java.util.Set anziché a java.util.List, l'oggetto deve sovrascrivere la hashCode funzione.

List.equals ()

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

Puoi utilizzare la libreria org.apache.commons.collections di Apache: http://commons.apache.org/collections/apidocs/org/apache/commons/collections/ListUtils.html

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

Controlla che entrambi gli elenchi non siano nulli. Se le loro dimensioni sono diverse, questi elenchi non sono uguali. Costruisci mappe costituite dagli elementi delle liste come chiavi e dalle loro ripetizioni come valori e confronta le mappe.

Ipotesi, se entrambe le liste sono nulle, le considero uguali.

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

Si noti che il metodo uguale a deve essere definito correttamente per questi oggetti. https://stackoverflow.com/a/24814634/4587961

Dipende dalla classe di elenco concreta che si sta utilizzando. La classe astratta AbstractCollection ha un metodo chiamato IncludesAll (Collection) che accetta un'altra raccolta (una List è una raccolta) e:

Restituisce vero se questa raccolta contiene tutti gli elementi nella raccolta specificata.

Quindi se viene passato un ArrayList puoi chiamare questo metodo per vedere se sono esattamente gli stessi.

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

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

    foo.containsAll(bar);

Il motivo per contiene All () è perché scorre nella prima lista cercando la corrispondenza nella seconda lista. Quindi se sono fuori uso equals () non lo raccoglierà.

EDIT: Voglio solo fare un commento qui sul tempo di esecuzione ammortizzato dell'esecuzione delle varie opzioni offerte. Il tempo di esecuzione è importante? Sicuro. È l'unica cosa che dovresti considerare? No.

Il costo della copia di OGNI singolo elemento dai tuoi elenchi in altri elenchi richiede tempo e occupa anche una buona porzione di memoria (raddoppiando effettivamente la memoria che stai utilizzando).

Quindi, se la memoria nella tua JVM non è un problema (come dovrebbe essere generalmente), devi comunque considerare il tempo necessario per copiare ogni elemento da due elenchi in due TreeSet. Ricorda che sta ordinando tutti gli elementi mentre li inserisce.

Il mio consiglio finale? È necessario considerare il set di dati e il numero di elementi presenti nel set di dati, nonché la dimensione di ciascun oggetto nel set di dati prima di poter prendere una buona decisione qui. Gioca con loro, creane uno per ogni direzione e vedi quale corre più veloce. È un buon esercizio.