Wie kann ich in Java 8 eine Liste von Listen in eine Liste umwandeln?

Question

Wenn ich eine List> habe, wie kann ich das in eine List umwandeln, die alle Objekte in der gleichen Iterationsreihenfolge enthält und dabei die Funktionen von Java 8 verwendet?

Answer 1

Ich möchte nur ein weiteres Szenario wie List erklären. Diese Liste enthält ein paar weitere Listen von anderen Dokumenten wie List, List, List. Also ist die Struktur wie folgt:

class A {
  List documentList;
}

class Documents {
  List excels;
  List words;
  List ppt;
}

Wenn Sie also nur Excel-Dokumente aus den Dokumenten durchlaufen möchten, tun Sie etwas Ähnliches wie unten..

Der Code wäre also:

 List documentList = new A().getDocumentList();

 // Überprüfen Sie, ob documentList nicht null ist

 Optional excelOptional = documentList.stream()
                         .map(doc -> doc.getExcel())
                         .flatMap(List::stream).findFirst();
 if(excelOptional.isPresent()){
   Excel exl = optionalExcel.get();
   // Holen Sie sich jetzt den Wert, den Sie möchten.
 }

Ich hoffe, dass dies jemandem bei der Programmierung helfen kann...

Answer 2

Sie können das flatCollect()-Muster von Eclipse Collections verwenden.

MutableList> list = Lists.mutable.empty();
MutableList flat = list.flatCollect(each -> each);

Wenn Sie die Liste nicht von List ändern können:

List> list = new ArrayList<>();
List flat = ListAdapter.adapt(list).flatCollect(each -> each);

Hinweis: Ich bin ein Mitwirkender an Eclipse Collections.

Answer 3

Eine Erweiterung von Erans Antwort, die die beste Antwort war. Wenn Sie eine Vielzahl von Ebenen von Listen haben, können Sie diese weiterhin flachmappen.

Dies geht auch mit einer praktischen Möglichkeit der Filterung, während Sie die Ebenen durchgehen, falls erforderlich.

Zum Beispiel:

List>>>>> multiLayeredList = ...

List objectList = multiLayeredList
    .stream()
    .flatmap(someList1 -> someList1
        .stream()
        .filter(...Optional...))
    .flatmap(someList2 -> someList2
        .stream()
        .filter(...Optional...))
    .flatmap(someList3 -> someList3
        .stream()
        .filter(...Optional...))
    ...
    .collect(Collectors.toList())

Dies ist ähnlich wie in SQL SELECT-Anweisungen innerhalb von SELECT-Anweisungen zu haben.

Answer 4

Seit java-16 können Sie Stream#mapMulti verwenden

List result = listOfLists.stream()
                                 .mapMulti((List list, Consumer consumer) -> {
                                     list.forEach(consumer::accept);
                                 })
                                 .collect(Collectors.toList());

Wenn Sie eine unveränderliche List benötigen, können Sie sogar toList() als Terminaloperation verwenden
List result = listOfLists.stream()
                                 .mapMulti((List list, Consumer consumer) -> {
                                     list.forEach(consumer::accept);
                                 })
                                 .toList();

Answer 5

Wir können dafür flatmap verwenden, bitte beachten Sie den folgenden Code :

 List i1= Arrays.asList(1, 2, 3, 4);
 List i2= Arrays.asList(5, 6, 7, 8);

 List> ii= Arrays.asList(i1, i2);
 System.out.println("List>"+ii);
 List flat=ii.stream().flatMap(l-> l.stream()).collect(Collectors.toList());
 System.out.println("Flattened to List"+flat);