Collectig Data With Stream

Question 1

count the number of dishes in the menu, using the

collector returned by the counting factory method:

Answer 1

long howManyDishes = menu.stream().collect(Collectors.counting());

You can write this far more directly as
long howManyDishes = menu.stream().count();

Question 2

Suppose you want to find the highest-calorie dish in the menu.

Answer 2

Comparator dishCaloriesComparator =
Comparator.comparingInt(Dish::getCalories);
Optional mostCalorieDish =
menu.stream()
.collect(maxBy(dishCaloriesComparator));

Question 3

Summeraization: you can find the total number of

calories in your menu list with

Answer 3

int totalCalories = menu.stream().collect(summingInt(Dish::getCalories));

Question 4

summarization: Calculate the Average

Answer 4

double avgCalories =

menu.stream().collect(averagingInt(Dish::getCalories));

Question 5

What is int SummaryStatistics?

Answer 5

For example, you can count the elements in the menu and obtain the sum, average, maximum, and minimum of the calories contained in each dish with a single
summarizing operation:

IntSummaryStatistics menuStatistics =
menu.stream().collect(summarizingInt(Dish::getCalories));

IntSummaryStatistics{count=9, sum=4300, min=120,
average=477.777778, max=800}

Question 6

Joining Strings

Answer 6

The collector returned by the joining factory method concatenates into a single string,
all strings resulting from invoking the toString method on each object in the stream.

This means you can concatenate the names of all the dishes in the menu as follows:
String shortMenu = menu.stream().map(Dish::getName).collect(joining());

Question 7

Collect vs. reduce

Answer 7

We’ve discussed reductions a lot in the previous chapter and this one. You may wonder
what the differences between the collect and reduce methods of the stream
interface are, because often you can obtain the same results using either method.
For instance, you can achieve what is done by the toList Collector using the
reduce method as follows:

Stream stream = Arrays.asList(1, 2, 3, 4, 5, 6).stream();
List numbers = stream.reduce(
new ArrayList(),
(List l, Integer e) -> {
l.add(e);
return l; },
(List l1, List l2) -> {
l1.addAll(l2);
return l1; });

This solution has two problems: a semantic one and a practical one. The semantic
problem lies in the fact that the reduce method is meant to combine two values and
produce a new one; it’s an immutable reduction. In contrast, the collect method is
designed to mutate a container to accumulate the result it’s supposed to produce.
This means that the previous snippet of code is misusing the reduce method,
because it’s mutating in place the List used as accumulator. As you’ll see in more
detail in the next chapter, using the reduce method with the wrong semantic is also
the cause of a practical problem: this reduction process can’t work in parallel,
because the concurrent modification of the same data structure operated by multiple
threads can corrupt the List itself. In this case, if you want thread safety, you’ll need
to allocate a new List every time, which would impair performance by object allocation.
This is the main reason why the collect method is useful for expressing reduction
working on a mutable container but crucially in a parallel-friendly way, as you’ll
learn later in the chapter.