深入了解Java集合中的ArrayList

摘要：实现了接口，所以包含的基本方法新增，删除，插入等都实现了。线程安全问题在多线程情况下有线程进行修改时，是线程不安全的。线程安全性问题，取决于如何应用。反映的是当前数组中存了多少数据，而则反映的是内部数组的容量。

ArrayList 是一个可扩容数组Resizable-array,它实现了List接口的所有方法。

</>复制代码 
从对ArrayList的简单描述中我们可以得出几点
ArrayList 是数组，但不同于一般数组，可扩容，而一般数组容量固定。
ArrayList 实现了List接口，所以List包含的基本方法（新增，删除，插入等）ArrayList都实现了。

</>复制代码 
ArrayList 内部实现是通过一个对象数组
transient Object[] elementData

</>复制代码 
ArrayList add() 方法实质上是实现了在数组的末尾添加一个元素 elementData[size++] = el 所以执行的时间复杂度是固定的O(1)，添加n个元素为O(n)

</>复制代码 
因为本质上是对数组进行操作，当在数组中插入、删除数据时，需要先对数组进行移位操作，插入时需要将插入点以后的数据全部后移，而删除操作则需要将删除节点后的数据全部前移,操作时间复杂度为O(n)。

</>复制代码 
ArrayList 在多线程情况下有线程进行修改时，是线程不安全的。线程安全性问题，取决于如何应用。List list = Collections.synchronizedList(new ArrayList(...))可以获取线程安全的ArrayList

ArrayList 有其自动扩容机制也可以在预知要处理数据大小时手动扩容

</>复制代码 
1.自动扩容
ArrayList 在新增元素时（add ,addAll操作）会先检测当前内部数组elementData[]的容量是否足够添加新元素，如果不足则扩容，ArrayList最大容量为Integer.MAX_VALUE，自动扩容调用的流程如下
</>复制代码 
</>复制代码 
public boolean add(E e) {
    // 自动扩容，并记录元素修改数量 ，元素修改数量主要是用于并发修改错误
    ensureCapacityInternal(size + 1); 
    elementData[size++] = e;
    return true;
}
private void ensureCapacityInternal(int minCapacity) {
    ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}
// 返回一个数组大小的值 minCapacity 和默认的 DEFAULT_CAPACITY 中较大的那个
private static int calculateCapacity(Object[] elementData, int minCapacity) {
    // 如果是空数组 通过new ArrayList()创建
    if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
      // 默认大小是DEFAULT_CAPACITY =  10
      return Math.max(DEFAULT_CAPACITY, minCapacity);
    }
    return minCapacity;
}
实际扩充容量的片段
</>复制代码 
private void ensureExplicitCapacity(int minCapacity) {
    modCount++;
    // 将上面方法返回的大小和当前 elementData 大小进行比较，判断是否需要扩容
    if (minCapacity - elementData.length > 0)
      grow(minCapacity);
}
private void grow(int minCapacity) { // 具体扩容代码
    int oldCapacity = elementData.length;
    // 扩容后容量总是扩容前的大约1.5倍左右增量0.5
    int newCapacity = oldCapacity + (oldCapacity >> 1);
    if (newCapacity - minCapacity < 0)
          newCapacity = minCapacity;
    // 如果扩容后超出了最大个数限制 则由hugeCapacity()来处理
    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);
}
private static int hugeCapacity(int minCapacity) {
    if (minCapacity < 0) // overflow
          throw new OutOfMemoryError();
    return (minCapacity > MAX_ARRAY_SIZE) ? Integer.MAX_VALUE : MAX_ARRAY_SIZE;
}
2.手动扩容或者指定初始容量
ArrayList 手动扩容主要是调用ensureCapacity(int minCapacity)方法，除此之外还能在创建ArrayList时指定初始容量
</>复制代码 
创建时直接指定容量new ArrayList<>(initialCapacity)及其实现
</>复制代码 
public ArrayList(int initialCapacity) {
    if (initialCapacity > 0) {
        // 创建指定容量的一个数组
        this.elementData = new Object[initialCapacity];
    } else if (initialCapacity == 0) {
        this.elementData = EMPTY_ELEMENTDATA;
    } else {
        throw new IllegalArgumentException("Illegal Capacity: "+
                                           initialCapacity);
    }
}
通过ensureCapacity(int minCapacity)方法在处理过程中扩容，这种情况一般发生在处理过程中发现初始容量不能满足当前数据需求，而又为了避免自动扩容时的资源浪费，因为每次自动扩容时都会进行数组复制。
</>复制代码 
public void ensureCapacity(int minCapacity) {
    int minExpand = (elementData != DEFAULTCAPACITY_EMPTY_ELEMENTDATA) ? 0: DEFAULT_CAPACITY;
    if (minCapacity > minExpand) {
        ensureExplicitCapacity(minCapacity);
    }
}
3.最后看看扩容时的数组复制,数组复制是通过Arrays.copyOf(origin,newLenght)方法来实现的
</>复制代码 
public static  T[] copyOf(T[] original, int newLength) {
    return (T[]) copyOf(original, newLength, original.getClass());
}
// 具体复制代码
public static  T[] copyOf(U[] original, int newLength, Class newType) {
    @SuppressWarnings("unchecked")
    T[] copy = ((Object)newType == (Object)Object[].class)
        ? (T[]) new Object[newLength]
        : (T[]) Array.newInstance(newType.getComponentType(), newLength);
    // 将旧数组中的数据复制到新数组
    System.arraycopy(original, 0, copy, 0,
                     Math.min(original.length, newLength));
    return copy;
}

</>复制代码 
ArrayList在方法中传递时，传递的是对象的引用，当某一个方法修改了ArrayList时，该修改会反映到引用该ArrayList的所有地方，不管传递多少次，都引用的时同一个内存区域的数据，所以如果要实现在传递时确保内容不变，应该克隆(用ArrayList的clone())方法一份进行传递(需要注意深浅克隆问题深克隆可以使用Collections.copy(dest,src)方法)，具体该怎么弄，还是要视需求而定。

</>复制代码 
如果要找他们之间的关系可能就是size=元素数量 <= capacity = 容量大小吧。size 反映的是当前数组中存了多少数据，而capacity则反映的是ArrayList内部数组的容量。不能习惯性认为capacity 既是 size

</>复制代码 
ArrayList和LinkedList为什么会存在选择性问题，因为他们在get、add、remove时性能是不一样的。
ArrayList是内部实现是数组，在随机存取时时间复杂度是O(1)知道索引就能立马取值，而其插入和删除操作就相对比较麻烦，需要进行移位操作线性的时间复杂度。
LinkedList 是双向连表Doubly-linked ，在插入和删除时时间复杂度都是O(1)，但索引（取索引位上的值）时需要从表头或者表尾进行遍历操作。
所以选用哪一个，完全取决于你要进行的操作是以随机存取为主还是增删元素较多为主。

</>复制代码 
transient关键字的作用是阻止对象序列化，那么为什么要防止elementData序列化呢?那是因为elementData是一个数组，并且并不是数组中每一个位置上都保存有值，容量10000的数组中可能只保存了10个对象。所以不能对其进行序列化，在ArrayList中重写了writeObject 、readObject 方法来对ArrayList进行序列化控制。

</>复制代码 
RandomAccess接口是一个标记接口并没有定义任何方法，ArrayList 实现它是标记ArrayList支持快速随机访问这一特性！

</>复制代码 
并发修改异常ConcurrentModificationException通常出现在对一个List进行遍历时，对正在遍历的数组进行了修改性操作（修改性操作：改变大小（size=数量）的操作，而不是指具体值）(add,remove,clear等)时便会抛出这个异常，在ArrayList内部有一个protected transient int modCount = 0的变量用于记录对ArrayList的修改，比如add方法代码
</>复制代码 
public boolean add(E e) {
    ensureCapacityInternal(size + 1);  // Increments modCount!!
    elementData[size++] = e;
    return true;
}
private void ensureCapacityInternal(int minCapacity) {
    ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}
private void ensureExplicitCapacity(int minCapacity) {
    modCount++;
    if (minCapacity - elementData.length > 0)
        grow(minCapacity);
}
可以看到在调用add方法时会执行modCount++操作以此标记最新修改的数量modCount
而在遍历时比如forEach先看代码
</>复制代码 
public void forEach(Consumer action) {
    Objects.requireNonNull(action);
    final int expectedModCount = modCount;
    @SuppressWarnings("unchecked")
    final E[] elementData = (E[]) this.elementData;
    final int size = this.size;
    for (int i=0; modCount == expectedModCount && i < size; i++) {
        action.accept(elementData[i]);
    }
    if (modCount != expectedModCount) {
        throw new ConcurrentModificationException();
    }
}
可以看到for循环中一个明确的条件是modCount == expectedModCount 每次遍历都会检测该条件是否成立，而在进入该段代码之前先用final int expectedModCount = modCount;来保存代码执行之前的修改数量，当进入遍历后，有了更改操作，就会使得expectedModCount 和modCount不相等此时便会抛出ConcurrentModificationException异常，对于其他的修改操作，原理都是类似的。