Tips
做一个终身学习的人。
在本章中,主要介绍以下内容:
接口的
- List
静态工厂方法创建不可变的 list。
- of()
接口的
- Set
静态工厂方法创建不可变的 set。
- of()
接口的
- Map
,
- of()
和
- ofEntries()
静态工厂方法创建不可变的 map。
- entry()
Collection API 由类和接口组成,提供了一种保存和操作不同类型的对象集合的方法,例如 list,set 和 map。 它在 Java SE 1.2 版本中添加进来。 Java 编程语言不支持 Collection Literals,这是一种简单易用的方式来声明和初始化集合。 Collection Literals 允许通过在紧凑形式的表达式中指定集合的元素来创建特定类型的集合。 Collection Literals 的一个示例是一个列表文字,能够创建一个列表,其中包含 100 和 200 的整数,如下所示:
- List < Integer > list = [100, 200];
Collection Literals 紧凑,使用简单。 由于在创建时已知元素的数量,因此可以实现高效的内存使用。 它可以设计成不可变的,使其线程安全。
在 Java 编程语言中包含 Collection Literals 语法在 JDK 9 之前被考虑过几次。 Java 设计师决定不将 Collection Literals 添加到 Java 语言中,至少不在 JDK 9 中。在这一点上将 Collection Literals 添加到 Java 将需要太多的努力来获得太少的收益。 他们决定通过在
,
- List
和
- Set
接口中添加静态工厂方法来更新 Collection API,从而可以轻松有效地创建小型的,不可变的集合来实现相同的目标。
- Map
现有的 Collection API 创建可变集合。 可以通过将可变集合包装在另一个对象中创建一个不可变的(或不可修改的)集合,该对象只是原始可变对象的包装器。 要在 JDK 8 或更早版本中创建两个整数的无法修改的列表,通常使用以下代码片段:
- // Create an empty, mutable list
- List < Integer > list = new ArrayList < >();
- // Add two elements to the mutable list
- list.add(100);
- list.add(200);
- // Create an immutable list by wrapping the mutable list
- List < Integer > list2 = Collections.unmodifiableList(list);
这种做法有严重的缺陷。 不可变的 list 只是可修改 list 的包装。 有意的是,将变量名为
。 不能使用
- list
变量修改列表。但是,仍然可以使用
- list2
变量来修改列表,并且在使用
- list
变量读取 list 时将会反映出修改。 下面包含一个完整的程序来创建一个不可变的 list,并显示如何在以后更改其内容。
- list2
- // PreJDK9UnmodifiableList.java
- package com.jdojo.collection;
- import java.util.ArrayList;
- import java.util.Collections;
- import java.util.List;
- public class PreJDK9UnmodifiableList {
- public static void main(String[] args) {
- List < Integer > list = new ArrayList < >();
- list.add(100);
- list.add(200);
- System.out.println("list = " + list);
- // Create an unmodifiable list
- List < Integer > list2 = Collections.unmodifiableList(list);
- System.out.println("list2 = " + list2);
- // Let us add an element using list
- list.add(300);
- // Print the contents of the list using both
- // variables named list and list2
- System.out.println("list = " + list);
- System.out.println("list2 = " + list2);
- }
- }
输出结果为:
- list = [100, 200] list2 = [100, 200] list = [100, 200, 300] list2 = [100, 200, 300]
输出显示,只要保留原始列表的引用,就可以更改其内容,并且不可变的 list 也不是真正不可变的! 解决此问题的方法是使用新的不可变 list 引用来覆盖原始引用变量,如下所示:
- List < Integer > list = new ArrayList < >();
- list.add(100);
- list.add(200);
- // Create an unmodifiable list and store it in list
- list = Collections.unmodifiableList(list);
注意,此示例使用多个语句来创建和填入不可变的 list。 如果需要在类中声明和初始化不可变的 list 作为实例或静态变量,则该方法不起作用,因为它涉及多个语句。 这样一个声明需要简单,紧凑,并且包含在一个声明中。 如果在类中使用以前的代码来实例变量,那么代码将类似于以下代码:
- public class Test {
- private List < Integer > list = new ArrayList < >(); {
- list.add(100);
- list.add(200);
- list = Collections.unmodifiableList(list);
- }
- // ...
- }
还有其他方式来声明和初始化一个不可变的 list,例如使用数组并将其转换为 list。 其中三种方式如下:
- public class Test {
- // Using an array and converting it to a list
- private List < Integer > list2 = Collections.unmodifiableList(new ArrayList < >(Arrays.asList(100, 200)));
- // Using an anonymous class
- private List < Integer > list3 = Collections.unmodifiableList(new ArrayList < >() {
- {
- add(100);
- add(200);
- }
- });
- // Using a stream
- private List < Integer > list4 = Collections.unmodifiableList(Stream.of(100, 200).collect(Collectors.toList()));
- // More code goes here
- }
此示例证明可以在一个语句中具有不可变的 list。 但是,语法是冗长的。 再是效率低下。 例如,只要在 list 中保存两个整数,则需要创建具有后备数组对象的多个对象来保存这些值。
JDK 9 通过向
,
- List
和
- Set
接口提供静态工厂方法来解决这些问题。 该方法命名为
- Map
并且被重载。 在 JDK 9 中,可以声明和初始化两个元素的不可变列表,如下所示:
- of()
- // Create an unmodifiable list of two integers
- List < Integer > list = List.of(100, 200);
JDK 9 将
静态工厂方法重载到
- of()
接口。 它提供了一种简单而紧凑的方式来创建不可变的 list。 以下是
- List
方法的所有版本:
- of()
- static < E > List < E > of() static < E > List < E > of(E e1) static < E > List < E > of(E e1, E e2) static < E > List < E > of(E e1, E e2, E e3) static < E > List < E > of(E e1, E e2, E e3, E e4) static < E > List < E > of(E e1, E e2, E e3, E e4, E e5) static < E > List < E > of(E e1, E e2, E e3, E e4, E e5, E e6) static < E > List < E > of(E e1, E e2, E e3, E e4, E e5, E e6, E e7) static < E > List < E > of(E e1, E e2, E e3, E e4, E e5, E e6, E e7, E e8) static < E > List < E > of(E e1, E e2, E e3, E e4, E e5, E e6, E e7, E e8, E e9) static < E > List < E > of(E e1, E e2, E e3, E e4, E e5, E e6, E e7, E e8, E e9, E e10) static < E > List < E > of(E...elements)
方法有 11 个特定版本来创建零到十个元素的 list。 另一个版本采用可变参数来允许创建任何数量的元素的不可变的 list。 你可能会想知道当使用可变参数的版本可以创建具有任意数量的元素的列表时,为什么有这么多版本的方法。 它们存在为性能原因。 API 设计人员希望能够有效地使用少量元素的列表。 使用数组实现可变参数。 存在具有非可变参数的方法,以避免将参数装入数组中,这使得它们更有效率。 这些方法使用
- of()
接口的特殊实现类用于较小的 list。
- List
方法返回的 list 具有以下特征:
- of()
异常。
- UnsupportedOperationException
异常。
- NullPointerException
方法中指定的,与
- of()
方法的可变参数版本中使用的数组相同。
- of(E… elements)
或任何其他实现
- ArrayList
接口的类。 这些方法的实现是内部的,不应该假定他们的类名。 例如,
- List
和
- List.of()
可能会返回两个不同类的对象。
- List.of("A")
类包含一个
- Collections
的静态属性,表示不可变的空 list。 它还包含一个
- EMPTY_LIST
的静态方法来获取不可变的空 list。
- emptyList()
方法返回具有指定元素的不可变单例 list。 以下代码片段显示了 JDK 9 和 JDK 9 之前创建不可变的空和单例 list 的方式。
- singletonList(T object)
- // Creating an empty, immutable List before JDK 9
- List < Integer > emptyList1 = Collections.EMPTY_LIST;
- List < Integer > emptyList2 = Collections.emptyList();
- // Creating an empty list in JDK 9
- List < Integer > emptyList = List.of();
- // Creating a singleton, immutable List before JDK 9
- List < Integer > singletonList1 = Collections.singletonList(100);
- // Creating a singleton, immutable List in JDK 9
- List < Integer > singletonList = List.of(100);
如何使用
方法从数组中创建一个不可变的 list? 答案取决于你想要从数组的列表。 可能需要一个 list,其元素与数组的元素相同,或者可能希望使用数组本身作为列表中唯一元素的 list。 使用
- of()
将调用
- List.of(array)
方法,返回的列表将其元素与数组中的元素相同。 如您希望数组本身是 list 中的唯一元素,则需要使用
- of(E... elements)
方法,这将调用
- List.<array-type>of(array)
方法,返回的列表将具有一个 元素,它是数组本身。 以下代码使用
- of(E e1)
数组来演示:
- Integer
- Integer[] nums = {
- 100,
- 200
- };
- // Create a list whose elements are the same as the elements
- // in the array
- List < Integer > list1 = List.of(nums);
- System.out.println("list1 = " + list1);
- System.out.println("list1.size() = " + list1.size());
- // Create a list whose sole element is the array itself
- List < Integer[] > list2 = List. < Integer[] > of(nums);
- System.out.println("list2 = " + list2);
- System.out.println("list2.size() = " + list2.size());
输出结果为:
- list1 = [100, 200] list1.size() = 2 list2 = [[Ljava.lang.Integer;@27efef64] list2.size() = 1
下面包含一个完整的程序,显示如何使用
接口的
- List
静态工厂方法来创建不可变的 list。
- of()
- // ListTest.java
- package com.jdojo.collection;
- import java.util.List;
- public class ListTest {
- public static void main(String[] args) {
- // Create few unmodifiable lists
- List < Integer > emptyList = List.of();
- List < Integer > luckyNumber = List.of(19);
- List < String > vowels = List.of("A", "E", "I", "O", "U");
- System.out.println("emptyList = " + emptyList);
- System.out.println("singletonList = " + luckyNumber);
- System.out.println("vowels = " + vowels);
- try {
- // Try using a null element
- List < Integer > list = List.of(1, 2, null, 3);
- } catch(NullPointerException e) {
- System.out.println("Nulls not allowed in List.of().");
- }
- try {
- // Try adding an element
- luckyNumber.add(8);
- } catch(UnsupportedOperationException e) {
- System.out.println("Cannot add an element.");
- }
- try {
- // Try removing an element
- luckyNumber.remove(0);
- } catch(UnsupportedOperationException e) {
- System.out.println("Cannot remove an element.");
- }
- }
- }
输出结果为:
- emptyList = [] singletonList = [19] vowels = [A, E, I, O, U] Nulls not allowed in List.of().Cannot add an element.Cannot remove an element.
JDK 9 在
接口中添加了
- Set
静态工厂方法的重载。 它提供了一种简单而紧凑的方式来创建不可变的 set。 以下是
- of()
方法的所有版本:
- of()
- static < E > Set < E > of() static < E > Set < E > of(E e1) static < E > Set < E > of(E e1, E e2) static < E > Set < E > of(E e1, E e2, E e3) static < E > Set < E > of(E e1, E e2, E e3, E e4) static < E > Set < E > of(E e1, E e2, E e3, E e4, E e5) static < E > Set < E > of(E e1, E e2, E e3, E e4, E e5, E e6) static < E > Set < E > of(E e1, E e2, E e3, E e4, E e5, E e6, E e7) static < E > Set < E > of(E e1, E e2, E e3, E e4, E e5, E e6, E e7, E e8) static < E > Set < E > of(E e1, E e2, E e3, E e4, E e5, E e6, E e7, E e8, E e9) static < E > Set < E > of(E e1, E e2, E e3, E e4, E e5, E e6, E e7, E e8, E e9, E e10) static < E > Set < E > of(E...elements)
方法的所有版本为性能都做了调整。 可以使用前 11 个版本来创建一个不可变的零到十个元素的 set。
- of()
方法的前 11 个版本与可变参数的版本一起存在的原因是为了避免将参数装入数组中,最多可设置 10 个元素。 可变参数的版本可用于创建一个包含任意数量元素的不可变 set。
- of
方法返回的 set 具有以下特征:
- of()
异常。
- UnsupportedOperationException
异常。
- NullPointerException
。
- IllegalArgumentException
或任何其他实现
- HashSet
接口的类。 这些方法的实现是内部的,不应该假定他们的类名。 例如,
- Set
和
- Set.of()
可能返回两个不同类的对象。
- Set.of("A")
类包含一个
- Collections
的静态属性,表示不可变的空 set。 它还包含
- EMPTY_SET
的静态方法来获取不可变的空 set。 它的
- emptySet()
方法返回具有指定元素的不可变单例 set。 以下代码片段显示了 JDK 9 和 JDK 9 之前创建不可变的空和单例 set 的方法:
- singleton(T object)
- // Creating an empty, immutable Set before JDK 9
- Set < Integer > emptySet1 = Collections.EMPTY_SET;
- Set < Integer > emptySet2 = Collections.emptySet();
- // Creating an empty Set in JDK 9
- Set < Integer > emptySet = Set.of();
- // Creating a singleton, immutable Set before JDK 9
- Set < Integer > singletonSet1 = Collections.singleton(100);
- // Creating a singleton, immutable Set in JDK 9
- Set < Integer > singletonSet = Set.of(100);
以下代码显示了如何从数组中创建一个不可变的 set。 可以有一个 set 的元素与数组的元素相同,或者可以使用集合作为唯一元素的集合。 注意,当使用数组元素作为集合的元素时,该数组不能具有重复的元素。 否则,
方法将抛出
- Set.of()
异常。
- IllegalArgumentException
- Integer[] nums = {
- 100,
- 200
- };
- // Create a set whose elements are the same as the
- // elements of the array
- Set < Integer > set1 = Set.of(nums);
- System.out.println("set1 = " + set1);
- System.out.println("set1.size() = " + set1.size());
- // Create a set whose sole element is the array itself
- Set < Integer[] > set2 = Set. < Integer[] > of(nums);
- System.out.println("set2 = " + set2);
- System.out.println("set2.size() = " + set2.size());
- // Create an array with duplicate elements
- Integer[] nums2 = {
- 101,
- 201,
- 101
- };
- // Try creating a set with the array as its sole element
- Set < Integer[] > set3 = Set. < Integer[] > of(nums2);
- System.out.println("set3 = " + set3);
- System.out.println("set3.size() = " + set3.size());
- try {
- // Try creating a set whose elements are the elements of
- // the array. It will throw an IllegalArgumentException.
- Set < Integer > set4 = Set.of(nums2);
- System.out.println("set4 = " + set4);
- } catch(IllegalArgumentException e) {
- System.out.println(e.getMessage());
- }
输出结果为:
- set1 = [100, 200] set1.size() = 2 set2 = [[Ljava.lang.Integer;@47c62251] set2.size() = 1 set3 = [[Ljava.lang.Integer;@3e6fa38a] set3.size() = 1 duplicate element: 101
下面包含一个完整的程序,显示如何使用
接口的
- Set
静态工厂方法来创建不可变的 set。 注意程序中包含元音元素的 set 的输出。 组合的元素可能不会以创建 set 时指定的相同顺序输出,因为 set 不保证其元素的顺序。
- of()
- // SetTest.java
- package com.jdojo.collection;
- import java.util.Set;
- public class SetTest {
- public static void main(String[] args) {
- // Create few unmodifiable sets
- Set < Integer > emptySet = Set.of();
- Set < Integer > luckyNumber = Set.of(19);
- Set < String > vowels = Set.of("A", "E", "I", "O", "U");
- System.out.println("emptySet = " + emptySet);
- System.out.println("singletonSet = " + luckyNumber);
- System.out.println("vowels = " + vowels);
- try {
- // Try using a null element
- Set < Integer > set = Set.of(1, 2, null, 3);
- } catch(NullPointerException e) {
- System.out.println("Nulls not allowed in Set.of().");
- }
- try {
- // Try using duplicate elements
- Set < Integer > set = Set.of(1, 2, 3, 2);
- } catch(IllegalArgumentException e) {
- System.out.println(e.getMessage());
- }
- try {
- // Try adding an element
- luckyNumber.add(8);
- } catch(UnsupportedOperationException e) {
- System.out.println("Cannot add an element.");
- }
- try {
- // Try removing an element
- luckyNumber.remove(0);
- } catch(UnsupportedOperationException e) {
- System.out.println("Cannot remove an element.");
- }
- }
- }
以下是输出结果:
- emptySet = [] singletonSet = [19] vowels = [E, O, A, U, I] Nulls not allowed in Set.of().duplicate element: 2 Cannot add an element.Cannot remove an element.
JDK 9 将
静态工厂方法重载添到 Map 接口中。 它提供了一种简单而紧凑的方式来创建不可变的 map。 方法的实现为性能做了调整。 以下是
- of()
方法的 11 个版本,可以创建一个不可变的零到十个键值条目的 map:
- of()
- static < K,
- V > Map < K,
- V > of() static < K,
- V > Map < K,
- V > of(K k1, V v1) static < K,
- V > Map < K,
- V > of(K k1, V v1, K k2, V v2) static < K,
- V > Map < K,
- V > of(K k1, V v1, K k2, V v2, K k3, V v3) static < K,
- V > Map < K,
- V > of(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4) 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) 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) 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) 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) 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) 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)
注意在
方法中的参数的位置。 第一个和第二个参数分别是 map 中第一个键值对的键和值;第三个和第四个参数分别是 map 中第二个键值对的键和值。 注意,在 Map 中,没有像在
- of()
和
- List
中可变参数的
- Set
方法。 这是因为
- of()
条目包含两个值(键值和值),并且 Java 中的方法中只能有一个可变参数。 以下代码片段显示了如何使用
- Map
方法创建 map:
- of()
- // An empty, unmodifiable Map
- Map < Integer,
- String > emptyMap = Map.of();
- // A singleton, unmodifiable Map
- Map < Integer,
- String > singletonMap = Map.of(1, "One");
- // A unmodifiable Map with two entries
- Map < Integer,
- String > luckyNumbers = Map.of(1, "One", 2, "Two");
要创建具有任意数量条目的不可修改的
,JDK 9 在
- Map
接口中提供了一个
- Map
的静态方法,它的签名如下:
- ofEntries()
- <K,V>
- Map
- <K,V>
- ofEntries(Map.Entry
- <? extends K,? extends V>
- ... entries)
要使用
方法,需要在
- ofEntries()
实例中包含每个 map 键值对。 JDK 9 在
- Map.Entry
接口中提供了一个方便的
- Map
静态方法来创建
- entry()
的实例。
- Map.Entry
方法的签名如下:
- entry()
- <K,V>
- Map.Entry
- <K,V>
- entry(K k, V v)
为了保持表达式的可读性和紧凑性,需要为
方法使用静态导入,并使用如下所示的语句来创建一个具有任意数量条目的不可修改的 map:
- Map.entry
- import java.util.Map;
- import static java.util.Map.entry;
- // ...
- // Use the Map.ofEntries() and Map.entry() methods to
- // create an unmodifiable Map
- Map < Integer,
- String > numberToWord = Map.ofEntries(entry(1, "One"), entry(2, "Two"), entry(3, "Three"));
接口的
- Map
和
- of()
方法返回的 map 具有以下特征:
- ofEntries()
异常。
- UnsupportedOperationException
异常。
- NullPointerException
异常。
- IllegalArgumentException
的实现类不能保证。 也就是说,不要指望返回的对象是
- Map
或实现
- HashMap
接口的任何其他类。 这些方法的实现是内部的,不应该假定他们的类名。 例如,
- Map
和
- Map.of()
可能会返回两个不同类的对象。
- Map.of(1, "One")
类包含
- Collections
的静态字段,表示不可变的空 map。 它还包含一个
- EMPTY_MAP
的静态方法来获取不可变的空 map。
- emptyMap()
方法返回具有指定键和值的不可变的单例 map。 以下代段显示了 JDK 9 和 JDK 9 之前创建不可变空 map 和单例 map 的方式:
- singletonMap(K key, V value)
- // Creating an empty, immutable Map before JDK 9
- Map < Integer,
- String > emptyMap1 = Collections.EMPTY_MAP;
- Map < Integer,
- String > emptyMap2 = Collections.emptyMap();
- // Creating an empty Map in JDK 9
- Map < Integer,
- String > emptyMap = Map.of();
- // Creating a singleton, immutable Map before JDK 9
- Map < Integer,
- String > singletonMap1 = Collections.singletonMap(1, "One");
- // Creating a singleton, immutable Map in JDK 9
- Map < Integer,
- String > singletonMap = Map.of(1, "One");
下面包含一个完整的程序,显示如何使用
接口的
- Map
,
- of()
和
- ofEntries()
静态方法来创建不可变的 map。 请注意 map 中指定日期的顺序以及输出中显示的顺序。 它们可能不匹配,因为 map 更像 set,不能保证其条目的检索顺序。
- entry()
- // MapTest.java
- package com.jdojo.collection;
- import java.util.Map;
- import static java.util.Map.entry;
- public class MapTest {
- public static void main(String[] args) {
- // Create few unmodifiable maps
- Map < Integer,
- String > emptyMap = Map.of();
- Map < Integer,
- String > luckyNumber = Map.of(19, "Nineteen");
- Map < Integer,
- String > numberToWord = Map.of(1, "One", 2, "Two", 3, "Three");
- Map < String,
- String > days = Map.ofEntries(entry("Mon", "Monday"), entry("Tue", "Tuesday"), entry("Wed", "Wednesday"), entry("Thu", "Thursday"), entry("Fri", "Friday"), entry("Sat", "Saturday"), entry("Sun", "Sunday"));
- System.out.println("emptyMap = " + emptyMap);
- System.out.println("singletonMap = " + luckyNumber);
- System.out.println("numberToWord = " + numberToWord);
- System.out.println("days = " + days);
- try {
- // Try using a null value
- Map < Integer,
- String > map = Map.of(1, null);
- } catch(NullPointerException e) {
- System.out.println("Nulls not allowed in Map.of().");
- }
- try {
- // Try using duplicate keys
- Map < Integer,
- String > map = Map.of(1, "One", 1, "On");
- } catch(IllegalArgumentException e) {
- System.out.println(e.getMessage());
- }
- try {
- // Try adding an entry
- luckyNumber.put(8, "Eight");
- } catch(UnsupportedOperationException e) {
- System.out.println("Cannot add an entry.");
- }
- try {
- // Try removing an entry
- luckyNumber.remove(0);
- } catch(UnsupportedOperationException e) {
- System.out.println("Cannot remove an entry.");
- }
- }
- }
输出结果为:
- emptyMap = {}
- singletonMap = {
- 19 = Nineteen
- }
- numberToWord = {
- 1 = One,
- 3 = Three,
- 2 = Two
- }
- days = {
- Sat = Saturday,
- Tue = Tuesday,
- Thu = Thursday,
- Sun = Sunday,
- Wed = Wednesday,
- Fri = Friday,
- Mon = Monday
- }
- Nulls not allowed in Map.of().duplicate key: 1 Cannot add an entry.Cannot remove an entry.
在 Java 语言中支持 collection literals 是非常需要的功能。 JDK 9 替代了对 collection literals 的支持,更新了 Collection API,而是在
,
- List
和
- Set
接口中添加了
- Map
静态工厂方法,分别返回一个不可变的
- of()
,
- List
和
- Set
。该方法被重载,指定集合的零到十个元素。
- Map
和
- List
接口提供了可变参数的
- Set
方法,用于创建一个包含任意数量的元素的
- of()
和
- List
。
- Set
接口提供了
- Map
静态工厂方法,用于创建一个不可变的任意数量条目的
- ofEntries()
。
- Map
接口还包含一个静态的
- Map
方法,它接受一个键和一个值作为参数并返回一个
- entry()
实例。
- Map.Entry
和
- ofEntries()
方法一起使用来创建任意数量条目的不可变的
- entry()
。
- Map
这些接口中的新的静态工厂方法为性能做了调整。
和
- List.of()
方法不允许使用 null 元素。
- Set.of()
方法不允许重复的元素。
- Set.of()
和
- Map.of()
方法不允许重复键,或者将 null 作为键或值。
- Map.ofEntries()
来源: http://www.cnblogs.com/IcanFixIt/p/7217042.html