Java Streams Collector Operations Explained with Examples

-

Collectors are the workhorses of Stream terminal aggregation in Java 8. They let you join strings, group and partition data, build specific collection types, and compute statistics — all in a fluent, readable style.

1) Collectors.joining() — Concatenate elements

Concatenate stream elements into a single string with optional delimiter, prefix, and suffix.

List<String> words = Arrays.asList("apple", "banana", "cherry");
String joined = words.stream()
    .collect(Collectors.joining(", ", "[", "]"));
System.out.println(joined); // [apple, banana, cherry]

2) Collectors.groupingBy() — Group by classifier

Group elements based on a key extractor. Default downstream is toList().

List<Person> people = Arrays.asList(
    new Person("John",  "New York"),
    new Person("Wick",  "London"),
    new Person("Smith", "New York")
);

Map<String, List<Person>> byCity = people.stream()
    .collect(Collectors.groupingBy(Person::getCity));

System.out.println(byCity);

2.1) groupingBy with a downstream collector

Count how many people per city using counting(). You can plug in many downstream collectors like mapping, toSet, etc.

Map<String, Long> countsPerCity = people.stream()
    .collect(Collectors.groupingBy(Person::getCity, Collectors.counting()));
System.out.println(countsPerCity); // {London=1, New York=2}

2.2) groupingBy with custom map type + downstream

Produce a TreeMap of cities to uppercase names list, preserving key order.

Map<String, List<String>> namesByCity = people.stream()
    .collect(Collectors.groupingBy(
        Person::getCity,
        java.util.TreeMap::new,
        Collectors.mapping(p -> p.getName().toUpperCase(), Collectors.toList())
    ));
System.out.println(namesByCity);

3) Collectors.partitioningBy() — Split into true/false buckets

Partition elements by a predicate (exactly two groups).

List<Integer> nums = Arrays.asList(1,2,3,4,5,6);
Map<Boolean, List<Integer>> evensAndOdds = nums.stream()
    .collect(Collectors.partitioningBy(n -> n % 2 == 0));
System.out.println(evensAndOdds); // {false=[1, 3, 5], true=[2, 4, 6]}

4) Numeric aggregations — summingInt, averagingInt, summarizingInt

Quick math over a stream of numbers.

List<Integer> vals = Arrays.asList(1,2,3,4,5);
int sum = vals.stream().collect(Collectors.summingInt(n -> n));
double avg = vals.stream().collect(Collectors.averagingInt(n -> n));
java.util.IntSummaryStatistics stats = vals.stream()
    .collect(Collectors.summarizingInt(n -> n));
System.out.println(sum);   // 15
System.out.println(avg);   // 3.0
System.out.println(stats); // count=5, sum=15, min=1, average=3.0, max=5

5) Collectors.mapping() — Transform before collecting

Apply a mapping function as part of the collect phase (often with groupingBy).

List<String> upperNames = people.stream()
    .collect(Collectors.mapping(p -> p.getName().toUpperCase(), Collectors.toList()));
System.out.println(upperNames); // [JOHN, WICK, SMITH]

6) Building collections — toList, toSet, toCollection

Choose the target collection type explicitly.

List<Integer> raw = Arrays.asList(1,1,2,3,4,4,5);

// Set (remove duplicates, no defined iteration order)
java.util.Set<Integer> asSet = raw.stream().collect(Collectors.toSet());

// Specific collection type (LinkedList here)
java.util.LinkedList<Integer> linked = raw.stream()
    .collect(Collectors.toCollection(java.util.LinkedList::new));

System.out.println(asSet);
System.out.println(linked);

7) Collectors.toMap() — Build a Map (with merge + map type)

When keys may collide, supply a merge function; you can also pick the map implementation.

// Name -> City (merging keeps the first value for duplicate names)
java.util.Map<String, String> nameToCity = people.stream()
    .collect(Collectors.toMap(
        Person::getName,
        Person::getCity,
        (left, right) -> left // merge on duplicate key
    ));

// Preserve insertion order with LinkedHashMap
java.util.Map<String, String> ordered = people.stream()
    .collect(Collectors.toMap(
        Person::getName,
        Person::getCity,
        (l, r) -> l,
        java.util.LinkedHashMap::new
    ));

System.out.println(nameToCity);
System.out.println(ordered);

8) Collectors.counting() — Count elements

Standalone or as a downstream (e.g., with groupingBy).

List<String> letters = Arrays.asList("a","bb","ccc","dddd");
long total = letters.stream().collect(Collectors.counting());
System.out.println(total); // 4

Person class (used in examples)

class Person {
    private String name;
    private String city;

    Person(String name, String city) {
        this.name = name;
        this.city = city;
    }
    public String getName() { return name; }
    public String getCity() { return city; }

    @Override public String toString() {
        return "Person{" +
               "city='" + city + '\'' +
               ", name='" + name + '\'' +
               '}';
    }
}

When to use what?

  • joining → build one string from many values
  • groupingBy → bucketize by key; combine with downstreams like counting, mapping
  • partitioningBy → boolean split (true/false)
  • summing/averaging/summarizing → quick number stats
  • toSet/toCollection → pick the exact collection type
  • toMap → control key collisions and map implementation
  • counting → element totals or per-group counts

All examples are Java 8 compatible. Pair these collectors with intermediate ops (map, filter, flatMap) to build expressive, high-performance pipelines.

Labels: Java Streams, Java 8, Collectors, groupingBy, partitioningBy, toMap, joining, summarizingInt, mapping, toSet, toCollection, Stream API, DevForgeHub

Comments

Post a Comment

Popular posts from this blog

Spring Boot on AWS EC2: Upload to S3 Securely Using IAM Role

-
When running a Spring Boot application on AWS EC2 , the most common security mistake is hardcoding AWS access keys inside application.properties . This is unnecessary and risky. AWS already provides a secure mechanism: IAM Roles attached to EC2 . In this blog, you will learn how to upload and download files to Amazon S3 from Spring Boot running on EC2 without any access keys , using: Spring Profiles AWS SDK v2 Instance Metadata Service (IMDS) IAM Roles Why Access Keys Are a Bad Idea on EC2 Typical S3 setups use: Access key Secret key Region Bucket This works only for local development. It should NOT be used on EC2. Problems with access keys: Stored in config or code (high risk) Might leak through Git, logs, or screenshots Require manual rotation Not needed if app runs on EC2 AWS automatically manages temporary credentials using the EC2 Instance Profile (IAM Role) . Architecture: EC2 → IAM Role → S3 Spring Boot app r...
Read more

Java Streams Intermediate Operations Explained with Examples

-
Image
The Java Stream API lets you process collections in a fluent, declarative style. In this post, we’ll walk through the most useful intermediate operations with simple examples. Note: Examples below use Java 8 compatible collect(Collectors.toList()) . If you’re on Java 16+, you can replace it with toList() . 1) filter() — Select elements by a condition Keeps only elements that match the predicate. List<Integer> list = Arrays.asList(1,2,3,4,5,6,7,8,9,10); List<Integer> res = list.stream() .filter(num -> num % 2 != 0) // keep only odd numbers .collect(Collectors.toList()); System.out.println(res); // [1, 3, 5, 7, 9] 2) map() — Transform each element Applies a function to every element and returns a stream of results. List<String> strs = Arrays.asList("rama", "anjaneya", "krishna"); List<String> upper = strs.stream() .map(String::toUpperCase) .collect(Collectors.toList()); System.o...
Read more

ConcurrentHashMap vs Synchronized HashMap in Java

-
Image
Introduction In multi-threaded Java applications, managing shared data safely and efficiently is crucial. Two common approaches are using Synchronized HashMap (via Collections.synchronizedMap(...) ) and ConcurrentHashMap . While both aim to provide thread-safety, their implementations and performance characteristics differ significantly. This post explores these differences in detail. What is a Synchronized HashMap? Created by wrapping a regular HashMap using: Map<K, V> syncMap = Collections.synchronizedMap(new HashMap<>()); Enforces synchronization at the object level , meaning only one thread can access the map at any time (read or write). Supports null keys and values since it relies on HashMap behavior. Iterators are fail-fast , throwing ConcurrentModificationException if the map is modified while iterating. Simpler implementation, suitable when concurrency is low or performance is not cri...
Read more