Javatpoint Logo
Javatpoint Logo

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.


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


  • 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.


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


  • 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.


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


  • 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.


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


  • 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.


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


  • 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.


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


  • 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:


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

Youtube For Videos Join Our Youtube Channel: Join Now


Help Others, Please Share

facebook twitter pinterest

Learn Latest Tutorials


Trending Technologies

B.Tech / MCA