Java集合框架源码学习-ArrayList

java集合框架体系结构

java集合框架顶层接口为：Collection接口，然后List和Set接口实现了Collection接口。其中，ArrayList和LinkedList具体实现了List接口，HashSet和TreeSet具体实现了Set接口,本文将尽可能仔细分析ArrayList的源代码（基于jdk1.8）。

ArrayList源码

类变量

下面将介绍一些ArrayList的类变量：

    /**
     *默认容量为10，当不使用任何参数初始化ArrayList时的elementData的默认容量
     */
    private static final int DEFAULT_CAPACITY = 10;

    /**
     * 空的数组实例
     */
    private static final Object[] EMPTY_ELEMENTDATA = {};

    /**
     * 默认容量的空数组实例，当不使用参数初始化List时，将elementData数组指向本实例，
     * 再添加第一个元素时在扩充数组
     */
    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

    /**
     *存储具体数据的数组，容量为初始化时指定容量或默认容量（初始化时为指定容量）
     */
    transient Object[] elementData; // non-private to simplify nested class access

    /**
     * 当前ArrayList中的存储的元素数量
     */
    private int size;
    /**
    *elementData数组长度的最大值
    */
    private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

由以上代码可知，ArrayList的初始化时默认的容量大小为10，当不使用参数初始化ArrayList时，不会为elementData数组分配空间，只有当添加第一个元素对象是才会对elementData进行扩容。

方法实现

初始化方法

ArrayList一共有3个初始化方法：

• 无参方法:

    public ArrayList() {
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }

直接将elementData 指向默认容量的空数组，不会对elementData 进行初始化；

• 参数为一个整数（容量）：

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

参数为elementData 数组的·初始化容量，=0时指向空的element实例；<0时会抛出异常；>0时会对elementData 数组进行初始化。

• 参数为一个集合

    public ArrayList(Collection<? extends E> c) {
        elementData = c.toArray();
        if ((size = elementData.length) != 0) {
            // c.toArray 可能 (不正确) 不会返回 Object[] (see 6260652)
            if (elementData.getClass() != Object[].class)
            //调用Arrays.copyOf方法实现Object数组的复制。底层调用的是系统的Native方法
                elementData = Arrays.copyOf(elementData, size, Object[].class);
        } else {
            // 用空数组替代.
            this.elementData = EMPTY_ELEMENTDATA;
        }
    }

使用一个集合来对ArrayList进行初始化，首先将集合参数转化为一个Object数组，然后赋给elementData，同时如果两个对象指向同一个地址会造成修改混乱问题，因此需要对elementData重新声明一个新的地址空间，程序调用Arrays.copyOf方法实现Object数组的复制，而Arrays.copyO又调用了一个Native方法 System.arraycopy。

公共方法

• size（）方法：获得ArrayList中元素的数量

public int size() {
        return size;
    }

直接返回size参数

• isEmpty（）方法：判断ArrayList是否为空

 public boolean isEmpty() {
        return size == 0;
    }

直接判断size是否为0.

• contains(Object o) 方法：判断ArrayList是否包含某个元素，参数为Object，因为java中Object类是所有类父类，使用Object类型可以兼容所有的对象。

public boolean contains(Object o) {
        return indexOf(o) >= 0;
    }

由源码可知，contains方法是通过调用indexOf方法实现的，返回值大于0时，证明包含该对象，下面我们来看indexOf方法。

• indexOf(Object o) 方法：返回对象在ArrayList中的elementData数组的第一次出现的下标，若对象不存在则返回-1；

    public int indexOf(Object o) {
        if (o == null) {//判断o==null的原因，避免出现指针异常
        //o为空时，判断数组中是否存在空元素
            for (int i = 0; i < size; i++)
                if (elementData[i]==null)
                    return i;
        } else {
        //数组不为空，则挨个对象比较
            for (int i = 0; i < size; i++)
                if (o.equals(elementData[i]))
                    return i;
        }
        //不存在，返回空
        return -1;
    }

从源码可知，o不为空时会调用equals（）函数进行比较。同时由于要遍历整个数组，indexOf（）方法和contains()方法的时间复杂度都为O（n）。
注意：如果使用自定义对象为重载equals（）函数，则Object的equals（）函数默认比较的对象地址。

• lastIndexOf(Object o) 方法：返回对象在ArrayList中的elementData数组最后一次出现的下标,不存在返回-1。

    public int lastIndexOf(Object o) {
       if (o == null) {
           for (int i = size-1; i >= 0; i--)
               if (elementData[i]==null)
                   return i;
       } else {
           for (int i = size-1; i >= 0; i--)
               if (o.equals(elementData[i]))
                   return i;
       }
       return -1;
   }

时间复杂度同indexOf方法，为：O（n）。

• toArray（）方法共有两个，第一个：无参方法返回一个新的数组，第二个传入一个数组a，将elementData中元素拷贝进数组a中。

    public Object[] toArray() {
        return Arrays.copyOf(elementData, size);
    }
    public <T> T[] toArray(T[] a) {
        if (a.length < size)//如果a的长度小于size，则新建一个数组返回
            // 创建a类型的新数组，但数组内元素为elementData内的元素
            return (T[]) Arrays.copyOf(elementData, size, a.getClass());
        System.arraycopy(elementData, 0, a, 0, size);
        if (a.length > size)
            a[size] = null;
        return a;
    }

注意：拷贝时，数组中的对象的相互顺序不会改变。

• get(int index) 方法·:返回数组中指数为index的对象。

   public E get(int index) {
       rangeCheck(index);

       return elementData(index);
   }

其中 rangeCheck(index)方法：检查输入的index是否合法； elementData(index)这是获得 elementData数组中index为的对象。时间复杂度为：O（1）；

• set(int index, E element) 方法：将index位置的对象，替换为element，同时返回被替换的对象

    public E set(int index, E element) {
        rangeCheck(index);

        E oldValue = elementData(index);
        elementData[index] = element;
        return oldValue;
    }

时间复杂度：O（1）

• add(E e)方法：向ArrayList中添加一个对象，如果elementData数组没有多余空间时，则会进行扩容

  public boolean add(E e) {
       ensureCapacityInternal(size + 1);  // 判断是否需要扩容
       elementData[size++] = e;
       return true;
   }
   //扩容函数，每次扩容为之前容量的1.5倍或minCapacity；minCapacity为需求的最小容量
  private void grow(int minCapacity) {
       // 旧容量为elementData数组的长度，每次扩容时表示elementData已满
       int oldCapacity = elementData.length;
       //新容量为旧容量的1.5倍
       int newCapacity = oldCapacity + (oldCapacity >> 1);
       //如果小于最小容量，则扩容至最小容量
       if (newCapacity - minCapacity < 0)
           newCapacity = minCapacity;
         //判断新容量是否大于最大容量的限制
       if (newCapacity - MAX_ARRAY_SIZE > 0)
       //大于则将新容量设置为 MAX_ARRAY_SIZE或 Integer.MAX_VALUE
           newCapacity = hugeCapacity(minCapacity);
       //复制新数组
       elementData = Arrays.copyOf(elementData, newCapacity);
   }
  //在指定位置添加元素
   public void add(int index, E element) {
       rangeCheckForAdd(index);

       ensureCapacityInternal(size + 1);  // Increments modCount!!
       System.arraycopy(elementData, index, elementData, index + 1,
                        size - index);
       elementData[index] = element;
       size++;
   }

由以上代码可知，使用add（）方法扩容时，每次扩容一般扩展为之前容量的1.5倍或之前容量加1（初始容量为1时），时间复杂度：O（n）

• remove(int index)和remove(Object o)方法：移除ArrayList中的一个元素对象，并返回该元素对象。

    //移除指定位置上的对象
    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;
    }
    //移除第一个与o相同的对象对象
    public boolean remove(Object o) {
        if (o == null) {
            for (int index = 0; index < size; index++)
                if (elementData[index] == null) {
                    fastRemove(index);
                    return true;
                }
        } else {
        //遍历数组，寻找与o相同的对象
            for (int index = 0; index < size; index++)
                if (o.equals(elementData[index])) {
                //fastRemove作用将index之后的元素前移一位
                    fastRemove(index);
                    return true;
                }
        }
        return false;
    }

从以上源代码可知，移除元素就相当于将index之后的分别元素前移一位，从而将index位置的元素覆盖掉，因此时间复杂度为：O（n）；

• clear() 方法：清空ArrayList中的全部元素，将elementData数组中的元素赋值为null

    public void clear() {
        modCount++;

        // 
        for (int i = 0; i < size; i++)
            elementData[i] = null;

        size = 0;
    }

时间复杂度：O（n）

• addAll（）方法添加一个集合

   public boolean addAll(Collection<? extends E> c) {
   //转化为Object数组
        Object[] a = c.toArray();
        int numNew = a.length;
        //判断当前elementData数组容量是否充足，若容量不够则进行扩容
        ensureCapacityInternal(size + numNew);  
        //将a数组拷贝进elementData数组中
        System.arraycopy(a, 0, elementData, size, numNew);
        size += numNew;
        //如果输入数组为空返回false，否则返回true
        return numNew != 0;
    }
    public boolean addAll(int index, Collection<? extends E> c) {
    	//判断index的范围是否符合条件
        rangeCheckForAdd(index);
		//其余同addAll的单参数方法
        Object[] a = c.toArray();
        int numNew = a.length;
        ensureCapacityInternal(size + numNew);  // Increments modCount

        int numMoved = size - index;
        //进行两次复制，第一次将index之后的数据
        if (numMoved > 0)
            System.arraycopy(elementData, index, elementData, index + numNew,
                             numMoved);

        System.arraycopy(a, 0, elementData, index, numNew);
        size += numNew;
        return numNew != 0;
    }

• removeAll(Collection<?> c) 方法：清除与c中元素相同的元素

	public boolean removeAll(Collection<?> c) {
       	Objects.requireNonNull(c);
       	return batchRemove(c, false);
   }

对elementData中的每个元素依次判断是否存在于c，存在则删除，否则保留，删除采取覆盖方式，第一个保留的元素放在elementData[0],第二个放在elementData[1]，以此类推时间复杂度：O（nm）

• retainAll(Collection<?> c) 方法：保留ArrayList与c中元素相同的元素

    public boolean retainAll(Collection<?> c) {
        Objects.requireNonNull(c);
        return batchRemove(c, true);
    }

实现方法同removeAll(Collection<?> c),时间复杂度：O（nm）

总结

ArrayList的实现相对而言比较简单，同时通过index读取数据和在结尾添加数据（不考虑扩容）的时间复杂度为O（1），删除元素和得到元素位置等操作的时间复杂度都为O（n）。