不可变集合的定义
不可变集合，顾名思义，就是不可以被修改的集合。一旦该集合创建完毕，其长度和内容均不能改变（不能增加或者减少元素），只能查找集合内的元素。
创建不可变集合的应用场景
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.<init>(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.<init>(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<Map.Entry<String, String>> 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");//再次添加，同样报错
}
}
资料参考
黑马程序员的不可变集合讲解
以上便是本人对于不可变集合的总结，这是本人的第一篇博客，如果有不足之处还希望各位大佬多多指导！！！
923
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
