集合的Java便利工厂方法

JDK 9 在基本 Collection 接口上添加了像of()这样的静态工厂方法，以创建不可修改的集合对象。这些与我们在 JDK 6、7、8 中创建的不可修改（不可变）集合相同。它允许您仅在一行中创建值的列表、集合和映射。 Java 9 并没有像它的前身那样给我们的编码方式带来那么多戏剧性的变化，但我们肯定会有一些奇特的特性。

下面-提及方式导致 创建不必要的对象。为了克服这个问题， Java 9 引入了静态工厂方法来创建一个不可变的列表、集合和映射，这将在后面讨论。在它之前，让我们修改在 JDK 9（JDK 7、8）之前创建不可修改的集合。

JDK 8 中的列表

List listOfString = new ArrayList<>();
listOfString.add("Geeks");
listOfString.add("Java");
listOfString.add("Kotlin");
listOfString.add("Groovy");
listOfString.add("Scala");
listOfString = Collections.unmodifiableList(listOfString);

方式一：使用双大括号初始化

List listOfString = Collections.unmodifiableList(new ArrayList<>() {

    {

        add(“Geeks”);

        add(“Java”);

        add(“Kotlin”);

        add(“Groovy”);

        add(“Scala”);

    }

});

方式二：使用Arrays API将数组转换为ArrayList

List listOfString = Collections.unmodifiableList(Arrays.asList(“Geeks”,”Java”,”Kotlin”,”Groovy”, “Scala”));

方式 3：使用 Stream API

List listOfString = Collections.unmodifiableList(Stream.of(“Bruce”,”Steve”,”Adrian”, “Dave”, “Janick”,”Nicko”).collect(toList()));

为什么是Java 9？

现在让我们先看看为什么使用Java 9 静态工厂方法的好处，然后再开始使用它们

• 允许在一行中创建值的列表、集合和映射。
• 使用静态工厂方法创建不可变对象可以防止我们插入空值或重复项（在 Sets 或 Maps 中）。
• 我们在遍历集合元素时不会遇到 NullPointerExceptions。

现在让我们讨论在 JDK 中创建一个不可修改的集合。下面讨论列表、集合和映射。

1. Java 9中的列表

List listOfString = List.of("Geeks", "Java", "Kotlin", "Groovy", "Scala");

只需一行代码就足以创建一个不可修改的列表，因此不涉及创建不必要的对象。

• List.of()允许您创建一个空的不可变列表。
• 任何修改都会导致 UnsupportedOperationException。
• 从性能角度来看，可以使用多个List.of() 的重载版本。

不可变列表有一个抽象基类 AbstractImmutableList 和四个实现：

• 列表0
• 列表1
• 列表2
• 列表N

这些类型中的每一种都对应于用于创建它们的元素的数量。在Java.util.List 接口中，我们有 12 个静态工厂方法，它们使用上述实现来创建不可变对象：

// creates empty immutable list
static  List of()

// creates one-element immutable list
static  List of(E e1)

// creates two-element immutable list
static  List of(E e1, E e2)

// creates ten-element immutable list
static  List of(E e1, E e2, E e3, E e4, E e5, E e6, E e7, E e8, E e9, E e10)

// creates N-element immutable list
static  List of(E... elements)

也做偷偷抛出UnsupportedOperationException的方法如下

• add(E e), addAll(Collection c), addAll(int index, Collection c)
• remove(Object o), removeAll(Collection c), removeIf(Predicate filter)
• replaceAll(UnaryOperator运算符)
• 保留所有（集合<？> c）
• sort(Comparator c)
• 清除（）

插入 Null 值会导致 NullPointerException 如下所示

List listOfString = List.of("Geeks","Java","Kotlin", "Scala", "Groovy", null);
// throws NullPointerException

因此，不可变列表的有效创建如下：

List listOfString = List.of("Geeks","Java","Kotlin", "Scala", "Groovy","Pearl");

2.在Java 9中设置 

• Set.of()允许您创建一个空的不可变集。
• 任何修改都会导致UnsupportedOperationException。
• 从性能的角度来看，Set.of() 的几个重载版本是可用的。

插图：

不可变集合的实现与我们在 List 接口中看到的类似。它有一个抽象基类 AbstractImmutableSet 和四个实现：

• 设置0
• 设置1
• 设置2
• 设置N

这再次对应于创建时使用的元素数量。在Java.util.Set 接口中，我们有 12 个静态工厂方法：

// creates empty immutable set
static  Set of()

// creates one-element immutable set
static  Set of(E e1)

// creates two-element immutable set
static  Set of(E e1, E e2)

// creates ten-element immutable set
static  Set of(E e1, E e2, E e3, E e4, E e5, E e6, E e7, E e8, E e9, E e10)

// creates N-element immutable set
static  Set of(E... elements)

抛出 UnsupportedOperationException 的方法如下：

1. add(E e), addAll(Collection c)
2. remove(Object o), removeAll(Collection c), removeIf(Predicate filter)
3. 保留所有（集合<？> c）
4. 清除（）

插图：

与不可变列表一样，我们不能使用空值实例化 Set，因为它会抛出 NullPointerException，其中添加重复项将导致 IllegalArgumentException，如下所示：

Set setOfString = Set.of("Geeks", "Java", "Kotlin", "Scala", "Groovy", null);
// throws NullPointerException

Set setOfString = Set.of("Geeks", "Java", "Kotlin", "Java");
// throws IllegalArgumentException

因此，不可变集的有效创建如下：

Set setOfString = Set.of("Geeks", "Java", "Kotlin", "Scala", "Groovy", "Pearl");

3. Java 9 中的映射 

• Map.of()和Map.ofEntries()允许您创建一个不可变的地图。
• 任何修改都会导致UnsupportedOperationException。
• Map.of()被重载以创建最多 10 个键值对的映射。
• Map.ofEntries()将用于创建超过 10 个键值对的映射。

不可变映射具有抽象基类 AbstractImmutableMap，具有三个实现：

• 映射0
• 地图1
• 地图N

同样，我们在Java.util.Map接口中有以下一组工厂方法。

// creates an empty map
static  Map of()

// creates one-element map
static  Map of(K k1, V v1)

// creates two-element map
static  Map of(K k1, V v1, K k2, V v2)

// creates ten-element map
static  Map 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)

// creates N-element map
static  Map ofEntries(Entry... entries)

再次抛出 UnsupportedOperationException 的方法如下：

• 清除（）
• 计算（K键，BiFunction<？超级K，？超级V，？扩展V> rf）
• computeIfAbsent(K key, 函数 mf)
• computeIfPresent(K key, BiFunction rf)
• 合并（K键，V值，BiFunction<？超级V，？超级V，？扩展V> rf）
• put(K key, V value), putAll(Map m), putIfAbsent(K key, V value)
• 删除（对象键），删除（对象键，对象值）
• replace(K key, V value), replace(K key, V oldValue, V newValue), replaceAll(BiFunction f)

插图：

插入 Null 键或值将导致 NullPointerException ：

Map weightInKg = Map.of(null, 59, "John", 61);
// throws NullPointerExcepton because of null key

Map weightInKg = Map.of("Ron", null, "John", 61);
// throws NullPointerExcepton because of null value

Map weightInKg = Map.ofEntries(Map.entry("Ron", 59), null);
// throws NullPointerExcepton because of null entry

添加重复的关键元素将抛出 IllegalArgumentException：

Map weightInKg = Map.of("Ron", 59, "Ron", 59);

Map weightInKg = Map.ofEntries(Map.entry("Ron", 59), Map.entry("Ron", 59));

不可变映射的有效创建如下：

Map weightInKg = Map.of("Ron", 59, "John", 61, "Ed", 60, "Nick", 60, "Jack", 60L, "Ben", 65);

Map age = Map.ofEntries(Map.entry("Ron", 59),
                                      Map.entry("John", 61),
                                      Map.entry("Ed", 60),
                                      Map.entry("Nick", 60),
                                      Map.entry("Jack", 60),
                                      Map.entry("Ben", 65));