Immutable collections

For this lesson, we'll focus on the three tiers you need in interviews and code review: unmodifiable views, unmodifiable copies and Java's immutable factory collections. We'll also cover Arrays.asList, UnsupportedOperationException, immutable map implementations, stream collectors, shallow immutability, defensive copies and performance notes. Interviewers love this one because the words sound interchangeable until a production object changes behind your back.

01Picture it first: window, snapshot, printed menu

Let's get the picture right first. An unmodifiable view is a window into someone else's room: you cannot move furniture through the window, but if the owner moves a chair, you see it. An unmodifiable copy is a photo taken once. An immutable factory collection is closer to a printed menu built for sharing.

Fig. 1

A mutable source list feeds three variants: an unmodifiable view that still sees source changes, a copy that does not, and an immutable factory list that has no source

Notice the source arrow. The view keeps pointing at the original collection. The copy and factory collection do not, although they still point at the same element objects unless you copy those too.

02Three tiers under the hood: view, copy, factory

The simple option is a wrapper. It stops writes through your reference and is cheap to create. It stops being enough when the original collection can still be mutated somewhere else, which is most API boundaries.

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class ImmutableTiersDemo {
    public static void main(String[] args) {
        List<String> source = new ArrayList<>(List.of("card", "cash"));

        List<String> view = Collections.unmodifiableList(source);
        List<String> copy = List.copyOf(source);
        List<String> factory = List.of("card", "cash");

        source.add("refund");

        System.out.println(view);       // [card, cash, refund]
        System.out.println(copy);       // [card, cash]
        System.out.println(factory);    // [card, cash]

        try {
            view.add("wire");
        } catch (UnsupportedOperationException expected) {
            System.out.println("view rejects writes through itself");
        }
    }
}

Notice three things:

• view is read-only, not independent. It delegates reads to source.
• copy is independent from later structural changes to source, but it is still shallow.
• factory never had a mutable source in the first place.

List.copyOf, Set.copyOf and Map.copyOf were added in Java 10. If the input is already one of the JDK's immutable collections, copyOf is allowed to return the same instance. That is good: copying an immutable value again buys nothing.