wake-up-neo.com

Verschachtelte Listen mit Streams in Java8

Ich habe eine Liste von Objekten A. Jedes Objekt A in dieser Liste enthält eine Liste von Objekt B und das Objekt B enthält eine Liste von Objekt C. Das Objekt C enthält einen Attributnamen, den ich zum Filtern mit Java 8 verwenden möchte.

so schreiben Sie den folgenden Code in Java 8 mit Streams, um verschachtelte Schleifen zu vermeiden:

C c1 = null;
String name = "name1"
for (A a: listOfAObjects) {
    for (B b: a.getList()) {
        for (C c: b.getPr()) {
            if (c.getName().equalsIgnoreCase(name)) {
                c1= c;
                break;
            }
        }
    }
}
8
sk555

Sie können zwei flatMap verwenden, dann eine filter, dann können Sie die erste auswählen oder wenn kein Ergebnis null zurückgibt:

C c1 = listOfAObjects.stream()
        .flatMap(a -> a.getList().stream())
        .flatMap(b -> b.getPr().stream())
        .filter(c -> c.getName().equalsIgnoreCase(name))
        .findFirst()
        .orElse(null);
8
YCF_L
 listOfObjectsA.stream()
               .flatMap(a -> a.getListOfObjectsB.stream())
               .flatMap(b -> b.getListOfObjectsC().stream())
               .filter(c -> name.equals(c.getName()))
               .findAny()
               .orElse(....)
1
Eugene

Sie können dies mit flatMap tun.

Ich habe ein Beispiel mit Company gemacht, das eine Liste von Person enthält: 

public static void main(String[] args) {
    List<Company> companies = Arrays.asList(
            new Company(Arrays.asList(new Person("Jon Skeet"), new Person("Linus Torvalds"))),
            new Company(Arrays.asList(new Person("Dennis Ritchie"), new Person("Bjarne Stroustrup"))),
            new Company(Arrays.asList(new Person("James Gosling"), new Person("Patrick Naughton")))
    );

    List<String> persons = companies.stream()
            .flatMap(company -> company.getPersons().stream())
            .map(Person::getName)
            .collect(Collectors.toList());

    System.out.println(persons);
}

Ausgabe : 

[Jon Skeet, Linus Torvalds, Dennis Ritchie, Bjarne Stroustrup, James Gosling, Patrick Naughton]

1

Ich hatte die gleiche Aufgabe, aber ich hatte eine verschachtelte Klasse. Und ich musste die Objekte mit Filter in der verschachtelten Sammlung filtern. Infolgedessen musste ich Elemente mit Übereinstimmungen in der Sammlung erhalten.

zum Beispiel:

public class RootElement {
    private String name;
    private List<String> nestedElements;

    //getters / setters and constructors
}

Init-Auflistung mit Elementen:

List<RootElement> elements = Arrays.asList(
                new RootElement("first", Arrays.asList("one", "two", "three")),
                new RootElement("second", Arrays.asList("four", "one", "two")));

Filterbeispiel:

String filterParam = "four";
        List<RootElement> filtered = elements.stream()
                .flatMap(root -> root.getNestedElements()
                        .stream()
                        .filter(nested -> nested.equalsIgnoreCase(filterParam))
                        .map(filteredElement -> new RootElement(root.getName(), root.getNestedElement())))
                .collect(Collectors.toList());

Hoffe, es wird jemandem helfen.

0