Durchlaufen und filtern von zwei Listen die mit java 8

Ich Durchlaufen zwei Listen und neue gefilterte Liste die Werte nicht in der zweiten Liste. Kann mir jemand helfen?

Ich habe zwei Listen - eine Liste von strings, und die andere ist die Liste der MyClass Objekte.

List<String> list1;
List<MyClass> list2;

MyClass {

    MyClass(String val)
    {
        this.str = val;
    }

     String str;
     ...
     ...
}

Möchte ich gefilterte Liste von strings, basierend auf -> check zweite Liste für Elemente (abc), deren Werte nicht im list1.

List<String> list1 = Arrays.asList("abc", "xyz", "lmn");

List<MyClass> list2 = new ArrayList<MyClass>();

MyClass obj = new MyClass("abc");
list2.add(obj);
obj = new MyClass("xyz");
list2.add(obj);

Nun will ich neue gefilterte Liste -> welche Bedeutung haben => "lmn". d.h. Werte, die nicht in list2 dessen Elemente in list1.

Möchten Sie Durchlaufen diese beiden Listen gleichzeitig ?
Herzlich willkommen auf Stackoverflow! Es ist gut, dass Sie einige code, sondern um eine Antwort, die Sie könnte auch versuchen zu beschreiben / zeigen, was Sie bisher ausprobiert haben.
Ja.. ich Durchlaufen beide Listen gleichzeitig. Zunächst ist Obermenge mit Liste von strings, und die zweite ist eine Liste von Objekten. Jedes Objekt in dieser zweiten Liste ist ein string-Feld mit dem ich vergleichen wollen ersten Listenelemente. Und alle diese fehlenden Elemente in der zweiten Liste, ich möchte, dass Sie erfassen in einer Liste.

InformationsquelleAutor Arun Khot | 2015-04-07

filter java

15
```
//produce the filter set by streaming the items from list 2
//assume list2 has elements of type MyClass where getStr gets the
//string that might appear in list1
Set<String> unavailableItems = list2.stream()
    .map(MyClass::getStr)
    .collect(Collectors.toSet());

//stream the list and use the set to filter it
List<String> unavailable = list1.stream()
            .filter(e -> unavailableItems.contains(e))
            .collect(Collectors.toList());
```
Hi Ashley, Was keyMapper und ValueMapper toMap() übergeben müssen?
ich änderte toMap zu toSet. Aber dennoch nicht wie erwartet funktioniert. nicht verfügbar ist nicht immer alle Elemente.
Sorry - das sollte toSet, nicht toMap - korrigiert in die post. Vielleicht ist die Logik, die Sie versuchen, zu implementieren, ist nicht ganz das, was ich vorgeschlagen habe. Ist die Idee, dass man auf der Suche nach Dingen, die in list1 und list2, oder versuchen Sie Dinge zu finden, die in list1 und NICHT in liste2? Wenn das zweite, dann setzen Sie ein ! in der filter - d.h. .filter(e -> !unavailableItems.contains(e))

InformationsquelleAutor Ashley Frieze

Tun es mit streams ist einfach und gut lesbar:

Predicate<String> notIn2 = s -> ! list2.stream().anyMatch(mc -> s.equals(mc.str));
List<String> list3 = list1.stream().filter(notIn2).collect(Collectors.toList());

InformationsquelleAutor DSchmidt

3

Schließlich bekam ich Weg, dies zu erreichen, folgenden Weg -
```
List<String> unavailable = list1.stream()
                .filter(e -> (list2.stream()
                        .filter(d -> d.getStr().equals(e))
                        .count())<1)
                        .collect(Collectors.toList());
```
Aber dies ist auch wie erwartet funktioniert.
Bitte lassen Sie mich wissen, wie viel das effektiv ist? und wenn jemand andere Art und Weise zu tun, die gleiche Sache?

Auf diese Weise wird sehr ineffizient sein wie die Größe der Liste 2 erhöht über 3. Dies ist, weil die Logik dieser ist so etwas wie die für jedes element in der Liste 1 Scannen Sie jedes element der Liste 2 um eine übereinstimmung zu finden hinzufügen, um Ergebnisse, wenn der scan erkennt keine übereinstimmung, So dass die Anzahl der Operationen ist so etwas wie list1 Größe * Liste 2 Größe Durch eine Reihe von Liste 2 und die enthält-operation, Sie machen diese rund 2x list1 Größe Anzahl der Berechnungen.
Nicht sieht die "richtige Antwort" markieren. Dies ist die gleiche Art mit Blasen! Es werden quadratische O der Zeit. Besser verwenden Sie Lösungen von stackoverflow.com/a/29534646/907576

InformationsquelleAutor Arun Khot
2

Wenn du Strom in der ersten Liste und verwenden Sie einen filter basierend auf enthalt in der zweiten...
```
list1.stream()
    .filter(item -> !list2.contains(item))
```
Die nächste Frage ist, was code fügen Sie an das Ende dieser streaming-Betrieb zur Weiterverarbeitung der Ergebnisse... über Euch.

Auch, Liste.enthält, ist sehr langsam, so dass Sie besser wäre mit Gruppen.

Aber dann, wenn Sie mit sets, finden Sie vielleicht einige einfacher Operationen, um diese zu bewältigen, wie removeAll
```
Set list1 = ...;
Set list2 = ...;
Set target = new Set();
target.addAll(list1);
target.removeAll(list2);
```
Gegeben, wir wissen nicht, wie Sie gehen zu verwenden, ist es nicht wirklich möglich zu beraten, welche Vorgehensweise zu nehmen.

Sie haben absolut Recht. Enthält die Methode funktioniert gut. Aber mein problem ist, meine zweite Liste ist nicht einfachen Liste von strings. Die Liste der Objekte und ich möchte vergleichen der ersten Liste mit einer der Eigenschaften des Objektes, die in der zweiten Liste. Und ich kann nicht den umgekehrten Weg I. e. Konvertierung ersten Liste zu setzen. Da die erste Liste ist eine Art Obermenge. Und nach einem Vergleich der beiden Listen, ich möchte eine neue Liste mit Elementen fehlt in der zweiten Liste, die vorhanden sind in der ersten.

InformationsquelleAutor Ashley Frieze
2

Einem einfachen Ansatz wird eine foreach-in "list1" und überprüfen Sie, ob das Element in list2, wenn nicht hinzufügen list3.
```
outer:
for(String s : list1) {
    for(MyClass c : list2) 
        if(c.getStr().equals(s))
            continue outer;
    filteredList.add(c);
}
```
Wenn Sie finden weiterhin label verwirrend, extrahieren Sie die innere Schleife in eine boolean-Rückkehr-Funktion. Sie können auch ersetzen die klassischen foreach-für lambda-stream-iterator.
```
public static boolean isInList(ArrayList<MyClass> list, String s) {
    list2.stream().foreach((o)-> {
        if(o.getStr().equals(s)) {
            return true;
        }
    });
    return false;
}

list1.stream().foreach((s) -> {
    if(!isInList(list2, s)) {
        list3.add(s);
    }
});
```
aber es sieht wirklich mehr junky/verschmutzt und unnötig in meinen Augen.

Auch String str in Ihrer Klasse keinen öffentlichen definition, das ist, warum ich in beiden Beispielen verwendet "getStr ()" - Methode, vorausgesetzt, Ihre Klasse folgt auf das java-bean-Modell und enthält eine Methode getStr () - Methode.

Ich bin auf der Suche nach dem Weg zum erreichen derselben mit Java 8
Pause und weiter zu beschriften und foreach sind vollkommen gültig ab Java 8. Sie können auch versuchen, einige gruselige Ansätze mit der Methode der Erklärung und stream-iteration, ich finde das alles auch zu kompliziert und zu verschwenden, aber ich werde aktualisieren Sie die Antwort.
wenn Sie mit stream(), nicht nur foreach(). Ihre erste foreach sollte anyMatch und der 2. sollte collect. continuemit labes ist einfach nur böse. Siehe meine Antwort.

InformationsquelleAutor Felype
2

Siehe unten, würde es begrüßen, anyones feedback zu den untenstehenden code.

nicht üblich, zwischen zwei arrays:
```
List<String> l3 =list1.stream().filter(x -> !list2.contains(x)).collect(Collectors.toList());
```
Gemeinsame zwischen zwei arrays:
```
List<String> l3 =list1.stream().filter(x -> list2.contains(x)).collect(Collectors.toList());
```
Und das funktioniert nicht. list2 nicht enthalten Zeichenfolgen.

InformationsquelleAutor tosi

list1 = list1.stream().filter(str1-> 
        list2.stream().map(x->x.getStr()).collect(Collectors.toSet())
        .contains(str1)).collect(Collectors.toList());

Diese können effizienter arbeiten.

InformationsquelleAutor YiFu.Zhou

0

wenn Sie die Klasse mit der id und nach dem Sie filtern möchten-id

line1 : Sie mape alle id -

line2: filter, was ist es nicht in der Karte
```
Set<String> mapId = entityResponse.getEntities().stream().map(Entity::getId).collect(Collectors.toSet());

List<String> entityNotExist = entityValues.stream().filter(n -> !mapId.contains(n.getId())).map(DTOEntity::getId).collect(Collectors.toList());
```
Während dieses code-snippet lösen können, die Frage, einschließlich einer Erklärung die wirklich hilft, zu verbessern, die Qualität Ihrer post. Denken Sie daran, dass Sie die Beantwortung der Frage für den Leser in der Zukunft, und die Menschen vielleicht nicht wissen, die Gründe für deinen code-Vorschlag.

InformationsquelleAutor Ran Adler

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.