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

Sie können flatMap verwenden, um die internen Listen (nach Umwandlung in Streams) in einen einzigen Stream zu flattene und dann das Ergebnis in eine Liste zu sammeln:

List> list = ...
List flat = 
    list.stream()
        .flatMap(List::stream)
        .collect(Collectors.toList());

Answer 2

Die Methode flatMap auf Stream kann diese Listen definitiv für Sie abflachen, aber sie muss Stream-Objekte für jedes Element erstellen, und dann einen Stream für das Ergebnis.

Sie benötigen nicht all diese Stream-Objekte. Hier ist der einfache, prägnante Code, um die Aufgabe auszuführen.

// listOfLists ist eine List>.
List result = new ArrayList<>();
listOfLists.forEach(result::addAll);

Weil eine List Iterable ist, ruft dieser Code die forEach Methode auf (Java 8 Feature), welche von Iterable geerbt ist.

  Führt die angegebene Aktion für jedes Element des Iterable aus, bis alle Elemente verarbeitet wurden oder die Aktion eine Ausnahme wirft. Aktionen werden in der Reihenfolge der Iteration durchgeführt, wenn diese Reihenfolge angegeben ist.

Ein Iterator einer List gibt Elemente in sequenzieller Reihenfolge zurück.

Für den Consumer übergibt dieser Code eine Methodenreferenz (Java 8 Feature) an die vor-Java-8-Methode List.addAll, um die Elemente der inneren Liste sequenziell hinzuzufügen.

  Hängt alle Elemente der angegebenen Sammlung an das Ende dieser Liste an, in der Reihenfolge, in der sie vom Iterator der angegebenen Sammlung zurückgegeben werden (optionale Operation).

Answer 3

flatmap ist besser, aber es gibt andere Möglichkeiten, das Gleiche zu erreichen

List> listOfList = ... // füllen

List collect = 
      listOfList.stream()
                .collect(ArrayList::new, List::addAll, List::addAll);

Answer 4

Methode zum Konvertieren einer List in eine List:

listOfLists.stream().flatMap(List::stream).collect(Collectors.toList());

Sieh dir dieses Beispiel an:

public class Beispiel {

    public static void main(String[] args) {
        List> listOfLists = Collections.singletonList(Arrays.asList("a", "b", "v"));
        List list = listOfLists.stream().flatMap(List::stream).collect(Collectors.toList());

        System.out.println("listOfLists => " + listOfLists);
        System.out.println("list => " + list);
    }

}       

Es gibt aus:

listOfLists => [[a, b, c]]
list => [a, b, c]

In Python kann dies mit List Comprehension gemacht werden.

list_of_lists = [['Roopa', 'Roopi', 'Tabu', 'Soudipta'], [180.0, 1231, 2112, 3112], [130], [158.2], [220.2]]

flatten = [val for sublist in list_of_lists for val in sublist]

print(flatten)

['Roopa', 'Roopi', 'Tabu', 'Soudipta', 180.0, 1231, 2112, 3112, 130, 158.2, 220.2]

Answer 5

Genau wie @Saravana erwähnt hat:

flatmap ist besser, aber es gibt andere Möglichkeiten, das Gleiche zu erreichen

 listStream.reduce(new ArrayList<>(), (l1, l2) -> {
        l1.addAll(l2);
        return l1;
 });

Zusammenfassend gibt es verschiedene Möglichkeiten, das Gleiche zu erreichen:

private  List mergeOne(Stream> listStream) {
    return listStream.flatMap(List::stream).collect(toList());
}

private  List mergeTwo(Stream> listStream) {
    List result = new ArrayList<>();
    listStream.forEach(result::addAll);
    return result;
}

private  List mergeThree(Stream> listStream) {
    return listStream.reduce(new ArrayList<>(), (l1, l2) -> {
        l1.addAll(l2);
        return l1;
    });
}

private  List mergeFour(Stream> listStream) {
    return listStream.reduce((l1, l2) -> {
        List l = new ArrayList<>(l1);
        l.addAll(l2);
        return l;
    }).orElse(new ArrayList<>());
}

private  List mergeFive(Stream> listStream) {
    return listStream.collect(ArrayList::new, List::addAll, List::addAll);
}