java中的不可变集合

Jie2025-03-162025-04-02

一. 不可变数组

注意： 以下不可变集合工厂方法都是在java 9引入的，在之前只能通过Collections下的unmodifiableXxx()通过包装可变集合为不可变视图，但本质上仍是可变集合的代理，并非独立的不可变实现，以及一些第三方库才能获得不可变集合

Map.of() / Map.ofEntries()：创建不可变 Map。
List.of()：创建不可变 List。
Set.of()：创建不可变 Set。

尝试添加、删除或修改元素会抛出 UnsupportedOperationException。

二. java中9之前跟9之后的关键区别

特性	Java 9 不可变集合	Java 8 及更早的 Collections.unmodifiableXxx()
实现类型	独立的不可变类（如 ImmutableMap）	可变集合的包装视图（非独立类）
内存占用	更紧凑（针对小集合优化）	与原可变集合相同
性能	更快的遍历和查询操作	与原集合性能一致
线程安全性	完全线程安全	需依赖原集合的线程安全策略

三. 示例demo

1. List.of()

package com.nianxi;

import java.util.Iterator;
import java.util.List;

public class ImmutableDemo1 {
    public static void main(String[] args) {
        /*
        // 创建一个不可变的字符串
         */
        List<String> list = List.of("张三", "李四", "王五", "赵六");
        for (String s : list) {
            System.out.println(s);
        }
        System.out.println("====================================");

        Iterator<String> it = list.iterator();
        while (it.hasNext()) {
            String s = it.next();
            System.out.println(s);
        }
        System.out.println("====================================");

        for (int i = 0; i < list.size(); i++) {
            String s = list.get(i);
            System.out.println(s);
        }
        System.out.println("====================================");

//        list.remove(1);
//        list.add("田七");
//        list.set(1, "田七");
    }
}

2. Set.of()

package com.nianxi;

import java.util.Iterator;
import java.util.Set;

public class ImmutableDemo2 {
    public static void main(String[] args) {
        /*
        // 创建一个不可变的Set集合
         */
        Set<String> set = Set.of("张三", "李四", "王五", "赵六");
        for (String s : set) {
            System.out.println(s);
        }
        System.out.println("====================================");
        Iterator<String> it = set.iterator();
        while (it.hasNext()) {
            String s = it.next();
            System.out.println(s);
        }
        System.out.println("====================================");
//        set.remove("李四");
//        set.add("田七");
        set.forEach(System.out::println);
    }
}

3. Map.of()

package com.nianxi;

import java.util.Map;
import java.util.Set;

public class ImmutableDemo3 {
    public static void main(String[] args) {
        /*
        // 创建一个不可变的Map集合
        */
        Map<String, Integer> map = Map.of("张三", 20, "李四", 30, "王五", 40, "赵六", 50);
        map.forEach((k, v) -> System.out.println(k + " : " + v));
        System.out.println("====================================");
        Set<String> keys = map.keySet();
        for (String key : keys) {
            System.out.println(key + " : " + map.get(key));
        }
        System.out.println("====================================");
        Set<Map.Entry<String, Integer>> entries = map.entrySet();
        for (Map.Entry<String, Integer> entry : entries) {
            System.out.println(entry.getKey() + " : " + entry.getValue());
        }
        System.out.println("====================================");
//        map.put("田七", 60);
//        map.remove("李四");
    }
}

注意： Map.of()最大可以创建10对键值对

4. Map.copyOf()

package com.nianxi;

import java.util.HashMap;
import java.util.Map;

public class ImmutableDemo4 {
    public static void main(String[] args) {
        /*
        // 创建一个不可变的Map集合,键值对的数量超过10个
        */
        HashMap<String, Integer> map = new HashMap<>();
        map.put("张三", 20);
        map.put("李四", 30);
        map.put("王五", 40);
        map.put("赵六", 50);
        map.put("田七", 60);
        map.put("孙八", 70);
        map.put("周九", 80);
        map.put("吴十", 90);
        map.put("郑十一", 100);
        map.put("王十二", 110);
        map.put("李十三", 120);
        map.put("赵十四", 130);

//        Set<Map.Entry<String, Integer>> entries = map.entrySet();
//        Map.Entry[] array = entries.toArray(new Map.Entry[0]);
//        Map map1 = Map.ofEntries(array);//不可变的Map集合

//        Map<Object, Object> objectObjectMap = Map.ofEntries(map.entrySet().toArray(new Map.Entry[0]));
//        objectObjectMap.put("张三", 20);
        Map<String, Integer> map1 = Map.copyOf(map);
//        map1.put("张三", 20);
    }
}

Map.copyOf()源码

/**
 * Returns an <a href="#unmodifiable">unmodifiable Map</a> containing the entries
 * of the given Map. The given Map must not be null, and it must not contain any
 * null keys or values. If the given Map is subsequently modified, the returned
 * Map will not reflect such modifications.
 *
 * @implNote
 * If the given Map is an <a href="#unmodifiable">unmodifiable Map</a>,
 * calling copyOf will generally not create a copy.
 *
 * @param <K> the {@code Map}'s key type
 * @param <V> the {@code Map}'s value type
 * @param map a {@code Map} from which entries are drawn, must be non-null
 * @return a {@code Map} containing the entries of the given {@code Map}
 * @throws NullPointerException if map is null, or if it contains any null keys or values
 * @since 10
 */
@SuppressWarnings({"rawtypes","unchecked"})
static <K, V> Map<K, V> copyOf(Map<? extends K, ? extends V> map) {
    if (map instanceof ImmutableCollections.AbstractImmutableMap) {
        return (Map<K,V>)map;
    } else {
        return (Map<K,V>)Map.ofEntries(map.entrySet().toArray(new Entry[0]));
    }
}

类型检查
如果传入的 Map 是 JDK 内部不可变集合实现类（如 java.util.ImmutableCollections$MapN、java.util.Collections$UnmodifiableMap），则直接返回原 Map，无需复制。
否则，创建一个新的不可变 Map 副本。
防御性检查
无论传入的 Map 是否为不可变，都会先检查其是否包含 null 键或值。若有，则抛出 NullPointerException。

Map.ofEntries()就是专门用来面对map中超过10对键值对来使用的

/**
 * Returns an unmodifiable map containing keys and values extracted from the given entries.
 * The entries themselves are not stored in the map.
 * See <a href="#unmodifiable">Unmodifiable Maps</a> for details.
 *
 * @apiNote
 * It is convenient to create the map entries using the {@link Map#entry Map.entry()} method.
 * For example,
 *
 * <pre>{@code
 *     import static java.util.Map.entry;
 *
 *     Map<Integer,String> map = Map.ofEntries(
 *         entry(1, "a"),
 *         entry(2, "b"),
 *         entry(3, "c"),
 *         ...
 *         entry(26, "z"));
 * }</pre>
 *
 * @param <K> the {@code Map}'s key type
 * @param <V> the {@code Map}'s value type
 * @param entries {@code Map.Entry}s containing the keys and values from which the map is populated
 * @return a {@code Map} containing the specified mappings
 * @throws IllegalArgumentException if there are any duplicate keys
 * @throws NullPointerException if any entry, key, or value is {@code null}, or if
 *         the {@code entries} array is {@code null}
 *
 * @see Map#entry Map.entry()
 * @since 9
 */
@SafeVarargs
@SuppressWarnings("varargs")
static <K, V> Map<K, V> ofEntries(Entry<? extends K, ? extends V>... entries) {
    if (entries.length == 0) { // implicit null check of entries array
        @SuppressWarnings("unchecked")
        var map = (Map<K,V>) ImmutableCollections.EMPTY_MAP;
        return map;
    } else if (entries.length == 1) {
        // implicit null check of the array slot
        return new ImmutableCollections.Map1<>(entries[0].getKey(),
                entries[0].getValue());
    } else {
        Object[] kva = new Object[entries.length << 1];
        int a = 0;
        for (Entry<? extends K, ? extends V> entry : entries) {
            // implicit null checks of each array slot
            kva[a++] = entry.getKey();
            kva[a++] = entry.getValue();
        }
        return new ImmutableCollections.MapN<>(kva);
    }
}

传入对应数组类型来获取不可变数组，其中新创建的数组会与原来的map集合进行比较，如果大于，则赋值给数组，空余的赋值为null(在使用之前需对集合进行过滤，否则如果键跟值有Null的话会报NullPointerException异常)，小于的话，会直接赋值给数组。

四. 总结

不可变集合的特点？
定义完成后不可以修改，或者添加、删除
如何创建不可变集合?
List、Set、Map接口中，都存在of方法可以创建不可变集合
三种方式的细节
- List: 直接用
- Set: 元素不能重复
- Map: 元素不能重复、键值对数量最多是10个。
  超过10个用ofEntries方法