por - recorrer lista de objetos java

¿Cómo puedo convertir una lista de listas en una lista en Java 8?

Question

Si tengo una List<List<Object>> , ¿cómo puedo convertir eso en una List<Object> que contiene todos los objetos en el mismo orden de iteración utilizando las funciones de Java 8?

Answer 1

Así como lo mencionó @Saravana:

Plano es mejor, pero hay otras formas de lograr el mismo

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

En resumen, hay varias formas de lograr lo mismo de la siguiente manera:

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

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

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

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

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

Answer 2

El método flatMap en Stream ciertamente puede aplanar esas listas para usted, pero debe crear objetos Stream para elemento, luego un Stream para el resultado.

No necesitas todos esos objetos Stream . Aquí está el código simple y conciso para realizar la tarea.

// listOfLists is a List<List<Object>>.
List<Object> result = new ArrayList<>();
listOfLists.forEach(result::addAll);

Debido a que una List es Iterable , este código llama al método forEach (función Java 8), que se hereda de Iterable .

Realiza la acción dada para cada elemento del Iterable hasta que todos los elementos hayan sido procesados ​​o la acción arroje una excepción. Las acciones se realizan en el orden de iteración, si ese orden se especifica.

Y el Iterator una List devuelve los artículos en orden secuencial.

Para el Consumer , este código pasa una referencia de método (característica Java 8) al método List.addAll anterior a Java 8 para agregar los elementos de la lista interna de forma secuencial.

Anexa todos los elementos de la colección especificada al final de esta lista, en el orden en que son devueltos por el iterador de la colección especificada (operación opcional).

Answer 3

Puede usar flatMap para aplanar las listas internas (después de convertirlas a Streams) en una sola Secuencia y luego recopilar el resultado en una lista:

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

Answer 4

Puede utilizar el patrón flatCollect() de las colecciones de Eclipse .

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

Si no puedes cambiar la lista de la List :

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

Nota: Soy un colaborador de Eclipse Collections.

Answer 5

Solo quiero explicar un escenario más como List<Documents> , esta lista contiene algunas listas más de otros documentos como List<Excel> , List<Word> , List<PowerPoint> . Así que la estructura es

Class A{
  List<Documents> documentList
}

Class Documents{
  List<Excel> excels
  List<Word> words
  List<PowerPoint> ppt
}

Ahora, si desea iterar Excel solo de documentos, haga algo como a continuación ...

Entonces el código sería

 List<Document> documentList = new A().getDocumentList();

 //check documentList as not null

 Optional<Excel> excelOptional = documentList.stream()
                         .map(doc -> doc.getExcel())
                         .flatMap(List::stream).findFirst();
 if(excelOptional.isPresent()){
   Excel exl = optionalExcel.get();
   // now get the value what you want.
 }

Espero que esto pueda resolver el problema de alguien mientras se codifica ...

Answer 6

flatmap es mejor, pero hay otras formas de lograr el mismo

List<List<Object>> listOfList = ... // fill

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