Java9中集合工廠方法的示例分析

這篇文章給大家分享的是有關Java9中集合工廠方法的示例分析的內容。小編覺得挺實用的，因此分享給大家做個參考，一起跟隨小編過來看看吧。

使集合框架更便捷的工廠方法

JEP269中提議，為集合框架增添一些工廠方法，來使創建不可變集合類與含有少量元素的Map變得更加便捷。下文就為什么它們應運而生來展開詳細的闡述。

集合框架增加工廠方法是必然的結果

Java飽受其語法臃腫的批評，比如，創建一個小而確定的集合類時(比如一個List)，需要使用它的構造方法，然后將它的引用存放在局部變量中，通過引用來多次調用add()方法之后， 最后才來封裝這個集合以獲得不可變的視圖。

早先的使用過程如下

List<String> list = new ArrayList<>();
list.add("a");
list.add("b");
list.add("c");
list = Collections.unmodifiableList(list);

上面這個語法如此臃腫的例子在先前的版本中并不能夠簡化，不可變的靜態集合必須在靜態初始塊中來填充，而不是使用更加方便的字段表達式。但是，

也不得不提一下下面這些單語句表達式

List<String> list1 = 
   Collections.unmodifiableList(new ArrayList<>(Arrays.asList("a", "b", "c")));

List<String> list2 = 
   Collections.unmodifiableList(new ArrayList<String>() {{ add("a"); add("b"); add("c"); }});

List<String> list3 = 
   Collections.unmodifiableList(Stream.of("a", "b", "c").collect(toList()));

• 第一種方式比較扯淡，你走遍千山，你跨過弱水，只為取一瓜瓢飲，是的，你沒有看錯，你費盡千辛萬苦只為了生成一個包含a，b，c三個元素的List，并且你要構建一個ArrayList還要仰仗Arrays.asList(“a”, “b”, “c”)這個烏七八黑的方式，它不好用不說，關鍵是它在短短的生命周期之后還要被GC，過程還是不可見的。。。

• 第二種好像看上去沒那么扯淡，使用一個匿名內部類的實例初始化構造器來減少代碼臃腫度，看上去很完美，但是可能會發生內存泄漏或者序列化的問題，因為它每次使用都會耗費額外的資源，還包含對封閉實例和任何捕獲對象的隱藏引用。

• 第三種方式是使用Java8的Streams API來完成的，雖然代碼沒那么臃腫，但是過程中也涉及到了不必要的對象創建。此外，Streams API不能用來構建Map， 除非值是經鍵計算而來或者stream的元素包含鍵值對。

為解決這些問題，JEP186提議了集合字面量的概念，集合字面量是一種句法表達式，采用一種類數組的方式，來創建List、Map或者其它的集合類

下面是其原始類型的簡明表達方式

List<String> list = #[ "a", "b", "c" ];

沒有任何新的語言特性，一切就像我們所思所想那樣簡明，但是這種集合字面量為什么沒有被整合到Java9中去呢？取而代之的是，Java9采用了工廠方法來替代它，這其實是為了使語言改動盡量最小化，采用現有的方式，生產語法糖來達到這個目的的。

如此，集合工廠方法應運而生了。

一起來看看集合工廠方法

JEP 269的工廠方法受到類java.util.Collection和java.util.EnumSet類中的類似工廠方法的啟發。 Collection提供用于創建空List，java.util.Set和Map的工廠方法，以及創建具有一個元素或鍵值對的單例List，Set和Map。 EnumSet提供了幾個重載的of(…)工廠方法，它們采用固定或可變數量的參數，是為了更方便地創建指定元素的EnumSet。Java 9中的EnumSet模型的of()方法提供一致和通用的方式來創建包含任意類型對象的List，Set和Map。

以下工廠方法已添加到List接口中

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)

以下工廠方法已添加到Set接口中

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)

在每個方法列表中， 第一個方法創建一個空的不可修改的集合。接下來的10個方法可創建1-10個元素的不可修改集合。盡管這些方法比較混亂，但它們避免了final類型的可變參方法產生的數組分配，初始化和垃圾回收開銷，這種方法還支持任意大小的集合。

以下是List和Set的示例

import java.util.List;
import java.util.Set;
public class ColDemo
{
   public static void main(String[] args)
   {
      List<String> fruits = List.of("apple", "orange", "banana");
      for (String fruit: fruits)
         System.out.println(fruit);
      try
      {
         fruits.add("pear");
      }
      catch (UnsupportedOperationException uoe)
      {
         System.err.println("unable to modify fruits list");
      }

      Set<String> marbles = Set.of("aggie", "alley", "steely");
      for (String marble: marbles)
         System.out.println(marble);
      try
      {
         marbles.add("swirly");
      }
      catch (UnsupportedOperationException uoe)
      {
         System.err.println("unable to modify marbles set");
      }
   }
}

運行后輸出：

apple
orange
banana
unable to modify fruits list
steely
alley
aggie
unable to modify marbles set

以下工廠方法則添加到Map接口中

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)
static <K,V> Map<K,V> 
   ofEntries(Map.Entry<? extends K,? extends V>... entries)

第一個方法創建了一個空的不可變的Map，接下來10個方法創建包含1-10和鍵值對的Map，盡管這些方法比較混亂，但它們避免了final類型的可變參方法產生的數組分配，初始化和垃圾回收開銷，且支持任意大小的Map。

雖然Map的可變參數方法近似List和Set的，但是它的每個鍵值對必須被包裝起來，下面這個方法可以方便地將包裝鍵值對轉換為Map標準鍵值對：

Map.Entry<K,V> entry(K k, V v)

下面是Map的ofEntries() 和entry()方法的示例

import java.util.Map;
import static java.util.Map.entry;
public class MapDemo
{
   public static void main(String[] args)
   {
      Map<String, String> capCities = 
         Map.ofEntries(entry("Manitoba", "Winnipeg"), 
                       entry("Alberta", "Edmonton"));
      capCities.forEach((k, v) -> 
                        System.out.printf("Key = %s, Value = %s%n", k, v));
      try
      {
         capCities.put("British Columbia", "Victoria");
      }
      catch (UnsupportedOperationException uoe)
      {
         System.err.println("unable to modify capCities map");
      }
   }
}

運行后輸出：

Key = Alberta, Value = Edmonton
Key = Manitoba, Value = Winnipeg
unable to modify capCities map

注意，未來的JDK版本可能會讓開發者指定值類型來減少包裝鍵值對所帶來的性能開銷，從entry(）方法可以看出，通過它返回一個新的實現自Map.Entry的具體引用類型，我想這是為了后面把潛在特性遷移到值類型中去設下的鋪墊吧。

感謝各位的閱讀！關于“Java9中集合工廠方法的示例分析”這篇文章就分享到這里了，希望以上內容可以對大家有一定的幫助，讓大家可以學到更多知識，如果覺得文章不錯，可以把它分享出去讓更多的人看到吧！