4

What I wanted to do was to add 10min if consecutive orders have the same postcode, otherwise, add 30 min to the journey. For example, if I have a class like the following this is how i achieve that imperatively.

@Data @AllArgsConstructor public static class Order{ private String orderNumber; private final String postCode; } Order order1 = new Order("1","N1"); Order order2 = new Order("2","N1"); Order order3 = new Order("3","N3"); Order order4 = new Order("4","N4"); List<Order> orders = List.of(order1, order2, order3, order4); int totalMin = 0; for (int i=0;i < orders.size()-1 ; i++ ){ if (orders.get(i+1).getPostCode().equals(orders.get(i).getPostCode())){ totalMin+=10; } else{ totalMin+=30; } } System.out.println(totalMin) // 70 // if order 2 is new Order("2","N2"); // 90

How can I achieve the same thing, or convert the above using Java 8 streams? I tried the reduce function but couldn't get my head around it.

Improve this question

3 Answers 3

Reset to default
3

You could use IntStream for that : 

int totalMin = IntStream.range(0, orders.size()-1) .map(i-> orders.get(i+1).getPostCode().equals(orders.get(i).getPostCode()) ? 10 : 30) .sum();
Improve this answer
Sign up to request clarification or add additional context in comments.

Comments

0

Here is a Collector-based approach that achieves the desired goal:

class State { String firstPostCode; String lastPostCode; int total; } int totalMin = orders.stream().collect(Collector.of( State::new, (State s, Order o) -> { if (s.firstPostCode == null) { s.firstPostCode = o.getPostCode(); } else { s.total += o.getPostCode().equals(s.lastPostCode) ? 10 : 30; } s.lastPostCode = o.getPostCode(); }, (State s1, State s2) -> { s1.total += s2.total + (s1.lastPostCode.equals(s2.firstPostCode) ? 10 : 30); s1.lastPostCode = s2.lastPostCode; return s1; }, (State s) -> s.total) );

This (parallelizable) collector sums the elements according to the desired rules.

Since collectors are required to support parallel execution (e.g. orders.parallelStream().collect(collector), some complexity is added to the implementation. Notably, the State keeps track of the fist and last post code of each run, so that when two adjacent states are combined, it is known whether the adjacent orders were in the same post codes or not.

The accumulator compares the post codes of the current and previous elements, and adds 10 or 30 to the total depending on whether they're the same. If it was the first element encountered, it sets the first post code. It also sets the last post code to the current post code.

The combiner adds the totals of the two states together, plus 10 or 30 depending on whether the last post code of the first state was equal to the first post code of the second state (i.e. whether the adjacent boundary elements were in the same post code). It uses the first post code of the first state and the last post code of the second state.

The supplier function creates an empty state with total 0, and the finisher function returns the total of the state (throwing away the rest of the state data).

Improve this answer

Comments

0

The windowSliding gatherer added in Java 24 (as part of the Stream Gatherers feature) can be used to achieve the stated goal, comparing each adjacent pair of elements:

int totalMin = orders.stream() .gather(Gatherers.windowSliding(2)) .mapToInt(w -> w.getFirst().getPostCode().equals(w.getLast().getPostCode()) ? 10 : 30) .sum();

This converts the Stream<Order> to a Stream<List<Order>>. Each list element in the new stream is a 2-element list of an adjacent pair of orders.

Improve this answer

Comments

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.