Java 创建不可变聚集

        Java中为了安全起见，偶然间不想让别人改聚集中的数据，那么就可以使用不可变聚集。

2. package listExercise;
4. import java.util.HashMap;
5. import java.util.Map;
6. import java.util.Set;
8. /**
9. * 不可变集合
10. * 长度不变，内容无法修改的集合
11. * 当集合中的数据不能被修改，那么将其拷贝到不可变集合中就是一种很好的防御手段
12. * 有些情况，不想让他人改变集合的内容，那么就需要使用不可变集合；
13. */
14. public class ListExercise {
15.     public static void main(String[] args) {
16.         // 不可变的集合有不可变List、不可变Set、不可变Map
18.         // 不可变List
19.         // 使用List.of方法创建一个不可变的List集合
20. //        List<String> list= List.of("张三","李四","王五","赵六");
21. //        // 发现使用List.of方法创建的集合是不可变的集合，只能查询，无法修改
22. //        // 不可变的集合可以正常查询
23. //        for (String s : list) {
24. //            System.out.println(s);
25. //        }
26. //        // 但是想要改变这个集合是不可以的，无法通过编译
27. //        list.remove(0);
28. //        list.remove("张三");
29. //        list.add("前七");
31. //        // 不可变的Set集合
32. //        // 不可变的Set大部分情况下和不可变List类似，但是使用of方法创建集合的时候，参数必须保证唯一性
33. //        Set<String> set = Set.of("张三","李四","王五","赵六");
34. //        for (String s : set) {
35. //            System.out.println(s);
36. //        }
37. //        // 使用Set.of创建集合的时候，参数必须保证唯一性，否则直接编译错误
38. //        Set<Integer> errorSet = Set.of(1,2,3,4,5,5);
39. //        set.remove("王五");
40. //        set.add("13");
41. //        set.remove("李四");
43.         // 不可变的Map集合
44.         // 如果使用Map.of方法，参数的键值对个数最多10个，其不支持不定参数的写法：
45.         // 因为不定参数只能有一个，并且必须写在参数列表的最后；但是Map中键值对一一对应，必须有两个不定参数，这是不符合语法的
46.         // 假如说想要传递多个键值对对象，数量大于10个，那么不能使用Map.of方法
49.         // Map.of方法不能传递相同的键，否则直接编译报错
50. //        Map<String, String> map = Map.of("张三", "南京", "张三", "北京", "王五", "上海",
51. //                "赵六", "广州", "孙七", "深圳", "周八", "杭州",
52. //                "吴九", "宁波", "郑十", "苏州", "刘一", "无锡",
53. //                "陈二", "嘉兴");
56. //        put方法可以传递相同的键，以后面的键值为准
57. //        Map<String, String> map1 = new HashMap<>();
58. //        map1.put("zhangsan", "123");
59. //        map1.put("zhangsan", "123");
61.         // 创建一个不可变的Map对象，键值对的数量不超过10
62. //        Map<String, String> map = Map.of("张三", "南京", "王五", "上海",
63. //                "赵六", "广州", "孙七", "深圳", "周八", "杭州",
64. //                "吴九", "宁波", "郑十", "苏州", "刘一", "无锡",
65. //                "陈二", "嘉兴");
66. //
67. //        // 通过得到keySet，然后遍历key得到value
68. //        Set<String> keySet = map.keySet();
69. //        for (String key : keySet) {
70. //            String value = map.get(key);
71. //            System.out.println(value + " " + key);
72. //        }
73. //
74. //        // 通过获得键值对集合，直接遍历
75. //        Set<Map.Entry<String, String>> entries = map.entrySet();
76. //        for (Map.Entry<String, String> entry : entries) {
77. //            System.out.println(entry.getKey() + " " + entry.getValue());
78. //        }
79. //
80. //        // 修改map失败
81. //        map.remove("张三");
82. //        map.put("123", "456");
84.         // 创建一个不可变的Map对象，但是键值对超过10
86.         // 创建一个普通的map对象
87.         HashMap<String, String> map = new HashMap<>();
88.         map.put("张三", "南京");
89.         map.put("李四", "北京");
90.         map.put("王五", "上海");
91.         map.put("赵六", "北京");
92.         map.put("孙七", "深圳");
93.         map.put("周八", "杭州");
94.         map.put("吴九", "宁波");
95.         map.put("郑十", "苏州");
96.         map.put("刘一", "无锡");
97.         map.put("陈二", "嘉兴");
98.         map.put("aaa", "111");
100. //        // 利用上面的map对象创建一个不可变的map
101. //        // 获取所有键值对对象
102. //        Set<Map.Entry<String, String>> entries = map.entrySet();
103. //        // 将entries变为数组
104. //        // 先创建一个数组，用于存储键值对
105. //        // 此处的数组大小可以随意，后面toArray会自己调整
106. //        Map.Entry[] array = new Map.Entry[0];
107. //        // toArray方法在底层会比较集合的长度跟数组的长度两者的大小
108. //        // 如果集合的长度 > 数组的长度 ：数据在数组中放不下，此时会根据实际数据的个数，重新创建数组
109. //        // 如果集合的长度 <= 数组的长度：数据在数组中放的下，此时不会创建新的数组，而是直接用
110. //        // 成功将原hashMap中的键值对转化为了数组
111. //        Map.Entry[] mapArray = entries.toArray(array);
112. //        // 用这个键值对数组创建不可变的map
113. //        Map map1 = Map.ofEntries(mapArray);
114. //        // 不可变的map，修改直接报错
115. //        map1.put("1230", "4567");
116. //
117. //        // 简便方法，在JDK10之前，需要将普通Map的键值对，转化为entries集合对象；再创建一个Map.Entry类型的数组
118. //        // 再通过这个数组（作为模板），将entries对象转换为Map.Entry类型的数组，然后再用这个数组，作为Map.ofEntries方法的参数，创造不可变的map
119. //
120. //        // JDK10之后的简便方法
121. //        // copyOf底层实现也是用的上面的方法，只是JDK对其进行了封装
122. //        Map<String, String> easyMap = Map.copyOf(map);
123. //        easyMap.put("132", "123");
125.         // 获取Map中的键值对集合
126.         Set<Map.Entry<String, String>> entries = map.entrySet();
127.         // 创建一个Map.Entry类型的数组，用于调用entries中toArray方法时指定数组类型
128.         Map.Entry[] entryArray = new Map.Entry[0];
129.         // 将Map中的键值存到Map.Entry数组中
130.         Map.Entry[] array = entries.toArray(entryArray);
131.         // 使用Map中的ofEntries方法使用原Map中的entry数组创建一个不可变的Map
132.         Map map2 = Map.ofEntries(array);
133.         System.out.println(map2);
135.         // JDK10之后的简便转换方法
136.         Map<String, String> easyMap = Map.copyOf(map);
137.         System.out.println(easyMap);
138.     }
139. }

复制代码

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！qidao123.com:ToB企服之家，中国第一个企服评测及软件市场,开放入驻,技术点评得现金