transmitir la creación de la lista de la lista (lista anidada) usando forEach, Java 8

chepe lucho :

class EntityCompositeId {
    private Long firstId;
    private Long secondId;
    // getter & setter...
}

class EntityComposite {
    private EntityCompositeId id;
    private String first;
    private String second;
    // getter & setter...
}

List<EntityComposite> listEntityComposite = ....
Supose this content

1, 1, "firstA", "secondBirdOne"
1, 2, "firstA", "secondBirdTwo"
1, 3, "firstA", "secondBirdThree"

2, 1, "firstB", "secondCatOne"
2, 2, "firstB", "secondCatTwo"
2, 3, "firstB", "secondCatThree"

3, 1, "firstC", "secondDogOne"
3, 2, "firstC", "secondDogTwo"
3, 3, "firstC", "secondDogThree"

Map<Long, List<String>> listOfLists = new HashMap<>();

Ahora, utilizando corriente Quiero llenar como:

 1 -> {"secondBirdOne", "secondBirdTwo", "secondBirdThree"}
 2 -> {"secondCatOne", "secondCatTwo", "secondCatThree"}
 3 -> {"secondDogOne", "secondDogTwo", "secondDogThree"}

Mi INACABADA (esa es la pregunta) código es:

listEntityComposite.stream()forEach(entityComposite {
        // How create a list according entityComposite.getId.getFirstId()?
        listOfLists.put(entityComposite.getId.getFirstId(), .... )
    });

Ousmane D .:

Existen varios enfoques diferentes en las que usted puede lograr la tarea en cuestión.

forEach + computeIfAbsent

 Map<Long, List<String>> map = new HashMap<>();
 listEntityComposite.forEach(e -> map.computeIfAbsent(e.getId().getFirstId(), 
                k -> new ArrayList<>()).add(e.getSecond()));

• enumera más de los elementos de listEntityCompositevíaforEach
• para cada elemento utiliza computeIfAbsentpara calcular la clave (es decir, firstId) y el valor (es decir List<String>)

groupingBy + mapeo

Otro enfoque sería aplicar una groupingBycon un mappingcolector de aguas abajo:

Map<Long, List<String>> resultSet = listEntityComposite.stream()
                .collect(groupingBy(e -> e.getId().getFirstId(),
                        mapping(EntityComposite::getSecond, toList())));

• grupos de los elementos de la fuente de la función de clasificación e.getId().getFirstId()y luego aplica un mappingcolector aguas abajo para refinar aún más nuestra consulta.

forEach + fusión

listEntityComposite.forEach(e -> map.merge(e.getId().getFirstId(),
                new ArrayList<>(singletonList(e.getSecond())),
                (l, r) -> {l.addAll(r); return l;}));

• enumera más de los elementos de listEntityCompositevíaforEach

• para cada elemento utiliza mergepara calcular la clave (es decir, firstId) y el valor (es decir List<String>)

para asignar

listEntityComposite.stream()
                   .collect(toMap(e -> e.getId().getFirstId(), 
                             v ->  new ArrayList<>(singletonList(v.getSecond())),
                             (l, r) -> {l.addAll(r); return l;}));

• se aplica una keyMapperfunción e -> e.getId().getFirstId()para extraer las claves de mapas.
• se aplica una valueMapperfunción v -> new ArrayList<>(singletonList(v.getSecond()))para extraer los valores de mapa.
• se aplica una mergefunción (l, r) -> {l.addAll(r); return l;}a las colisiones clave determinación.

Para concluir, el forEach+ computeIfAbsentaproximación y el groupingBy+ mappingenfoque son los dos que debe favorecer en este caso específico, ya que son más idiomática.