ArrayList源码解析

一、简介：

讲解的版本是JDK 1.8。ArrayList是基于数组实现的，是一个动态数组，其容量能自动增长，类似于C语言中的动态申请内存，动态增长内存。ArrayList不是线程安全的，只能用在单线程环境下，多线程环境下可以考虑用Collections.synchronizedList(List l)函数返回一个线程安全的ArrayList类，也可以使用concurrent并发包下的CopyOnWriteArrayList类。

二、重要成员变量：

transient Object[] elementData：保存元素

private int size：当前保存的元素数量

private static final int DEFAULT_CAPACITY = 10：默认数组大小

三、构造方法：

arrayList有三个构造方法，看下最只要的：

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

initialCapacity为传入的初始容量，如果大于0，则创建数组，否则，使用默认大小为0的数组；

四、重要的方法：

1.add():

          public boolean add(E e) {
                  //检查是否越界
                ensureCapacityInternal(size + 1);  // Increments modCount!!
                //插入元素
                elementData[size++] = e;
                return true;
            }
          
           private void ensureCapacityInternal(int minCapacity) {
                   //如果是开始起始时的空数组，则在默认容量和minCapacity中选择较大的
                if (elementData == DEFAULTCAPACITY_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:
                //将原数组拷贝到创建的数组中然后赋值给elementData,最终调用System.arraycopy()来完成
                elementData = Arrays.copyOf(elementData, newCapacity);
            }

代码关键部分都做了注释，就不在解释了。

2.get():

            public E get(int index) {
                //检查索引是否越界
                rangeCheck(index);
                //直接返回元素
                return elementData(index);
            }
            private void rangeCheck(int index) {
                if (index >= size)
                    throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
            }

3.remove(int index):

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

这样基本的操作就讲完了，还是挺简单的吧。