Java不可变集合（超详解）

不可变集合的定义

不可变集合，顾名思义，就是不可以被修改的集合。一旦该集合创建完毕，其长度和内容均不能改变（不能增加或者减少元素），只能查找集合内的元素。

创建不可变集合的应用场景

1.如果某个数据不能被修改，把它防御性地拷贝到不可变集合中是个很好的实践；
2.当集合对象被不可信的库调用的时候，不可变形式是安全的。

以上两点简而言之就是：如果在创建集合的过程中不希望别人修改集合中的内容，那么就可以创建不可变集合，使得别人在使用此集合的时候只能进行查找操作（例如斗地主的牌，电脑硬件型号等）。

创建不可变集合的书写格式

在List，Set，Map接口中，都存在 静态的of方法，可以获取一个不可变的集合

static<E> List<E> of(E...elements) //创建一个具有指定元素的List集合对象
static<E> Set<E> of(E...elements) //创建一个具有指定元素的Set集合对象
static<E> Map<E> of(E...elements) //创建一个具有指定元素的Map集合对象

注意：这个集合不能添加，不能删除，不能修改。

代码实现（List）

先创建List集合，此处调用静态方法List.of来创建一个不可变的List集合，以及调用其常见的遍历方法进行遍历：

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

public class ImmutableDemo1 {
    public static void main(String[] args) {
        /**
         * 创建不可变的List集合
         * "张三","李四","王五","赵六"
         */

        //一旦创建完毕之后，是无法进行修改的，在下面的代码中，只能进行查询操作
        List<String> list = List.of("张三", "李四", "王五", "赵六");

        //用list调用get方法
        System.out.println(list.get(0));
        System.out.println(list.get(1));
        System.out.println(list.get(2));
        System.out.println(list.get(3));

		//增强for遍历
        for (String s : list) {
            System.out.println(s);
        }

        //迭代器遍历
        Iterator<String> it = list.iterator();
        while(it.hasNext()){
            System.out.println(it.next());
        }

        //lambda表达式遍历
        list.forEach( s -> System.out.println(s));

        //方法引用遍历
        list.forEach(System.out::println);
        
		
    }
}

代码运行结果如下（五种遍历方式结果相同）：

张三
李四
王五
赵六

此时，我们在上述代码中添加方法来修改集合中的元素

list.set(0,"aaa");
list.add("zzz");
list.remove("张三");

运行结果报错如下：

Exception in thread "main" java.lang.UnsupportedOperationException
	at java.base/java.util.ImmutableCollections.uoe(ImmutableCollections.java:142)
	at java.base/java.util.ImmutableCollections$AbstractImmutableList.set(ImmutableCollections.java:260)
	at ImmutableDemo1.main(ImmutableDemo1.java:38)

此处报错很明显是因为我们创建的list集合是一个静态集合，静态集合中的元素是不可以被改变的。

代码实现（Set）

创建方法与上面的List集合大同小异，代码如下：

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

public class ImmutableDemo2 {
    public static void main(String[] args) {
        /**
         * 创建不可变的Set集合
         * "张三","李四","王五","赵六"
         */

        //一旦创建完毕之后，是无法进行修改的，在下面的代码中，只能进行查询操作
        Set<String> set = Set.of("张三","李四","王五","赵六");


        //增强for遍历
        for (String s : set) {
            System.out.println(s);
        }

        //迭代器遍历
        Iterator<String> it = set.iterator();
        while(it.hasNext()){
            System.out.println(it.next());
        }

        //lambda表达式遍历
        set.forEach( s -> System.out.println(s));

        //方法引用遍历
        set.forEach(System.out::println);
    }
}

代码运行结果如下：

赵六
张三
王五
李四

同样使用remove，add方法：

set.remove("王五");
set.add("aaa");

运行结果如下：

Exception in thread "main" java.lang.UnsupportedOperationException
	at java.base/java.util.ImmutableCollections.uoe(ImmutableCollections.java:142)
	at java.base/java.util.ImmutableCollections$AbstractImmutableCollection.remove(ImmutableCollections.java:150)
	at ImmutableDemo2.main(ImmutableDemo2.java:32)

此处，上述方法同样不能修改Set集合中的元素。

值得一提的是，Set集合中元素是唯一的，故Set不可变集合中元素不能重复：

Set<String> set = Set.of("张三","李四","王五","赵六","赵六"); 
//此处我们创建了一个带有重复元素的Set集合，重复元素为赵六

代码运行结果如下：

Exception in thread "main" java.lang.IllegalArgumentException: duplicate element: 赵六
	at java.base/java.util.ImmutableCollections$SetN.(ImmutableCollections.java:918)
	at java.base/java.util.Set.of(Set.java:544)
	at ImmutableDemo2.main(ImmutableDemo2.java:13)

如上文：因为Set集合中出现了两个一样的“赵六”，故报错，所以当我们使用Set不可变集合的时候，我们要确保Set集合中元素的唯一性。

代码实现（Map）

创建方式以及其遍历方式如下：

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

public class ImmutableDemo3 {
    public static void main(String[] args) {
        /**
         * 创建不可变的Map集合
         *
         * "张三","南京","李四","北京","王五","上海","赵六","广州"
         */
        //一旦创建完毕之后，是无法进行修改的，在下面的代码中，只能进行查询操作
        Map<String, String> map = Map.of("张三", "南京", "李四", "北京", "王五", "上海", "赵六", "广州");


        Set<String> keys = map.keySet();

        //增强for遍历
        for (String key : keys) {
            String value = map.get(key);
            System.out.println(key + "=" + value);
        }

        //entrySet方法遍历
        Set<Map.Entry<String, String>> entries = map.entrySet();
        for (Map.Entry<String, String> entry : entries) {
            String key = entry.getKey();
            String value = entry.getValue();
            System.out.println(key + "=" + value);
        }
    }
}

运行结果如下：

李四=北京
赵六=广州
张三=南京
王五=上海
==========================
李四=北京
赵六=广州
张三=南京
王五=上海

此处我们同样调用put，remove，clear方法

map.put("aaa","bbb");
map.remove("张三");
map.clear();

程序运行结果如下：

Exception in thread "main" java.lang.UnsupportedOperationException
	at java.base/java.util.ImmutableCollections.uoe(ImmutableCollections.java:142)
	at java.base/java.util.ImmutableCollections$AbstractImmutableMap.put(ImmutableCollections.java:1072)
	at ImmutableDemo3.main(ImmutableDemo3.java:33)

与上文中List，Set集合一致，此处不能修改Map集合。

在之前我们已经知道：Map集合与Set集合一样，不能出现重复元素，那么键或者值其中之一相同的时候能否正常创建集合呢？

我们将上面已经创建好的Map集合中增加一个重复键：

Map<String, String> map = Map.of("张三", "南京", "李四", "北京", "王五", "上海", "赵六", "广州","赵六", "长沙");
//此处多了一个“赵六”，“长沙”

程序运行结果如下：

Exception in thread "main" java.lang.IllegalArgumentException: duplicate key: 赵六
	at java.base/java.util.ImmutableCollections$MapN.(ImmutableCollections.java:1189)
	at java.base/java.util.Map.of(Map.java:1443)
	at ImmutableDemo3.main(ImmutableDemo3.java:12)

既然键一样会报错，那么值一样是否依然会报错呢？

Map<String, String> map = Map.of("张三", "南京", "李四", "北京", "王五", "上海", "赵六", "广州","钱七", "广州");
//此处键“钱七”的值对应的值“广州”与键“赵六”相等

程序运行结果如下：

王五=上海
钱七=广州
赵六=广州
张三=南京
李四=北京

我们发现程序可以正常的运行，因此我们得出结论：在创建Map不可变集合中，可以出现键不同值相同的情况。

Map不可变集合的特殊点

Map中的of方法，参数是有上限的，最多只能传递20个参数，也就是10个键值对：

我们调用了Map接口的底层源码，发现Map在创建不可变集合的静态方法中有若干个代码相似，参数不同的创建方法，其中能创建最多参数的创建方法如下：

static <K, V> Map<K, V> of(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5,
                               K k6, V v6, K k7, V v7, K k8, V v8, K k9, V v9, K k10, V v10) {
        return new ImmutableCollections.MapN<>(k1, v1, k2, v2, k3, v3, k4, v4, k5, v5,
                                               k6, v6, k7, v7, k8, v8, k9, v9, k10, v10);
    }

那么为什么Map集合不能和List，Set集合一样，创建任意元素个数的集合呢？

因此，本人便尝试如下代码：

发现编译时直接报错，原因是可变参数必须是在所有参数的最末尾。

那难道我们创建Map不可变集合时，只能创建最多十个键值对的集合了吗？

答案当然是不可能，毕竟我们能想到的问题在Java开发的时候就已经被思考过了。

于是Map接口中就存在了这么一个方法：

@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);
        }
    }

既然两个可变参数不能放在一起，那么我们把键值放在一起形成一个entry键值对总可以创建一个任意长度的Map集合了吧。

于是便有了以下创建任意长度的Map不可变集合的方法：

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

public class ImmutableDemo4 {
    public static void main(String[] args) {

        /*
            创建Map的不可变集合,键值对的数量超过10个
        */

        //1.创建一个普通的Map集合
        HashMap<String, String> hm = new HashMap<>();
        hm.put("张三", "南京");
        hm.put("李四", "北京");
        hm.put("王五", "上海");
        hm.put("赵六", "北京");
        hm.put("孙七", "深圳");
        hm.put("周八", "杭州");
        hm.put("吴九", "宁波");
        hm.put("郑十", "苏州");
        hm.put("刘一", "无锡");
        hm.put("陈二", "嘉兴");
        hm.put("aaa", "111");

        //2.利用上面的数据来获取一个不可变的集合

/*        //获取到所有的键值对对象（Entry对象）
        Set> entries = hm.entrySet();
        //把entries变成一个数组
        Map.Entry[] arr1 = new Map.Entry[0];
        //toArray方法在底层会比较集合的长度跟数组的长度两者的大小
        //如果集合的长度 > 数组的长度 ：数据在数组中放不下，此时会根据实际数据的个数，重新创建数组
        //如果集合的长度 <= 数组的长度：数据在数组中放的下，此时不会创建新的数组，而是直接用
        Map.Entry[] arr2 = entries.toArray(arr1);
        //此处创建了一个不可变的map集合
        Map map = Map.ofEntries(arr2);
        map.put("bbb","222"); //此处代码报错，原因和上面一致：不可变集合不能使用除查询外的一切修改元素方法
        */


        Map<Object, Object> map = Map.ofEntries(hm.entrySet().toArray(new Map.Entry[0])); //链式编程方法创建，效果与上面一致


        Map<String, String> map = Map.copyOf(hm);//此处用到的copyOf方法就是Java为了方便我们创建一个Map不可变集合而创建的函数，但是JDK10之后才可以使用
        map.put("bbb","222");//再次添加，同样报错

    }
}

资料参考

黑马程序员的不可变集合讲解
以上便是本人对于不可变集合的总结，这是本人的第一篇博客，如果有不足之处还希望各位大佬多多指导！！！