本文已参与「新人创作礼」活动，一起开启掘金创作之路。

前言

ArrayList可以说是日常开发中最常用到的一个数据结构了，今天我们开始撸一下它的源码，因为涉及知识点较多所以准备分为几个部分来写，今天是第一个部分，主要介绍ArrayList的常用方法。

整体结构

ArrayList的继承关系如下所示：

需要注意到ArrayList实现了RandomAccess这个接口，其源码如下：

public interface RandomAccess {
}

可以看到这个接口里并没有任何属性或者方法，那为什么还有实现呢？主要是为了做一个标记，用来表明实现该接口的类支持快速（通常是固定时间）随机访问。此接口允许算法更改其行为，从而在随机或连续访问列表时能够提供良好的性能。

ArrayList底层其实是一个数组，比较简单，如下所示：

ArrayList的特点如下：

允许null值；
有序，可根据索引快速访问；
非线程安全；
快速失败，若是在遍历过程中，对集合进行结构性修改（增，删），会导致快速失败(fast-fial)，这也是为什么《阿里巴巴Java开发手册》中禁止ArrayList在循环时增删元素；

成员变量

             //默认容量
             private static final int DEFAULT_CAPACITY = 10;
             //空数组 
             private static final Object[] EMPTY_ELEMENTDATA = {};
             //默认空数组 无参构造时用到
             private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
             //元素数组 真正用于存储元素
             transient Object[] elementData;
             //数组最大长度
             private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
             //元素个数
             private int size;

构造方法

          //无参构造 
          public ArrayList() {
            // 默认使用DEFAULTCAPACITY_EMPTY_ELEMENTDATA 此时大小为0
            this.elementData = DEFAULTDEFAULTCAPACITY_EMPTY_ELEMENTDATACAPACITY_EMPTY_ELEMENTDATA;
          }

          //带有 capacity入参的构造方法
          public ArrayList(int initialCapacity) {
            if (initialCapacity > 0) {
              this.elementData = new Object[initialCapacity];
            } else if (initialCapacity == 0) {
              //等于0是 使用EMPTY_ELEMENTDATA 此时大小为0
              this.elementData = EMPTY_ELEMENTDATA;
            } else {
              throw new IllegalArgumentException("Illegal Capacity: "+
                                                 initialCapacity);
            }
          }
          //集合作为入参的构造方法
          public ArrayList(Collection<? extends E> c) {
            //elementData 是保存数组的容器，默认为 null
            elementData = c.toArray();
            //如果给定的集合（c）数据有值
            if ((size = elementData.length) != 0) {
              //如果集合元素类型不是 Object 类型，我们会转成 Object
              if (elementData.getClass() != Object[].class)
                elementData = Arrays.copyOf(elementData, size, Object[].class);
            } else {
              // 给定集合（c）无值，则默认空数组
              this.elementData = EMPTY_ELEMENTDATA;
            }
          }

关于这几个构造函数需要注意的点：

ArrayList无参构造初始化时，默认大小数组是空数组，而不是常说的10，ArrayList也是懒加载，只有真正存放数据时才会去进行扩容；
在使用集合作为入参的构造函数时，，当给定集合内的元素不是Object类型时，默认会将其转换为Object类型；

常用方法

下面详细撸一下几个常用方法的源码

add(E e)

           public boolean add(E e) {
            //检测目前的数组是否还能继续存放元素，不够执行扩容，size 为当前数组的大小
            ensureCapacityInternal(size + 1);  
            //直接赋值，线程不安全的
            elementData[size++] = e;
            return true;
          }

          private void ensureCapacityInternal(int minCapacity) {
            // 调用无参构造时进入该if分支
            if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
              //这也说明了，当使用无参构造时，第一次add时，数组会长度会由0增加到10
              minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
            }
            //确保容积足够
            ensureExplicitCapacity(minCapacity);
          }

          private void ensureExplicitCapacity(int minCapacity) {
            // 更新modCount
            modCount++;

            //如果期望的最小容量大于目前数组的长度，那么就扩容
            if (minCapacity - elementData.length > 0)
              grow(minCapacity);
          }


          //扩容，并把现有数据拷贝到新的数组里面去
          private void grow(int minCapacity) {
            //当前数组的长度
            int oldCapacity = elementData.length;
            //新数组长度为1.5倍的旧长度
            int newCapacity = oldCapacity + (oldCapacity >> 1);
            //如果新数组长度小于期望的最小容量 那么新数组长度直接设为期望容量
            if (newCapacity - minCapacity < 0)
              newCapacity = minCapacity;
            //如果新数组长度大于最大允许的数组长度 新数组容量设为Integer的最大值
            if (newCapacity - MAX_ARRAY_SIZE > 0)
              newCapacity = hugeCapacity(minCapacity);
            // 通过复制进行扩容
            elementData = Arrays.copyOf(elementData, newCapacity);
          }

          //private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

          private static int hugeCapacity(int minCapacity) {
            if (minCapacity < 0) // overflow
              throw new OutOfMemoryError();
            return (minCapacity > MAX_ARRAY_SIZE) ?
              Integer.MAX_VALUE :
            MAX_ARRAY_SIZE;
          }

add(E e)的逻辑还是比较清晰和简单的：

先判断是否需要扩容，需要的话就进行扩容，否则直接赋值即可；
扩容时，新数组的长度为旧数组长度的1.5倍；
扩容时调用的Arrays#copyOf方法其底层最后调用的是一个native方法，System#arraycopy；
ArrayList中的数组的最大值是Integer.MAX_VALUE，超过该值时JVM不会再继续分配内存空间了；
新增时，没有对入参做校验，因而ArrayList允许为null；

add(int index, E e)

            public void add(int index, E element) {
                    //检查下标是否越界
                    rangeCheckForAdd(index);
                    //检查是否需要扩容
                    ensureCapacityInternal(size + 1); 
                    // 数组元素位置调整
                    System.arraycopy(elementData, index, elementData, index + 1,
                                     size - index);
                    //索引位置处涉及值
                    elementData[index] = element;
                    //更新size
                    size++;
                }

            private void rangeCheckForAdd(int index) {
                    if (index > size || index < 0)
                        throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
                }

没啥好分析的，看一下注释就行。

add(Collection<? extends E> c)

          public boolean addAll(Collection<? extends E> c) {
            //转为Object数组
            Object[] a = c.toArray();
            //获取集合长度
            int numNew = a.length;
            // 检查是否需要进行扩容
            ensureCapacityInternal(size + numNew);
            //将c添加到数组中
            System.arraycopy(a, 0, elementData, size, numNew);
            //更新size
            size += numNew;
            return numNew != 0;
          }

get(int index)

            public E get(int index) {
                    //检测下标是否越界
                    rangeCheck(index);
                    //直接返回索引位置处的数据
                    return elementData(index);
                }

remove(int index)

          public E remove(int index) {
            //检测下标是否越界
            rangeCheck(index);
            // 更新modCount
            modCount++;
            //索引位置处的值
            E oldValue = elementData(index);
            // numMoved 表示删除 index 位置的元素后，需要从 index 后移动多少个元素到前面去
            // 减 1 的原因，是因为 size 从 1 开始算起，index 从 0开始算起
            int numMoved = size - index - 1;
            if (numMoved > 0)
              // 从 index +1 位置开始被拷贝，拷贝的起始位置是 index，长度是 numMoved
              System.arraycopy(elementData, index+1, elementData, index,
                               numMoved);
            //置为null 帮助gc
            elementData[--size] = null; // clear to let GC do its work

            // 返回旧值
            return oldValue;
          }

remove(Object o)

          public boolean remove(Object o) {
            // 如果o为null
            if (o == null) {
              // 正序遍历，将第一个null对象移除
              for (int index = 0; index < size; index++)
                if (elementData[index] == null) {
                  fastRemove(index);
                  return true;
                }
            } else {
              // 否则的话遍历数组进行查找，然后删除
              for (int index = 0; index < size; index++)
                // 这里是根据  equals 来判断值相等的，相等后再根据索引位置进行删除
                if (o.equals(elementData[index])) {
                  fastRemove(index);
                  return true;
                }
            }
            return false;
          }

          // 可以看出没有返回值的 remove(int index)
          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的底层数据结构、增删改查四个方法以及支撑这四个方法的其他方法。下篇文章准备再介绍一下ArrayList其他几个比较重要的方法。

JDK8 ArrayList源码解析P1

前言