Stream.toList() (Java 16) vs collect(Collectors.toList()): unmodifiable vs mutable, breaking change

• Stream.toList() (Java 16) is a concise terminal operation that returns an unmodifiable list. Throws UnsupportedOperationException on add/remove/set/sort.
• collect(Collectors.toList()) returns a mutable ArrayList that allows all mutations (add, remove, set, sort).
• Breaking change: replacing collect(toList()) with .toList() during code modernization breaks any code that later mutates the result.
• toList() allows null elements. toUnmodifiableList() rejects nulls with NPE.
• Use .toList() for the common read-only case (clearer, less typing).
• Use collect(toList()) when you need to modify the result afterward.

What is the difference?

package com.bank.util;

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

public class ToListComparisonDemo {
    public static void main(String[] args) {
        var numbers = Stream.of(3, 1, 4, 1, 5);

        // collect(toList()) → mutable ArrayList
        List<Integer> mutable = numbers.collect(Collectors.toList());
        mutable.add(9);      // OK
        mutable.sort(null);  // OK
        System.out.println("Mutable: " + mutable);

        // Stream.toList() → unmodifiable
        List<Integer> unmod = Stream.of(3, 1, 4, 1, 5).toList();
        try {
            unmod.add(9);    // UnsupportedOperationException!
        } catch (UnsupportedOperationException e) {
            System.out.println("Cannot modify toList() result");
        }
    }
}

Mutable: [1, 1, 3, 4, 5, 9]
Cannot modify toList() result

When does swapping break code?

// Original code: works fine with mutable list
List<String> names = accounts.stream()
    .map(Account::holder)
    .collect(Collectors.toList());
names.sort(null);  // sorts the mutable list
names.add("New Account");  // adds to the mutable list

// After modernization: breaks!
List<String> names = accounts.stream()
    .map(Account::holder)
    .toList();  // unmodifiable!
names.sort(null);  // UnsupportedOperationException!

Comparison table

| Feature | collect(Collectors.toList()) | Stream.toList() | toUnmodifiableList() |
|---------|-------------------------------|-------------------|----------------------|
| Java version | 8+ | 16+ | 10+ |
| Mutability | Mutable (ArrayList) | Unmodifiable | Unmodifiable |
| Null elements | Allowed | Allowed | Rejected (NPE) |
| Encounter order | Preserved | Preserved | Preserved |
| Conciseness | Verbose | Concise | Medium |

How do you get a mutable list from toList()?

// Wrap in a new ArrayList for mutability
List<String> mutableCopy = new ArrayList<>(accounts.stream()
    .map(Account::holder)
    .toList());
mutableCopy.sort(null);  // OK

What are common mistakes?

WRONG: Blindly replacing collect(toList()) with .toList() in a codebase-wide refactor.

WRONG: Assuming Collectors.toList() is guaranteed to return an ArrayList. The specification says the returned list has "no guarantees on the type, mutability, serializability, or thread-safety." In practice it returns ArrayList, but you should not rely on this.

What should a senior engineer know?

• In new code, prefer .toList() for the common read-only case. It is shorter, signals intent, and protects against accidental mutation.
• For mutable results, use collect(Collectors.toCollection(ArrayList::new)) for an explicit, guaranteed mutable ArrayList.
• IDE tools like IntelliJ's "Modernize" inspection may suggest replacing collect(toList()) with .toList(). Review each case to ensure the result is not mutated downstream.
• The toList() method is defined directly on Stream as a default method, not in Collectors.