	In Browser
	StumbleUpon
	del.icio.us
	Google
	Google Buzz
	reddit
	LinkedIn

	Facebook
	Twitter
	Linkedin
	E-Mail

Java 8 Features > Stream API > Java 8 Collectors - groupingBy, partitioningBy and joining

Java 8 Collectors - groupingBy, partitioningBy and joining

Author: Venkata Sudhakar

The Collectors utility class in Java 8 provides a rich set of terminal operations for the Stream API. While methods like collect(Collectors.toList()) and collect(Collectors.toSet()) are well known, the most powerful collectors are groupingBy(), partitioningBy(), counting(), summarizingInt(), and joining(). These allow you to perform SQL-like aggregations entirely in Java without writing loops - grouping orders by status, partitioning customers by region, computing average order values, or joining names into a comma-separated string.

Collectors can be composed: a downstream collector is passed as the second argument to groupingBy() to perform a secondary aggregation on each group. For example, groupingBy(status, counting()) counts orders per status, groupingBy(status, summingDouble(Order::getAmount)) sums order amounts per status, and groupingBy(status, toList()) collects each group into a List. This composability makes Collectors one of the most expressive features of the Java Stream API for data aggregation tasks.

The below example demonstrates the most useful Collectors on a list of orders from a data migration context - grouping, partitioning, summarising, and joining.

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

public class CollectorsExample {

record Order(String id, String status, String region, double amount) {}

public static void main(String[] args) {
        List<Order> orders = List.of(
            new Order("ORD-1", "COMPLETED", "APAC",   450.00),
            new Order("ORD-2", "PENDING",   "EMEA",   890.00),
            new Order("ORD-3", "COMPLETED", "APAC",   120.00),
            new Order("ORD-4", "FAILED",    "EMEA",   670.00),
            new Order("ORD-5", "PENDING",   "APAC",   300.00),
            new Order("ORD-6", "COMPLETED", "AMER",  1200.00),
            new Order("ORD-7", "FAILED",    "AMER",   450.00)
        );

// 1. groupingBy: group orders by status -> Map<String, List<Order>>
        Map<String, List<Order>> byStatus =
            orders.stream().collect(Collectors.groupingBy(Order::status));
        System.out.println("Orders by status:");
        byStatus.forEach((status, list) ->
            System.out.println("  " + status + ": " + list.size() + " orders"));

// 2. groupingBy + counting: count orders per status
        Map<String, Long> countByStatus =
            orders.stream().collect(
                Collectors.groupingBy(Order::status, Collectors.counting()));
        System.out.println("\nCount by status: " + countByStatus);

// 3. groupingBy + summingDouble: total revenue per region
        Map<String, Double> revenueByRegion =
            orders.stream().collect(
                Collectors.groupingBy(Order::region,
                    Collectors.summingDouble(Order::amount)));
        System.out.println("\nRevenue by region: " + revenueByRegion);

// 4. groupingBy + averagingDouble: average order value per region
        Map<String, Double> avgByRegion =
            orders.stream().collect(
                Collectors.groupingBy(Order::region,
                    Collectors.averagingDouble(Order::amount)));
        avgByRegion.forEach((r, avg) ->
            System.out.printf("  %s avg: $%.2f%n", r, avg));
    }
}

It gives the following output,

Orders by status:
  COMPLETED: 3 orders
  PENDING: 2 orders
  FAILED: 2 orders

Count by status: {COMPLETED=3, PENDING=2, FAILED=2}

Revenue by region:
  APAC avg: $290.00
  EMEA avg: $780.00
  AMER avg: $825.00

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

public class CollectorsExample2 {

record Order(String id, String status, String region, double amount) {}

// 5. partitioningBy: split into two groups (true/false predicate)
        Map<Boolean, List<Order>> partition =
            orders.stream().collect(
                Collectors.partitioningBy(o -> o.amount() > 500.0));
        System.out.println("High value (>$500): " +
            partition.get(true).stream().map(Order::id).collect(Collectors.joining(", ")));
        System.out.println("Normal value:       " +
            partition.get(false).stream().map(Order::id).collect(Collectors.joining(", ")));

// 6. summarizingDouble: count, sum, min, max, avg in one pass
        DoubleSummaryStatistics stats =
            orders.stream().collect(
                Collectors.summarizingDouble(Order::amount));
        System.out.printf("%nAmount stats: count=%d, sum=%.2f, min=%.2f, max=%.2f, avg=%.2f%n",
            stats.getCount(), stats.getSum(),
            stats.getMin(), stats.getMax(), stats.getAverage());

// 7. joining: build a CSV of order IDs
        String csv = orders.stream()
            .map(Order::id)
            .collect(Collectors.joining(", ", "[", "]"));
        System.out.println("\nOrder IDs: " + csv);

// 8. toMap: build a lookup Map<id, order>
        Map<String, Order> orderMap = orders.stream()
            .collect(Collectors.toMap(Order::id, o -> o));
        System.out.println("\nLookup ORD-3: " + orderMap.get("ORD-3"));
    }
}

It gives the following output,

High value (>$500): ORD-2, ORD-4, ORD-6
Normal value:       ORD-1, ORD-3, ORD-5

Amount stats: count=6, sum=3630.00, min=120.00, max=1200.00, avg=605.00

Order IDs: [ORD-1, ORD-2, ORD-3, ORD-4, ORD-5, ORD-6]

Lookup ORD-3: Order[id=ORD-3, status=COMPLETED, region=APAC, amount=120.0]

Key Collectors to memorise:

Collectors.toList(), toSet(), toUnmodifiableList() - basic collection. Collectors.toMap(keyFn, valueFn) - build a Map, add a merge function as third arg to handle duplicate keys. Collectors.groupingBy(classifier) and groupingBy(classifier, downstream) - group by a key with optional secondary aggregation. Collectors.partitioningBy(predicate) - split into exactly two groups. Collectors.joining(delimiter, prefix, suffix) - build strings. Collectors.counting(), summingInt/Long/Double(), averagingInt/Long/Double(), summarizingInt/Long/Double() - numeric aggregations. Collectors.collectingAndThen(downstream, finisher) - apply a final transformation to the collected result.

Send your comments, suggestions or queries regarding this site to [email protected].