Resumindo valores de um objecto, em primeiro lugar filtragem outros valores singulares do mesmo objecto

Plainsage:

Digamos que eu tenho uma lista de um objeto permite chamar esta Ordem objeto que tem uma quantidade e preço como campos.

por exemplo, como a seguir:

Objeto Order(campos quantitye price) contém a lista abaixo: valores

Quantity  Price

5         200
6         100
3         200
1         300

Agora eu quero usar Java-8 para buscar esta lista filtrada no abaixo maneira:

Quantity  Price

8         200
6         100
1         300

Sendo o preço o valor único de filtro de e somando qualquer quantidade que o preço tem, eu quero formar uma nova lista com base nesta.

Por favor sugerir como eu posso fazer isso com java expressão 8 lambda, agradecimentos.

Nikolas:

A seguir Streamfaz o truque:

List<Order> o  = orders.stream().collect(
    Collectors.collectingAndThen(
        Collectors.groupingBy(Order::getPrice,Collectors.summingInt(Order::getQuantity)),
        map -> map.entrySet().stream()
                             .map(e -> new Order(e.getKey(), e.getValue()))
                             .collect(Collectors.toList())));

Vamos decompô-lo:

1. O código a seguir retorna uma Map<Integer, Integer>que contém o preço como uma chave (o valor único que você deseja basear a soma diante) e suas quantidades somadas. O método de chave é Collectors.groupingBycom classifierdescrevendo a chave e a downstreamdefinição de um valor, que seria uma soma das quantidades, por conseguinte, Collectors.summingInt(dependendo do quantitytipo):

   Map<Integer, Integer> map = orders.stream().collect(
       Collectors.groupingBy(                            // I want a Map<Integer, Integer>
           Order::getPrice,                              // price is the key
           Collectors.summingInt(Order::getQuantity))    // sum of quantities is the value
   

2. A estrutura desejada é List<Order>, portanto, você quer usar o Collectors.collectingAndThenmétodo com um Collector<T, A, R> downstreame Function<R, RR> finisher. A downstreamé o agrupamento a partir do primeiro ponto, o módulo de acabamento será uma conversão de Map<Integer, Integer>volta para List<Order>:

   List<Order> o  = orders.stream().collect(
   Collectors.collectingAndThen(
       grouping,                                                 // you know this one ;)
       map -> map.entrySet()                        
                 .stream()                                       // iterate entries
                 .map(e -> new Order(e.getKey(), e.getValue()))  // new Order(qty, price)
                 .collect(Collectors.toList())));                // as a List<Order>