Collectors

Question 1

Static Imports

Answer 1

Typically, we can find all the predefined implementations in the Collectors class.
import static java.util.stream.Collectors.*;

Question 2

Collectors.toCollection()

Answer 2

When using the toSet() and toList() collectors, we can’t make any assumptions about their implementations, ie with toList() we cannot assume that we will get a LinkedList implementation
List<String> result = givenList.stream()
.collect(toCollection(LinkedList::new))
In above, result is collected to a LinkedList implementation</String>

Question 3

Collectors.toList()

Answer 3

Collect all Stream elements into a List instance. The important thing to remember is that we can’t assume any particular List implementation with this method. If we want to have more control over this, we can use toCollection() instead.

List<String> result = givenList.stream()
.collect(toList());</String>

Question 4

Collectors.toUnmodifiableList()

Answer 4

List<String> result = givenList.stream()
.collect(toUnmodifiableList());
if we try to modify result we will get an exception
assertThatThrownBy(() -> result.add("foo")) .isInstanceOf(UnsupportedOperationException.class);</String>

Question 5

Collectors.toSet()

Answer 5

Set<String> result = givenList.stream()
.collect(toSet());</String>

Question 6

Collectors.toUnmodifiableSet()

Answer 6

Set<String> result = givenList.stream()
.collect(toUnmodifiableSet());</String>

Question 7

Collectors.toMap()

Answer 7

The toMap() collector can be used to collect Stream elements into a Map instance. To do so, we need to provide two functions: keyMapper() and valueMapper().

keyMapper() to extract a Map key from a Stream element. we can use valueMapper() to extract a value associated with a given key
Map<String, Integer> result = givenList.stream()
.collect(toMap(Function.identity(), String::length))
Function.identity() is just a shortcut for defining a function that accepts and returns the same value

If it sees duplicate keys, it immediately throws an IllegalStateException.

In such cases with key collision, we should use toMap() with another signature

Map<String, Integer> result = givenList.stream()
.collect(toMap(Function.identity(), String::length, (item, identicalItem) -> item));

The third argument here is a BinaryOperator(), where we can specify how we want to handle collisions. In this case, we’ll just pick any of these two colliding values because we know that the same strings will always have the same lengths too.

Question 8

Collectors.toUnmodifiableMap()

Answer 8

Map<String, Integer> result = givenList.stream() .collect(toUnmodifiableMap(Function.identity(), String::length))
assertThatThrownBy(() -> result.put(“foo”, 3)) .isInstanceOf(UnsupportedOperationException.class);

Question 9

Collectors.collectingAndThen()

Answer 9

CollectingAndThen() is a special collector that allows us to perform another action on a result straight after collecting ends.
Let’s collect Stream elements to a List instance, and then convert the result into an ImmutableList instance:
List<String> result = givenList.stream()
.collect(collectingAndThen(toList(), ImmutableList::copyOf))</String>

Question 10

Collectors.joining()

Answer 10

The Joining() collector can be used for joining Stream<String> elements.
String result = givenList.stream() .collect(joining());
or
String result = givenList.stream()
.collect(joining(" "));</String>

Question 11

Collectors.counting()

Answer 11

Counting() is a simple collector that allows for the counting of all Stream elements.

Question 12

Collectors.summarizingDouble/Long/Int()

Answer 12

SummarizingDouble/Long/Int is a collector that returns a special class containing statistical information about numerical data in a Stream of extracted elements.
DoubleSummaryStatistics result = givenList.stream()
.collect(summarizingDouble(String::length));

assertThat(result.getAverage()).isEqualTo(2);
assertThat(result.getCount()).isEqualTo(4);
assertThat(result.getMax()).isEqualTo(3);
assertThat(result.getMin()).isEqualTo(1);
assertThat(result.getSum()).isEqualTo(8);

Question 13

Collectors.averagingDouble/Long/Int()

Answer 13

Double result = givenList.stream()
.collect(averagingDouble(String::length));

Question 14

Collectors.summingDouble/Long/Int()

Answer 14

SummingDouble/Long/Int is a collector that simply returns a sum of extracted elements
Double result = givenList.stream()
.collect(summingDouble(String::length));

Question 15

Collectors.maxBy/minBy

Answer 15

MaxBy() and MinBy() collectors return the biggest/smallest element of a Stream according to a provided Comparator instance.
Optional<String> result = givenList.stream()
.collect(maxBy(Comparator.naturalOrder()));</String>

Question 16

Collectors.groupingBy()

Answer 16

Typically, we can use the GroupingBy() collector to group objects by a given property and then store the results in a Map instance.
Map<Integer, Set<String>> result = givenList.stream()
.collect(groupingBy(String::length, toSet()));</String>

Question 17

Collectors.partitioningBy()

Answer 17

partitioningBy() is a specialized case of groupingBy() that accepts a Predicate instance, and then collects Stream elements into a Map instance that stores Boolean values as keys and collections as values. Under the “true” key, we can find a collection of elements matching the given Predicate, and under the “false” key, we can find a collection of elements not matching the given Predicate.

Map<Boolean, List<String>> result = givenList.stream()
.collect(partitioningBy(s -> s.length() > 2))</String>

{false=[“a”, “bb”, “dd”], true=[“ccc”]}