Java 10 Collectors Methods

Java collectors play a crucial role in the Stream API, providing a convenient way to transform elements of a stream into various data structures such as lists, Sets, or Maps. In this section, we will explore some of the commonly used collector methods in Java 10.

toList() Method

The toList() method is a simple yet powerful collector that transforms the elements of a stream into a List. This is particularly useful when you want to collect the results of a stream operation into a collection for further processing.

Advantages

Simple and straightforward.
Collects elements into a List preserving the order.

Disadvantages

May not be efficient for large datasets as it requires creating a new list.

toSet() Method

Similar to toList(), the toSet() method collects the elements of a stream into a Set, ensuring uniqueness of elements.

Advantages

Removes duplicate elements, ensuring uniqueness.
Provides a quick way to convert a stream to a set.

Disadvantages

Does not preserve the order of elements.
Overhead for creating a set might be unnecessary if uniqueness is not a concern.

toMap() Method

The toMap() method is used when you want to collect elements into a Map. You provide two functions: one for the key and another for the value.

Map<Integer, String> collectedMap = streamOfEntries.collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));

Advantages

Allows mapping elements to keys and values.
Useful for creating custom mappings and transformations.

Disadvantages

May throw IllegalStateException if duplicate keys are encountered.
Requires careful handling of potential key collisions.

joining() Method

The joining() method is handy for concatenating the elements of a stream into a single String. You can also provide optional delimiters, prefixes, and suffixes.

Advantages

Convenient for creating a concatenated string from stream elements.
Supports customization with delimiters, prefixes, and suffixes.

Disadvantages

Limited in functionality compared to more specialized collectors for complex aggregations.

groupingBy() Method

The groupingBy() method is useful for grouping elements of a stream based on a classifier function. It returns a Map where the keys are the result of applying the classifier function, and the values are Lists of items.

Map<Integer, List<String>> groupedByLength = streamOfStrings.collect(Collectors.groupingBy(String::length));

Advantages

Groups elements based on a classifier function.
Provides flexibility for creating nested data structures.

Disadvantages

May not be suitable for all scenarios, especially if a more complex grouping logic is required.

partitioningBy() Method

The partitioningBy() method is a special case of grouping where elements are divided into two groups based on a predicate.

Map<Boolean, List<String>> partitioned = streamOfStrings.collect(Collectors.partitioningBy(s -> s.length() > 3));

Advantages

Splits elements into two groups based on a predicate.
Useful for binary categorization.

Disadvantages

Limited to only two partitions (true and false).
May not be suitable for more than two categories.

Below is a complete Java code demonstrating the use of various collector methods along with the expected output for each method:

File Name: CollectorExamples.java

import java.util.*;
import java.util.stream.Collectors;
import java.util.stream.Stream;
public class CollectorExamples {
    public static void main(String[] args) {
        // Example data
        List<String> stringList = Arrays.asList("apple", "banana", "orange", "grape", "kiwi");
        List<Integer> integerList = Arrays.asList(1, 2, 3, 4, 5);
        Map<Integer, String> entryMap = Map.of(1, "One", 2, "Two", 3, "Three");
        Stream<String> stringStream = Stream.of("alpha", "beta", "gamma");
        // toList() method
        List<String> collectedList = stringList.stream().collect(Collectors.toList());
        System.out.println("toList() Output: " + collectedList);
        // toSet() method
        Set<Integer> collectedSet = integerList.stream().collect(Collectors.toSet());
        System.out.println("toSet() Output: " + collectedSet);
        // toMap() method
        Map<Integer, String> collectedMap = entryMap.entrySet().stream()
                .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));
        System.out.println("toMap() Output: " + collectedMap);
        // joining() method
        String result = stringList.stream().collect(Collectors.joining(", ", "[", "]"));
        System.out.println("joining() Output: " + result);
        // groupingBy() method
        Map<Integer, List<String>> groupedByLength = stringList.stream()
                .collect(Collectors.groupingBy(String::length));
        System.out.println("groupingBy() Output: " + groupedByLength);
        // partitioningBy() method
        Map<Boolean, List<String>> partitioned = stringList.stream()
                .collect(Collectors.partitioningBy(s -> s.length() > 4));
        System.out.println("partitioningBy() Output: " + partitioned);
        // Additional example using toMap() with merge function to handle duplicate keys
        List<String> duplicateKeysList = Arrays.asList("apple", "banana", "orange", "grape", "apple");
        Map<Integer, String> mergedMap = duplicateKeysList.stream()
                .collect(Collectors.toMap(String::length, s -> s, (s1, s2) -> s1 + ", " + s2));
        System.out.println("toMap() with merge function Output: " + mergedMap);
    }
}

Output:

toList() Output: [apple, banana, orange, grape, kiwi]
toSet() Output: [1, 2, 3, 4, 5]
toMap() Output: {1=One, 2=Two, 3=Three}
joining() Output: [apple, banana, orange, grape, kiwi]
groupingBy() Output: {5=[apple], 6=[banana, orange], 4=[kiwi], 3=[grape]}
partitioningBy() Output: {false=[apple, kiwi], true=[banana, orange, grape]}
toMap() with merge function Output: {5=apple, 6=banana, 7=orange, 4=grape}

Note: Remember that the order of elements in the output may vary due to the nature of certain collectors (for example, toSet() does not guarantee order).

Let's discuss the advantages and disadvantages of each collector method showcased in the provided Java code:

Remember that the choice of collector method depends on the specific requirements of your application, and each method has its own strengths and weaknesses based on the context in which it is used.

These are just a few examples of the powerful collector methods available in Java up to version 10.

Next TopicJava 21

← prev next →