ImmutableList是一個不可變、執行緒安全的列表集合，它只會獲取傳入物件的一個副本，而不會影響到原來的變數或者物件，如下程式碼：

        int a = 23;
        ImmutableList<Integer> list = ImmutableList.of(a, 12);
        System.out.println(list);
        a = 232;
        System.out.println(list);
1
2
3
4
5
輸出結果：

[23, 12]
[23, 12]
1
2
ImmutableList建立不可變物件有兩種方法，一種是使用靜態of方法，另外一種是使用靜態內部類Builder。

靜態內部類構建方法 
先看下原始碼，他是一個靜態內部類，使用static和final修飾符，來輔助外部類ImmutableList構建不可變的集合物件
  public static final class Builder<E>
     extends ImmutableCollection.Builder<E>
   {
     private Object[] contents;
     private int size;
     public Builder()
     {
       this(4);
     }
     Builder(int capacity)
     {
       this.contents = new Object[capacity];
       this.size = 0;
     }

     Builder<E> ensureCapacity(int minCapacity)
     {
       if (this.contents.length < minCapacity) {
         this.contents = ObjectArrays.arraysCopyOf(this.contents, expandedCapacity(this.contents.length, minCapacity));
       }

       return this;
     }
     public Builder<E> add(E element)
     {
       Preconditions.checkNotNull(element);
       ensureCapacity(this.size + 1);
       this.contents[(this.size++)] = element;
       return this;
     }

     public Builder<E> addAll(Iterable<? extends E> elements)
     {
       if ((elements instanceof Collection)) {
         Collection<?> collection = (Collection)elements;
         ensureCapacity(this.size + collection.size());
       }
       super.addAll(elements);
       return this;
     }
     public Builder<E> add(E... elements)
     {
       for (int i = 0; i < elements.length; i++) {
         ObjectArrays.checkElementNotNull(elements[i], i);
       }
       ensureCapacity(this.size + elements.length);
       System.arraycopy(elements, 0, this.contents, this.size, elements.length);
       this.size += elements.length;
       return this;
     }
     public Builder<E> addAll(Iterator<? extends E> elements)
     {
       super.addAll(elements);
       return this;
     }
     public ImmutableList<E> build()
     {
       switch (this.size) {
       case 0: 
         return ImmutableList.of();

       case 1: 
         E singleElement = this.contents[0];
         return ImmutableList.of(singleElement);
       }
       if (this.size == this.contents.length)
       {
         return new RegularImmutableList(this.contents);
       }
       return new RegularImmutableList(ObjectArrays.arraysCopyOf(this.contents, this.size));
     }
   }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
使用的具體示例：

        //使用內部類的方式
        ImmutableList<Integer> list = ImmutableList .<Integer>builder()
                                                        .add(12)
                                                        .add(23)
                                                        .add(34)
                                                        .build();
1
2
3
4
5
6
靜態方法 
靜態方法提供了多個引數的of靜態方法
        //獲取一個空的不可變集合物件
        ImmutableList<String> list1 = ImmutableList .<String>of();
        //獲取一個有一個元素的不可變集合物件
        ImmutableList<String> list2 = ImmutableList .<String>of("12");
        //獲取一個有兩個元素的不可變集合物件
        ImmutableList<String> list3 = ImmutableList .<String>of("12","23");
1
2
3
4
5
6
複製陣列中的元素到ImmutableList中
        List<String> list4 = new ArrayList<String>();
        list4.add("1");
        list4.add("2");
        list4.add("3");
        //copy陣列list4的一個副本
        List<String> list5 = ImmutableList .<String>copyOf(list4);
--------------------- 
作者：隨風yy 
來源：CSDN 
原文：https://blog.csdn.net/yaomingyang/article/details/80903780 
版權宣告：本文為博主原創文章，轉載請附上博文連結！