The Collectors.partitioningBy is a method in Java’s java.util.stream.Collectors class that is used to partition elements of a stream into two groups based on a predicate. It essentially creates a Map with a boolean key (true or false) and lists of elements as values. Here’s an explanation of how to use it effectively:

Syntax:

Collectors.partitioningBy(Predicate<? super T> predicate)

Description:

1. Predicate: This is a functional interface that tests a condition on elements of the stream. Each element in the stream is evaluated against this condition.
2. Result: The partitioningBy collector returns a Map with two entries:
   • Key true: Contains elements for which the predicate evaluates to true.
   • Key false: Contains elements for which the predicate evaluates to false.

Example:

Here’s an example usage of partitioningBy:

package org.kodejava.util.stream;

import java.util.*;
import java.util.stream.Collectors;

public class PartitioningExample {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);

        // Partition numbers into even and odd
        Map<Boolean, List<Integer>> partitions = numbers.stream()
                .collect(Collectors.partitioningBy(num -> num % 2 == 0));

        // Access partitions
        List<Integer> evens = partitions.get(true);  // Numbers divisible by 2 (even numbers)
        List<Integer> odds = partitions.get(false); // Numbers not divisible by 2 (odd numbers)

        System.out.println("Even Numbers: " + evens);
        System.out.println("Odd Numbers: " + odds);
    }
}

Output:

Even Numbers: [2, 4, 6, 8, 10]
Odd Numbers: [1, 3, 5, 7, 9]

Advanced Usage:

You can extend the functionality of partitioningBy by combining it with other collectors, such as Collectors.mapping or Collectors.counting.

Example: Count of elements in each partition

Map<Boolean, Long> partitionedCount = numbers.stream()
        .collect(Collectors.partitioningBy(num -> num % 2 == 0, Collectors.counting()));

System.out.println(partitionedCount);
// Output: {false=5, true=5}

In this example, instead of partitioning into lists, the partitioning is configured to count the number of elements in each group.

---

When to Use partitioningBy:

Use Collectors.partitioningBy when:

• You need to classify a collection of items into two mutually exclusive groups.
• The condition for classification is a boolean predicate.

It’s commonly used in scenarios like:

• Splitting numbers into even and odd.
• Categorizing people into adults and minors based on age.
• Determining whether elements in a list satisfy a specific condition, e.g., “passing grade” or “failing grade.”