ArrayList源码分析(JDK1.8)

一、前言

前面刚分析完HashMap的源码，今天开始分析ArrayList的源码。本文将以 涉及到的数据结构->类的属性->构造方法->常用的API 的顺序来阅读源码。

二、数据结构

ArryList的数据结构如下

由上图可知，ArrayList的底层就是一个数组，数组存储的元素数据类型为Object,更准确的说，ArrayList就是一个动态数组，它可以动态的增加和减少元素、灵活的设置数组的大小。

三、类的属性

/** 支持泛型 继承于AbstarctList 实现了List接口（规定了List的操作规范）
*	实现了RandomAccess接口（支持随机访问） 
*	实现了cloneable接口（支持拷贝）
*	实现了Serializable接口（支持序列化）
*/
public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{
	/**序列化Id 很大程度上避免反序列化过程的失败。比如当版本升级后，我们可能删除了
	*  某个成员变量，也可能增加了一些新的成员变量，这个时候我们的反序列化依然能够成功，
	* 程序依然能够最大程度地恢复数据
	*/
    private static final long serialVersionUID = 8683452581122892189L;

    /**
     * 数组的默认初始大小
     */
    private static final int DEFAULT_CAPACITY = 10;

    /**
     * 空对象数组
     */
    private static final Object[] EMPTY_ELEMENTDATA = {};

    /**
     * 默认的空对象数组
     */
    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

    /**
     * 核心属性，用来存储Arraylist元素的数组
     */
    transient Object[] elementData; 

    /**
     *  数组elementData已经存储的元素的数量，初始为0
     */
    private int size;
    /**
    *  elementData的最大容量
    */
    private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
   }

四、构造方法

指定初始容量

public ArrayList(int initialCapacity) {
		  //如果给定的初始容量大于0，则按给定的初始容量进行创建数组
        if (initialCapacity > 0) {
            this.elementData = new Object[initialCapacity];
         //如果给定的初始容量值为0，则按照默认的初始容量值进行创建数组
        } else if (initialCapacity == 0) {
            this.elementData = EMPTY_ELEMENTDATA;
          //否则抛出异常
        } else {
            throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
        }
    }

默认构造函数

public ArrayList() {
        //将用来存储Arraylist元素的数组置空
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }

以集合作为参数的构造方法

public ArrayList(Collection<? extends E> c) {
		//将传进来的集合转换为数组
        elementData = c.toArray();
        //如果传进来的集合不为空
        if ((size = elementData.length) != 0) {
            //判断数组是否转换为Object类型的数组
            if (elementData.getClass() != Object[].class)
            		//如果没有转换为Object类型的数组则进行复制赋值
                elementData = Arrays.copyOf(elementData, size, Object[].class);
        } else {
            //如果传进来的集合为空，则将数组置空
            this.elementData = EMPTY_ELEMENTDATA;
        }
    }

五、常用API

增

add方法

//往数组elementDataw尾部添加一个元素
public boolean add(E e) {
		//新添加元素时，先将数组数组的容量加1
        ensureCapacityInternal(size + 1); 
        //将待添加的元素添加到数组尾部
        elementData[size++] = e;
        return true;
    }

ensureCapacityInternal方法

确保数组elementData 有合适的大小

private void ensureCapacityInternal(int minCapacity) {
		//判断数组是否为空
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
        	//如果数组为空 对minCapacity和默认初始容量之间取最大值作为数组的容量
            minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
        }
        //同样确保数组elementData有合适的大小
        ensureExplicitCapacity(minCapacity);
    }

ensureExplicitCapacity方法

private void ensureExplicitCapacity(int minCapacity) {
        //当集合结构发生改变比如新增元素时，modCount++用来记录发生改变的次数
        modCount++;
        //判断新容量是否超出了当前数组elementData的容量
        if (minCapacity - elementData.length > 0)
        	 //超出的话进行扩容
            grow(minCapacity);
    }

grow方法(扩容)

private void grow(int minCapacity) {
     //记录扩容前数组的大小
        int oldCapacity = elementData.length;
        //记录扩容后数组的大小，扩容后的数组的大小为扩容前的1.5倍
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        //再次判断扩容的数组容量够不够
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
            //判断扩容后的数组的容量是否超过最大限制
        if (newCapacity - MAX_ARRAY_SIZE > 0)
        //如果新数组的容量超出最大限制，指定新的容量
            newCapacity = hugeCapacity(minCapacity);
       //将旧数组进行扩容
        elementData = Arrays.copyOf(elementData, newCapacity);
    }

hugeCapacity方法

  private static int hugeCapacity(int minCapacity) {
        if (minCapacity < 0) // overflow
            throw new OutOfMemoryError();
         //minCapacity在超出最大限制时则重新赋值为Integer.MAX_VALUE，
      // 而不仅仅是Integer.MAX_VALUE-8
        return (minCapacity > MAX_ARRAY_SIZE) ?
            Integer.MAX_VALUE :
            MAX_ARRAY_SIZE;
    }

删

remove方法(根据数组下标删除元素)

public E remove(int index) {
		//检查索引是否合法
        rangeCheck(index);
        ///当集合结构发生改变比如增、删元素时，modCount++用来记录发生改变的次数
        modCount++;
        //保存要删除的元素的值
        E oldValue = elementData(index);
        //删除待删除元素需要移动的次数
        int numMoved = size - index - 1;
        //进行移动数组元素从而删除待删除的元素
        if (numMoved > 0)
            System.arraycopy(elementData, index+1, elementData, index,
                             numMoved);
          //将待删除的元素的位置赋空，便于gc                   
        elementData[--size] = null; 
		//返回已经删除的元素的值
        return oldValue;
    }

查

get方法（返回指定下标所在的元素的值）

 public E get(int index) {
 		//检查索引是否合法
        rangeCheck(index);
        //返回查找结果
        return elementData(index);
    }

elementData方法

返回指定下标所在的元素的值

@SuppressWarnings("unchecked")
    E elementData(int index) {
        return (E) elementData[index];
    }

indexOf方法

查找指定元素值的下标

public int indexOf(Object o) {
        //遍历数组，如果改值存在则返回值所在的下标，否则返回-1
        if (o == null) {
            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;
    }

改

set方法

改变指定位置元素的值

public E set(int index, E element) {
		//检查索引的合法性
        rangeCheck(index);
        //保存旧值
        E oldValue = elementData(index);
        //更新旧值
        elementData[index] = element;
        //返回旧值
        return oldValue;
    }

六、总结

ArrayList允许存储null值，与LinkedList相比，优势在于随机读取，缺点在于插入或者删除元素的过程中需要移动大量元素，因此效率不太高。还有一点ArrayList是线程不安全的。