Java8 ArrayList的实现

ArrayList底层是使用数组的方式实现的，在java8中初始化则是分配一个内存为0的对象数组（常量类型），在添加时在不断分配新内存

• 初始化

public class ArrayList<E> extends AbstractList<E>        implements List<E>, RandomAccess, Cloneable, java.io.Serializable{   //默认的数组长度    private static final int DEFAULT_CAPACITY = 10;    //java8以后的ArrayList初始化之后并不会马上分配内存空间    private static final Object[] EMPTY_ELEMENTDATA = {};     //transient修饰非序列化    transient Object[] elementData; // non-private to simplify nested class access    private int size;    public ArrayList(int initialCapacity) {        super();        if (initialCapacity < 0)            throw new IllegalArgumentException("Illegal Capacity: "+                                               initialCapacity);        this.elementData = new Object[initialCapacity];    }    public ArrayList() {        super();        this.elementData = EMPTY_ELEMENTDATA;    }}

• 添加节点

 public boolean add(E e) {        //判断是否需要扩容（传入的参数是目前所需要的最小数组长度）        ensureCapacityInternal(size + 1);         elementData[size++] = e;        return true; }private void ensureCapacityInternal(int minCapacity) {        if (elementData == EMPTY_ELEMENTDATA) {            //判断默认的长度是否符合要求            minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);        }        ensureExplicitCapacity(minCapacity);    }    private void ensureExplicitCapacity(int minCapacity) {        modCount++;        // overflow-conscious code        if (minCapacity - elementData.length > 0)            grow(minCapacity);}//进行扩容private void grow(int minCapacity) {        // overflow-conscious code        int oldCapacity = elementData.length;        int newCapacity = oldCapacity + (oldCapacity >> 1);        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:        //Arrays.copyOf(oldArray，newArrayLength)        elementData = Arrays.copyOf(elementData, newCapacity);    }

注意：Arrays.copyOf(elementData, newCapacity)在底层视线中非常常见，是将数组有一个数组复制到另一个数组中
区别：System.arraycopy(Object src, int srcPos, Object dest, int destPos, int length)表示将数组src从srcPost的位置开始复制，复制的长度为length，复制到dest数组的destPost位置上

• 删除节点（给出节点位置）

public E remove(int index) {        rangeCheck(index);        modCount++;        E oldValue = elementData(index);        int numMoved = size - index - 1;        if (numMoved > 0)            System.arraycopy(elementData, index+1, elementData, index,                             numMoved);        elementData[--size] = null; // clear to let GC do its work        return oldValue;}//判断节点位置是否存在private void rangeCheck(int index) {        if (index >= size)            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));}

• 删除节点（已知节点内容）

 public boolean remove(Object o) {        if (o == null) {            for (int index = 0; index < size; index++)                if (elementData[index] == null) {                    fastRemove(index);                    return true;                }        } else {            for (int index = 0; index < size; index++)                if (o.equals(elementData[index])) {                    fastRemove(index);                    return true;                }        }        return false;    }    //快速删除节点private void fastRemove(int index) {        modCount++;        int numMoved = size - index - 1;        if (numMoved > 0)            System.arraycopy(elementData, index+1, elementData, index,                             numMoved);        elementData[--size] = null; // clear to let GC do its work    }

同样的，在ArrayList中允许节点内容为空，也允许节点内容重复

• 获取某位置的节点

public E get(int index) {            rangeCheck(index);            checkForComodification();            return ArrayList.this.elementData(offset + index);}//判断该节点是否已经被修改了（这个一般用于并发操作的控制，防止多个线程都写不一致）private void checkForComodification() {            if (ArrayList.this.modCount != this.modCount)                throw new ConcurrentModificationException();}

• 设置某位置的节点为指定内容

public E set(int index, E element) {        rangeCheck(index);        E oldValue = elementData(index);        elementData[index] = element;        return oldValue;}//获取某位置的节点 E elementData(int index) {        return (E) elementData[index];}

• 获取表长度

//同样这里增强了对并发操作的版本控制，查看目前的size是否被改变过 public int size() {            checkForComodification();            return this.size;}