ArrayList源码解析-java8

今天开始整理java集合的一些源码，ArrayList相对简单，所以先从此开始。
在面试中经常会被问道ArrayList和LinkedList的区别，如果能从源码角度回答的话，应该会被HR加分。
那么，废话不多说，让我们一起来学习吧！いっしょに勉強しましょう！

如果有喜欢学习日语的小伙伴可以留个联系方式呀！一起搞一搞！

ArrayList介绍：

• ArrayList实现了List接口，内部以动态数组存储数据，允许重复。
• ArrayList具有数组所具有的特性，通过索引支持随机访问。访问元素性能高，插入，删除效率低。但是在数组末尾插入元素效率高。默认初始容量为10，随着ArrayList中元素的增加，容量也会不断自动增长。每次添加新元素时，都会检查是否需要进行扩容操作，扩容需要重新拷贝数组，比较耗时，所以如果能预先知道数组大小，可以在初始化的时候指定一个初始容量。
• ArrayList非线程安全，不是同步的。

1.属性介绍

/**
 * 初始化默认容量。
 */
private static final int DEFAULT_CAPACITY = 10;

/**
 * 指定该ArrayList容量为0时，返回该空数组。
 */
private static final Object[] EMPTY_ELEMENTDATA = {};

/**
 * 当调用无参构造方法，返回的是该数组。刚创建一个ArrayList 时，其内数据量为0。
 * 它与EMPTY_ELEMENTDATA的区别就是：该数组是默认返回的，而后者是在用户指定容量为0时返回。
 */
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

/**
 * 保存添加到ArrayList中的元素。
 * ArrayList的容量就是该数组的长度。
 * 该值为DEFAULTCAPACITY_EMPTY_ELEMENTDATA 时，当第一次添加元素进入ArrayList中时，数组将扩容值DEFAULT_CAPACITY。
 * 被标记为transient，在对象被序列化的时候不会被序列化。
 */
transient Object[] elementData; // non-private to simplify nested class access

/**
 * ArrayList的实际大小（数组包含的元素个数）。
 * @serial
 */
private int size;

2. 构造方法

ArrayList提供了三种构造方法。

• ArrayList(int initialCapacity)：构造一个指定容量为capacity的空ArrayList。
• ArrayList()：构造一个初始容量为 10 的空列表。
• ArrayList(Collection<? extends E> c)：构造一个包含指定 collection 的元素的列表，这些元素是按照该 collection 的迭代器返回它们的顺序排列的。

ArrayList( int initialCapacity)

/**
 * 构造一个指定初始化容量为capacity的空ArrayList。
 *
 * @param  initialCapacity  ArrayList的指定初始化容量
 * @throws IllegalArgumentException  如果ArrayList的指定初始化容量为负。
 */
public ArrayList(int initialCapacity) {
	//判断指定的初始化容量，如果大于0，则新建一个Object数组，否则返回上述属性中的EMPTY_ELEMENTDATA
    if (initialCapacity > 0) {
        this.elementData = new Object[initialCapacity];
    } else if (initialCapacity == 0) {
        this.elementData = EMPTY_ELEMENTDATA;
    } else {
        throw new IllegalArgumentException("Illegal Capacity: "+
                                           initialCapacity);
    }
}

ArrayList()

/**
 * 构造一个初始容量为 10 的空列表。
 */
public ArrayList() {
    this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}

ArrayList(Collection<? extends E> c)

/**
 * 构造一个包含指定 collection 的元素的列表，这些元素是按照该 collection 的迭代器返回它们的顺序排列的。
 *
 * @param c 其元素将放置在此列表中的 collection
 * @throws NullPointerException 如果指定的 collection 为 null
 */
public ArrayList(Collection<? extends E> c) {
    elementData = c.toArray();
    if ((size = elementData.length) != 0) {
        // c.toArray might (incorrectly) not return Object[] (see 6260652)
        if (elementData.getClass() != Object[].class)
            elementData = Arrays.copyOf(elementData, size, Object[].class);
    } else {
        // replace with empty array.
        this.elementData = EMPTY_ELEMENTDATA;
    }
}

3.主要方法：

构造方法介绍完之后，一起看一下主要的操作方法：

get方法：
介绍：get方法相对简单，判断是否越界，之后通过数组下标来获取数据。所以get方法的时间复杂度为O(1)。

/**
 * Returns the element at the specified position in this list.
 *
 * @param  index index of the element to return
 * @return the element at the specified position in this list
 * @throws IndexOutOfBoundsException {@inheritDoc}
 */
public E get(int index) {
	 //检查下标index是否越界，如果下标大于当前的size，那么会报下标越界异常
	 rangeCheck(index);
	 //返回具体的下标的值
	 return elementData(index);
}
 
/**
 * Checks if the given index is in range.  If not, throws an appropriate
 * runtime exception.  This method does *not* check if the index is
 * negative: It is always used immediately prior to an array access,
 * which throws an ArrayIndexOutOfBoundsException if index is negative.
 */
private void rangeCheck(int index) {
	 //检测下标是否越界
	 if (index >= size)
	  throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}

/**
 * 返回索引为index的元素
 */
@SuppressWarnings("unchecked")
E elementData(int index) {
    return (E) elementData[index];
}

add方法：

/**
 * 添加元素到list末尾.
 *
 * @param e 被添加的元素
 * @return true
 */
public boolean add(E e) {
    //确认list容量，如果不够，容量加1。
    ensureCapacityInternal(size + 1);  // Increments modCount!!
    elementData[size++] = e;
    return true;
}

private void ensureCapacityInternal(int minCapacity) {
 	ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}

//计算容量
private static int calculateCapacity(Object[] elementData, int minCapacity) {
	 //判断当前是否是默认的数组
	 if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
	  	return Math.max(DEFAULT_CAPACITY, minCapacity);
	 }
	 return minCapacity;
}

private void ensureExplicitCapacity(int minCapacity) {
	 modCount++;
	 // overflow-conscious code
	 //如果当前的最小容量，大于目前的数据长度，那么需要扩容
	 if (minCapacity - elementData.length > 0)
	  	grow(minCapacity);
}

/**
 * Increases the capacity to ensure that it can hold at least the
 * number of elements specified by the minimum capacity argument.
 *
 * @param minCapacity the desired minimum capacity
 */
private void grow(int minCapacity) {
	 // overflow-conscious code
	 //没扩容前的容量
	 int oldCapacity = elementData.length;
	 //这个是扩容的重点，oldCapacity >> 1右移一位，然后再+oldCapacity,相当于扩容为原先的1.5倍
	 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 = Arrays.copyOf(elementData, newCapacity);
}

private static int hugeCapacity(int minCapacity) {
	 //判断入参容量的大小
	 if (minCapacity < 0) // overflow
	  throw new OutOfMemoryError();
	 //和最大容量进行比较，如果大于最大容量，则扩容后最大容量为定义的最大容量，不会无限制扩容
	 return (minCapacity > MAX_ARRAY_SIZE) ?
	  Integer.MAX_VALUE :
	  MAX_ARRAY_SIZE;
}

set方法：

/**
 * Replaces the element at the specified position in this list with
 * the specified element.
 *
 * @param index index of the element to replace
 * @param element element to be stored at the specified position
 * @return the element previously at the specified position
 * @throws IndexOutOfBoundsException {@inheritDoc}
 */
public E set(int index, E element) {
	 //判断下标是否越界
	 rangeCheck(index);
	 //获取旧数据
	 E oldValue = elementData(index);
	 //在对应的下标下更新数据
	 elementData[index] = element;
	 //返回旧数据
	 return oldValue;
}

remove方法：

/**
 * 删除list中位置为指定索引index的元素
 * 索引之后的元素向左移一位
 *
 * @param index 被删除元素的索引
 * @return 被删除的元素
 * @throws IndexOutOfBoundsException 如果参数指定索引index>=size，抛出一个越界异常
 */
public E remove(int index) {
    //检查索引是否越界。如果参数指定索引index>=size，抛出一个越界异常
    rangeCheck(index);
    //结构性修改次数+1
    modCount++;
    //记录索引为inde处的元素
    E oldValue = elementData(index);

    // 删除指定元素后，需要左移的元素个数
    int numMoved = size - index - 1;
    //如果有需要左移的元素，就移动（移动后，该删除的元素就已经被覆盖了）
    if (numMoved > 0)
        System.arraycopy(elementData, index+1, elementData, index,
                         numMoved);
    // size减一，然后将索引为size-1处的元素置为null。为了让GC起作用，必须显式的为最后一个位置赋null值
    elementData[--size] = null; // clear to let GC do its work

    //返回被删除的元素
    return oldValue;
}

/**
 * 越界检查。
 * 检查给出的索引index是否越界。
 * 如果越界，抛出运行时异常。
 * 这个方法并不检查index是否合法。比如是否为负数。
 * 如果给出的索引index>=size，抛出一个越界异常
 */
private void rangeCheck(int index) {
    if (index >= size)
        throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}