Überprüfen Sie, ob eine Liste Elemente aus der anderen enthält

Ich habe zwei Listen mit unterschiedlichen Objekten.

List<Object1> list1;
List<Object2> list2;

Ich möchte überprüfen, ob ein Element aus Liste1 in Liste2 vorhanden ist, basierend auf einem bestimmten Attribut (Objekt1 und Objekt2 haben (unter anderem) ein gemeinsames Attribut (mit dem Typ Long) mit dem Namen attributeSame).

im Moment mache ich es so:

boolean found = false;
for(Object1 object1 : list1){
   for(Object2 object2: list2){
       if(object1.getAttributeSame() == object2.getAttributeSame()){
           found = true;
           //also do something
       }
    }
    if(!found){
        //do something
    }
    found = false;
}

Aber ich denke, es gibt einen besseren und schnelleren Weg, dies zu tun :) Kann jemand es vorschlagen?

Vielen Dank!

Wenn Sie nur die grundlegende Gleichheit testen müssen, können Sie dies mit dem grundlegenden JDK tun, ohne die Eingabelisten in der einen Zeile zu ändern

!Collections.disjoint(list1, list2);

Wenn Sie eine bestimmte Eigenschaft testen müssen, ist dies schwieriger. Ich würde standardmäßig empfehlen,

list1.stream()
   .map(Object1::getProperty)
   .anyMatch(
     list2.stream()
       .map(Object2::getProperty)
       .collect(toSet())
       ::contains)

... die die unterschiedlichen Werte in sammelt list2und jeden Wert list1auf Präsenz prüft .

Sie können Apache Commons CollectionUtils verwenden :

if(CollectionUtils.containsAny(list1,list2)) {  
    // do whatever you want
} else { 
    // do other thing 
}  

Dies setzt voraus, dass Sie die Gleichheitsfunktionalität für Ihre benutzerdefinierten Objekte ordnungsgemäß überladen haben.

Um Narendras Logik zu verkürzen, können Sie Folgendes verwenden:

boolean var = lis1.stream().anyMatch(element -> list2.contains(element));

Es ist eine Methode von dem CollectionNamen , retainAllaber mit einigen Nebenwirkungen für Sie Referenz

Behält nur die Elemente in dieser Liste bei, die in der angegebenen Sammlung enthalten sind (optionaler Vorgang). Mit anderen Worten, werden alle Elemente aus dieser Liste entfernt, die nicht in der angegebenen Sammlung enthalten sind.

true, wenn sich diese Liste infolge des Aufrufs geändert hat

Es ist wie

boolean b = list1.retainAll(list2);

Loius Antwort ist richtig, ich möchte nur ein Beispiel hinzufügen:

listOne.add("A");
listOne.add("B");
listOne.add("C");

listTwo.add("D");
listTwo.add("E");
listTwo.add("F");      

boolean noElementsInCommon = Collections.disjoint(listOne, listTwo); // true

Ein schnellerer Weg erfordert zusätzlichen Platz.

Beispielsweise:

1. Fügen Sie alle Elemente in einer Liste in ein HashSet ein (Sie müssen die Hash-Funktion selbst implementieren, um object.getAttributeSame () verwenden zu können.)

2. Gehen Sie die andere Liste durch und prüfen Sie, ob sich ein Element im HashSet befindet.

Auf diese Weise wird jedes Objekt höchstens einmal besucht. und HashSet ist schnell genug, um ein Objekt in O (1) zu überprüfen oder einzufügen.

Laut JavaDoc für die .contains(Object obj):

Gibt true zurück, wenn diese Liste das angegebene Element enthält. Genauer gesagt, gibt true nur dann zurück, wenn diese Liste mindestens ein Element e enthält, so dass (o == null? E == null: o.equals (e)).

Wenn Sie also Ihre .equals()Methode für Ihr bestimmtes Objekt überschreiben , sollten Sie in der Lage sein:if(list1.contains(object2))...

Wenn die Elemente eindeutig sind (dh unterschiedliche Attribute haben), können Sie das .equals()und überschreiben .hashcode()und alles in speichern HashSets. Auf diese Weise können Sie in konstanter Zeit überprüfen, ob eines ein anderes Element enthält.

Um es schneller zu machen, können Sie eine Pause hinzufügen. Auf diese Weise stoppt die Schleife, wenn gefunden auf true gesetzt ist:

boolean found = false;
for(Object1 object1 : list1){
   for(Object2 object2: list2){
       if(object1.getAttributeSame() == object2.getAttributeSame()){
           found = true;
           //also do something  
           break;
       }
    }
    if(!found){
        //do something
    }
    found = false;
}

Wenn Sie Karten anstelle von Listen mit den Schlüsseln attributeSame als Schlüssel haben würden, könnten Sie schneller nach einem Wert in einer Karte suchen, ob die zweite Karte einen entsprechenden Wert enthält oder nicht.

Können Sie die Art der Daten definieren, die Sie speichern? ist es Big Data? ist es sortiert? Ich denke, dass Sie je nach Daten unterschiedliche Effizienzansätze berücksichtigen müssen.

Wenn Ihre Daten beispielsweise groß und unsortiert sind, können Sie versuchen, die beiden Listen zusammen nach Index zu iterieren und jedes Listenattribut in einem anderen Listenhelfer zu speichern. Dann können Sie die aktuellen Attribute in den Hilfslisten überprüfen.

Viel Glück

bearbeitet: und ich würde nicht empfehlen, gleich viel zu überladen. Es ist gefährlich und wahrscheinlich gegen Ihr Objekt.

org.springframework.util.CollectionUtils

boolean containsAny(java.util.Collection<?> source, java.util.Collection<?> candidates)

Return true if any element in 'candidates' is contained in 'source'; otherwise returns false

Mit java 8können wir wie folgt prüfen, ob eine Liste ein Element einer anderen Liste enthält

boolean var = lis1.stream().filter(element -> list2.contains(element)).findFirst().isPresent();

Wenn Sie überprüfen möchten, ob ein Element in einer Liste vorhanden ist, verwenden Sie die Methode includes.

if (list1.contains(Object o))
{
   //do this
}