newArrayListWithExpectedSize()和newArrayListWithCapacity()详细对比

package com.lxk.guavaTest;
 
import com.google.common.collect.Lists;
 
import java.util.List;
 
/**
 * Created by lxk on 2016/11/7
 */
public class ListsTest {
 
    public static void main(String[] args) {
        testLists();
    }
 
    /**
     * 测试 guava Lists
     */
    private static void testLists() {
 
        List<String> list1 = Lists.newArrayList();
        for (int i = 0; i < 10; i++) {
            list1.add(i + "");
        }
        System.out.println("list1: " + list1);
        List<String> list2 = Lists.newArrayList("1", "2", "3");
        System.out.println("list2: " + list2);
        List<String> list3 = Lists.newArrayList(new String[]{"22", "22"});
        System.out.println("list3: " + list3);
        List<String> list4 = Lists.newArrayList(list1);
        System.out.println("list4: " + list4);
 
        //下面的这个写法呢是在初始化list的时候，说明容器的扩容界限值
 
        //使用条件：你确定你的容器会装多少个，不确定就用一般形式的
 
        //说明：这个容器超过10个还是会自动扩容的。不用担心容量不够用。默认是分配一个容量为10的数组，不够将扩容
        //执行数组数据迁移操作：新建新数组，复制就数组数据到新数组（包括开辟新空间，copy数据等等，耗时，耗性能）
 
        //对下数字10的说明：若直接new一个list的话，默认大小是10的数组，下面的方式则是 5L + x + x/10 = 16L(x = 10)，在17的时候扩容
 
        //整个来说的优点有：节约内存，节约时间，节约性能。代码质量提高。
        List<String> list = Lists.newArrayListWithExpectedSize(10);
 
        //这个方法就是直接返回一个10的数组。
        List<String> list_ = Lists.newArrayListWithCapacity(10);
    }
}

下面先是关于Lists.newArrayListWithExpectedSize(10)的源码简单分析
  @GwtCompatible(serializable = true)
  public static <E> ArrayList<E> newArrayListWithExpectedSize(int estimatedSize) {
    return new ArrayList<E>(computeArrayListCapacity(estimatedSize));
  }
    
  static int computeArrayListCapacity(int arraySize) {
    checkNonnegative(arraySize, "arraySize");
 
    // TODO(kevinb): Figure out the right behavior, and document it
    return Ints.saturatedCast(5L + arraySize + (arraySize / 10));
  }
  static int checkNonnegative(int value, String name) {
    if (value < 0) {
      throw new IllegalArgumentException(name + " cannot be negative but was: " + value);
    }
    return value;
  }
  public static int saturatedCast(long value) {
    if (value > Integer.MAX_VALUE) {
      return Integer.MAX_VALUE;
    }
    if (value < Integer.MIN_VALUE) {
      return Integer.MIN_VALUE;
    }
    return (int) value;
  }    
  
    public ArrayList(int initialCapacity) {
        super();
        if (initialCapacity < 0)
            throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
        this.elementData = new Object[initialCapacity];
    }

然后是Lists.newArrayListWithCapacity(10)的源码简单分析
  @GwtCompatible(serializable = true)
  public static <E> ArrayList<E> newArrayListWithCapacity(int initialArraySize) {
    checkNonnegative(initialArraySize, "initialArraySize"); // for GWT.
    return new ArrayList<E>(initialArraySize);
  }

然后看上面的主要是ArrayList，然后就看看ArrayList源码里面的add方法以及如何扩容的。
    /**
     * list底层的用来保存数据的数组
     */
    private transient Object[] elementData;
    /**
     * Shared empty array instance used for empty instances.
     */
    private static final Object[] EMPTY_ELEMENTDATA = {};
    /**
     * Default initial capacity.
     */
    private static final int DEFAULT_CAPACITY = 10;
 
    public boolean add(E e) {
        ensureCapacityInternal(size + 1);  // Increments modCount!! (Increments 翻译-- 增量; 增长( increment的名词复数 ); 增额; 定期的加薪;)
        elementData[size++] = e;
        return true;
    }
    private void ensureCapacityInternal(int minCapacity) { // Internal 翻译--  内部的; 国内的; 体内的; 内心的;   Capacity  翻译--  容量; 性能; 才能; 生产能力;
        if (elementData == EMPTY_ELEMENTDATA) {
            minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
        }
 
        ensureExplicitCapacity(minCapacity);
    }
    
    private void ensureExplicitCapacity(int minCapacity) { //Explicit  翻译-- 明确的，清楚的; 直言的; 详述的; 不隐瞒的;
        modCount++;
 
        // overflow-conscious code
        if (minCapacity - elementData.length > 0) // 扩容条件，就是minCapacity = size + 1 大于当前数组的长度。就扩容。
            grow(minCapacity);
    }
    
    private void grow(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length;
        int newCapacity = oldCapacity + (oldCapacity >> 1); //新容量相当于是原来容量的1.5倍(old + old>>1右移一位即除以2)
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
        // minCapacity is usually close to size, so this is a win:
        elementData = Arrays.copyOf(elementData, newCapacity); // 复制旧数组数据到新数组
    }

关于 ArrayList 的modCount属性，java源码里面写的注释很长一大串，不是一时半会可以看的明白的。我就做个记录，翻译一下。
    /**
     * The number of times this list has been <i>structurally modified</i>.  这个list的结构已经被修改过的次数
     * Structural modifications are those that change the size of the        结构修改是那些改变list的size属性，
     * list, or otherwise perturb it in such a fashion that iterations in    或者其他方式如迭代进度可能会产生不正确的结果 
     * progress may yield incorrect results.
     *
     * <p>This field is used by the iterator and list iterator implementation  这个字段是由迭代器和列表迭代器实现的
     * returned by the {@code iterator} and {@code listIterator} methods.      代码迭代器listIterator方法返回的代码
     * If the value of this field changes unexpectedly, the iterator (or list  如果此字段的值意外更改，则迭代器(list迭代器)
     * iterator) will throw a {@code ConcurrentModificationException} in       将在响应迭代器的next方法，remove方法，previous(),set(),add()等方法
     * response to the {@code next}, {@code remove}, {@code previous},         抛出concurrentmodificationexception 异常
     * {@code set} or {@code add} operations.  This provides                   这提供了
     * <i>fail-fast</i> behavior, rather than non-deterministic behavior in    快速失败的行为，而不是在面对迭代过程中，并发修改的非确定性行为
     * the face of concurrent modification during iteration.
     *
     * <p><b>Use of this field by subclasses is optional.</b> If a subclass    子类们使用这个字段是可选的，如果一个子类
     * wishes to provide fail-fast iterators (and list iterators), then it     希望提供快速失败的迭代器(lsit迭代器),那么 它
     * merely has to increment this field in its {@code add(int, E)} and       仅仅需要增加这个字段在他的 add，remove，方法
     * {@code remove(int)} methods (and any other methods that it overrides    (或者其他任何修改了list结构的方法)
     * that result in structural modifications to the list).  A single call to  一个单一的调用
     * {@code add(int, E)} or {@code remove(int)} must add no more than         add()或者remove()方法，必须增加不超过
     * one to this field, or the iterators (and list iterators) will throw      1 的大小的值，给这个字段。否则，迭代器或者list迭代器将抛出
     * bogus {@code ConcurrentModificationExceptions}.  If an implementation    ConcurrentModificationExceptions 异常   如果一个实现
     * does not wish to provide fail-fast iterators, this field may be          不希望提供快速失败迭代器，这个字段可以忽视
     * ignored.                                              
     */