集合：不可变工厂与 JDK 11 的小补丁

版本地图：9、10、11 各加了什么01

集合 API 的版本归属很容易混。JDK 9 引入了不可变工厂，JDK 10 引入了 copyOf 和不可变 Collector，JDK 11 只加了几个便利方法。

下面用 --release 实测边界：List.copyOf 在 release 9 不存在，Optional.isEmpty 在 release 10 不存在，release 11 才全部通过。

import java.util.*;

public class CollApi {
    public static void main(String[] args) {
        List<String> copy = List.copyOf(List.of("a"));
        System.out.println(Optional.empty().isEmpty() + " " + copy);
    }
}

javac --release 9  : cannot find symbol: method copyOf(List<String>)
javac --release 10 : cannot find symbol: method isEmpty()
javac --release 11 : 编译通过

这段程序本身的运行输出是 true [a]；上面三行记录的是三个 --release 下的编译结果，不是运行时输出。

List.of / Map.of：短小、不可变、拒绝 null02

工厂方法返回的是高度优化的不可变集合。它们不接受 null，重复元素/键会抛异常；不要把它当成「初始化可变集合」的快捷方式。

import java.util.*;

public class FactoryDemo {
    public static void main(String[] args) {
        List<String> list = List.of("a", "b");
        System.out.println("list=" + list);
        try { list.add("c"); } catch (UnsupportedOperationException e) { System.out.println("list.add=UOE"); }
        try { list.set(0, "z"); } catch (UnsupportedOperationException e) { System.out.println("list.set=UOE"); }
        try { List.of("a", null); } catch (NullPointerException e) { System.out.println("list.null=NPE"); }

        try { Set.of("a", "a"); } catch (IllegalArgumentException e) { System.out.println("set.dup=IAE"); }
        try { Map.of("k", 1, "k", 2); } catch (IllegalArgumentException e) { System.out.println("map.dup=IAE"); }
        try { Map.of("k", null); } catch (NullPointerException e) { System.out.println("map.null=NPE"); }
    }
}

list=[a, b]
list.add=UOE
list.set=UOE
list.null=NPE
set.dup=IAE
map.dup=IAE
map.null=NPE

• List.of 的 add/set/remove 都抛 UnsupportedOperationException；它不是固定大小的 Arrays.asList。
• Set.of 的重复元素在运行时抛 IllegalArgumentException，不是编译错误。
• Map.of 的重复键同样运行时抛 IllegalArgumentException；null 键或值抛 NullPointerException。
• Map.of 最多 10 对键值；更多时用 Map.ofEntries(Map.entry(...), ...)。
• Map.of 的迭代顺序未指定，不要依赖它；需要顺序时用 LinkedHashMap 或 TreeMap。

不可变视图、固定大小、快照：三种「不可变」03

Arrays.asList 是固定大小，Collections.unmodifiableList 是只读视图，List.copyOf 是不可变快照。三者的行为差异，比「都不能 add」这句话重要得多。

import java.util.*;

public class ViewDemo {
    public static void main(String[] args) {
        List<String> src = new ArrayList<>(List.of("a"));
        List<String> view = Collections.unmodifiableList(src);
        List<String> copy = List.copyOf(src);

        src.add("b");
        System.out.println("view=" + view);
        System.out.println("copy=" + copy);
        try { view.add("c"); } catch (UnsupportedOperationException e) { System.out.println("view.add=UOE"); }
    }
}

view=[a, b]
copy=[a]
view.add=UOE

List.copyOf 会创建快照，之后源集合的变化不影响它；Collections.unmodifiableList 只是包了一层，源集合变化会立即反映。需要稳定快照时用 copyOf。

不可变集合只保证结构不可变，不保证元素对象不可变。如果元素是可变对象，修改元素内部状态仍然会反映到集合里。

List<StringBuilder> list = List.of(new StringBuilder("a"));
list.get(0).append("b");
System.out.println(list); // [ab]

JDK 11 的小补丁：isEmpty、not、toArray04

JDK 11 没有大改集合框架，但补了几个很常用的小方法。它们经常和 Stream、Optional 一起出现。

import java.util.*;
import java.util.function.Predicate;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class StreamPatch {
    public static void main(String[] args) {
        System.out.println("optional.isEmpty=" + Optional.empty().isEmpty());
        System.out.println("predicate.not=" + Stream.of("", "a", " ")
                .filter(Predicate.not(String::isBlank))
                .collect(Collectors.toList()));

        String[] arr = List.of("x", "y").toArray(String[]::new);
        System.out.println("toArray=" + Arrays.toString(arr));

        List<Integer> mutable = Stream.of(1, 2).collect(Collectors.toList());
        mutable.add(3);
        System.out.println("collector=" + mutable);

        List<Integer> unmod = Stream.of(1, 2).collect(Collectors.toUnmodifiableList());
        try { unmod.add(3); } catch (UnsupportedOperationException e) { System.out.println("unmod.add=UOE"); }
    }
}

optional.isEmpty=true
predicate.not=[a]
toArray=[x, y]
collector=[1, 2, 3]
unmod.add=UOE

Collectors.toList() 返回可变 List（实现通常是 ArrayList），Collectors.toUnmodifiableList() 返回不可变 List。JDK 11 没有 Stream.toList()，后者是 JDK 16 才加入的。

System.out.println(Stream.of(1, 2).toList());

error: cannot find symbol
  symbol:   method toList()
  location: interface Stream<Integer>

选型：可变、不可变、并发05

不可变集合不是默认答案，而是表达「这个集合不应该被修改」的工具。需要频繁增删时，可变集合更合适；需要并发写入时，ConcurrentHashMap 比同步包装更细粒度。

JDK 11 还没有 SequencedCollection。getFirst()、getLast()、reversed() 这些方法在 JDK 21 才出现；JDK 11 里请继续用 get(0)、get(size - 1) 或 Deque 的 peekFirst()。

版本边界BOUNDARY

这张表比 API 本身更值得记。写代码时先确认你的运行时版本。

费曼自检SELF CHECK

先合上页面，用自己的话回答，再展开对照。能讲出因果和反例，才算真正掌握。