guava中ImmutableList使用示例详解

ImmutableList是一个不可变、线程安全的列表集合，它只会获取传入对象的一个副本，而不会影响到原来的变量或者对象，如下代码：

        int a = 23;
        ImmutableList<Integer> list = ImmutableList.of(a, 12);
        System.out.println(list);
        a = 232;
        System.out.println(list);

输出结果：

[23, 12]
[23, 12]

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));
     }
   }

使用的具体示例：

        //使用内部类的方式
        ImmutableList<Integer> list = ImmutableList .<Integer>builder()
                                                        .add(12)
                                                        .add(23)
                                                        .add(34)
                                                        .build();

• 静态方法
  静态方法提供了多个参数的of静态方法

        //获取一个空的不可变集合对象
        ImmutableList<String> list1 = ImmutableList .<String>of();
        //获取一个有一个元素的不可变集合对象
        ImmutableList<String> list2 = ImmutableList .<String>of("12");
        //获取一个有两个元素的不可变集合对象
        ImmutableList<String> list3 = ImmutableList .<String>of("12","23");

• 复制数组中的元素到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);