Java8 Stream how to groupingBy and combine elements with same fields

Question

I hava an order list that contains different id and date.
Now, I need to combine order amount of same id and date.

The core of this problem maybe is how to create a Collector that counld combine Orders with same id and date, and the result is an Order list rather than a Map<Integer, List>.

Is there any other ways to simplify this flow?

public class Order {
    private Integer id;
    private LocalDate date;
    private double amount;
    public void accept(Order other) {
        setId(other.getId());
        setDate(other.getDate());
        setAmount(getAmount() + other.getAmount());
    }
    public Order combine(Order other) {
        setId(other.getId());
        setDate(other.getDate());
        setAmount(getAmount() + other.getAmount());
        return this;
    }
}

    List<Order> result = new ArrayList<>();

    List<Order> orders = mockData();
    Map<Integer, List<Order>> collect = list.stream()
            .collect(groupingBy(Order::getId));

    collect.forEach((id, orders) -> {
        Map<LocalDate, Order> resultMap = orders.stream()
                .collect(groupingBy(Order::getDate, mapping(order -> order, Collector.of(Order::new, Order::accept, Order::combine))));
        result.addAll(resultMap.values());
    });

What’s the point of wrapping a collector in mapping(order -> order, …)? There’s also no need for the accept method, as you can use the Order::combine instead of Order::accept. — Holger
– Holger, Commented Jan 12, 2023 at 10:38

Sweeper · Accepted Answer · 2023-01-12 10:56:58Z

3

I would first make a new record so that you can work with id and date at once.

record IdAndDate(Integer id, LocalDate date) {}

To not get a List<Order> as the map's value type, use the toMap collector. You can then specify a "merge function". That is where you specify Order::combine.

var result = new ArrayList<>(
    orders.stream().collect(
        Collectors.toMap(
            x -> new IdAndDate(x.getId(), x.getDate()), // key mapper
            Function.identity(), // value mapper (no change)
            Order::combine // merge function
        )
    ).values()
);

Note that Order.combine changes the instance on which it is called, which means that some of the orders in the original list would be changed by this operation. This is also true for your original code, so I'll assume this fact doesn't matter in your case. Just in case you don't want that to happen, you should make combine return a new instance of Order, instead of this.

edited Jan 12, 2023 at 10:56

answered Jan 12, 2023 at 9:12

Sweeper

292k23 gold badges260 silver badges438 bronze badges

Sign up to request clarification or add additional context in comments.

2 Comments

Holger Over a year ago

…and when you’re on an older Java version without record, you can use x -> Arrays.asList(x.getId(), x.getDate()) instead of x -> new IdAndDate(x.getId(), x.getDate()). It’s worth noting that the solution modifies some of the existing Order objects (just like the original code).

Sweeper Over a year ago

@Holger Thanks for pointing that out. I felt like I forgot something too :)

Eritrean · Accepted Answer · 2023-01-12 10:55:46Z

1

You could also nest the groupingBy calls and do it like:

List<Order> orders = mockData();

List<Order> result = orders.stream()   // Stream<Order>
                           .collect(Collectors.groupingBy(Order::getId,
                                      Collectors.groupingBy(Order::getDate)))   //Map<Integer, Map<LocalDate,List<Order>>>
                          .values()   //Collection<Map<LocalDate,List<Order>>>
                          .stream()    ////Stream<Map<LocalDate,List<Order>>>
                          .flatMap(m -> m.values().stream())    //Stream<List<Order>>
                          .map(list -> list.stream().reduce(Order::combine).get())     // Stream<Order>
                          .collect(Collectors.toList());

edited Jan 12, 2023 at 10:55

answered Jan 12, 2023 at 9:35

Eritrean

16.6k3 gold badges25 silver badges28 bronze badges

5 Comments

pebble unit Over a year ago

Hi Eritrean, I dont quite understand this part .flatMap(m -> m.values().stream()) .map(list -> list.stream().reduce(Order::combine).get()). Could you explain what it is doing here? It looks like you are extracting the nested Map and getting its values? Is streaming it necessary?

Holger Over a year ago

You should not use reduce with Order::combine, as this function modifies one of its inputs.

Eritrean Over a year ago

@experimentunit1998X The nested groupingBy produces a xxx. Since the OP wants to merge the orders that have the same id and belong to the same tag, I first stream over the values of the outer map and reduce the values of the inner map for the respective day. See my edit, hope it is clearer with the type of the stream after each step.

Eritrean Over a year ago

@Holger I thought that was the intention of OP. What do you recomend instead of reduce ?

Holger Over a year ago

The simplest approach is to use a Collector producing the intended result in the first place, instead of first collecting into a List and then perform another Stream operation on the list. Just like the OP already did. This still bears the problematic design of modifying the incoming objects, but it least, it doesn’t clash with the concept of Reduction. (And it’s more efficient than producing intermediate lists)

Collectives™ on Stack Overflow

Java8 Stream how to groupingBy and combine elements with same fields

2 Answers 2

2 Comments

5 Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

2 Comments

5 Comments

Your Answer

Sign up or log in

Post as a guest

Related