JDK1.8源码(六)——java.util.ArrayList类

一、概述

1、介绍

　　ArrayList元素是有序的，可重复。线程不安全的。底层维护一个 Object 数组。
　　JDK1.7：ArrayList像饿汉式，默认初始长度直接创建一个容量为 10 的数组。
　　JDK1.8：ArrayList像懒汉式，默认一开始创建一个长度为 0 的数组，当添加第一个元素时再创建一个始容量为10的数组。
　　默认情况扩容都为原来数组的 1.5 倍。

　　继承关系：

　　扩容原理：

2、遍历方式

　　①随机访问
　　由于实现了 RandomAccess 接口，它支持通过索引值去随机访问元素。

ArrayList<String> list = new ArrayList<>();
list.add("1");
list.add("3");
list.add("2");
for (int i = 0; i < list.size(); i++) {
    System.out.println(list.get(i));
}

　　②增强forEach，底层还是使用的迭代器

ArrayList<String> list = new ArrayList<>();
list.add("1");
list.add("3");
list.add("2");
for (String s : list) {
    System.out.println(s);
}

　　这种语法可以看成是 JDK 的一种语法糖，通过反编译 class 文件，可以看到生成的 java 文件，还是通过调用 Iterator 迭代器来遍历的。

for (Iterator<String> iterator = list.iterator(); iterator.hasNext(); ) {
    iterator.next();
}

　　③迭代器 iterator

ArrayList<String> list = new ArrayList<>();
list.add("1");
list.add("3");
list.add("2");

final Iterator<String> iterator = list.iterator();
while (iterator.hasNext()) {
    System.out.println(iterator.next());
}

　　④迭代器 ListIterator

ArrayList<String> list = new ArrayList<>();
list.add("1");
list.add("3");
list.add("2");

final ListIterator<String> iterator = list.listIterator();
// 向后遍历
while (iterator.hasNext()) {
    System.out.println(iterator.next()); // 1 3 2
}

// 向前遍历.此时由于上面进行了向后遍历,游标指向了最后一个元素,所以此处向前遍历能有值
while (iterator.hasPrevious()) {
    System.out.println(iterator.previous()); // 2 3 1
}

二、类源码

1、类声明

　　源码示例：

 * @author  Josh Bloch
 * @author  Neal Gafter
 * @see     Collection
 * @see     List
 * @see     LinkedList
 * @see     Vector
 * @since   1.2
 */

public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{}

　　继承了AbstractList：AbstractList提供List接口的骨干实现，以最大限度地减少"随机访问"数据存储（如ArrayList）实现Llist所需的工作。
　　实现了 List 接口：定义了实现该接口的类都必须要实现的一组方法，实现了所有可选列表操作。
　　实现了 RandmoAccess 接口：表明ArrayList支持快速（通常是固定时间）随机访问。此接口的主要目的是允许一般的算法更改其行为，从而在将其应用到随机或连续访问列表时能提供良好的性能。比如在工具类 Collections 中，应用二分查找方法时判断是否实现了 RandomAccess 接口：

// Collections类
public static <T>
int binarySearch(List<? extends Comparable<? super T>> list, T key) {
    if (list instanceof RandomAccess || list.size()<BINARYSEARCH_THRESHOLD)
        return Collections.indexedBinarySearch(list, key);
    else
        return Collections.iteratorBinarySearch(list, key);
}

　　实现了 Cloneable 接口：一个标记接口，接口内无任何方法体和常量的声明。需要复写Object.clone()函数，表示它可以被克隆。
　　实现了 Serializable 接口：一个标记接口，标识该类可序列化。

2、类属性

　　源码示例：读一下源码中的英文注释。

private static final long serialVersionUID = 8683452581122892189L;

// 默认的初始化容量(大小)
/**
 * Default initial capacity.
 */
private static final int DEFAULT_CAPACITY = 10;

// 空的数组实例
/**
 * Shared empty array instance used for empty instances.
 */
private static final Object[] EMPTY_ELEMENTDATA = {};

// 也是一个空的数组实例.个人觉得和上一个属性没啥区别
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

// 任何一个空的 elementData 就是 DEFAULTCAPACITY_EMPTY_ELEMENTDATA
// 当它第一次 add 元素的时候会被扩展到DEFAULT_CAPACITY,也就是 10
/**
 * The array buffer into which the elements of the ArrayList are stored.
 * The capacity of the ArrayList is the length of this array buffer. Any
 * empty ArrayList with elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA
 * will be expanded to DEFAULT_CAPACITY when the first element is added.
 */
transient Object[] elementData; // non-private to simplify nested class access

// 容器的实际元素个数
private int size;

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

3、类构造器

　　源码示例：三个重载（重要）
　　ArrayList list = new ArrayList(); // 集合长度初始化是0，而不是 10，JDK7才是10。

public ArrayList() {
    // 很清楚的看到,初始化的是一个空数组
    this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}

　　ArrayList list = new ArrayList(7); // 指定大小时，初始多大就是多大。

// 不写注释也能看懂的代码
public ArrayList(int initialCapacity) {
    if (initialCapacity > 0) {
        // 大于 0 时, new 的数组大小就是多少
        this.elementData = new Object[initialCapacity];
    } else if (initialCapacity == 0) {
        // 等于 0 时, 初始化的是一个空数组
        this.elementData = EMPTY_ELEMENTDATA;
    } else {
        // 否则,参数异常
        throw new IllegalArgumentException("Illegal Capacity: "+
                                           initialCapacity);
    }
}

　　传入一个集合。

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

4、add()方法

　　源码示例：扩容原理

public boolean add(E e) {
    // 判断是否需要扩容
    ensureCapacityInternal(size + 1);  // Increments modCount!!
    elementData[size++] = e;
    return true;
}

private void ensureCapacityInternal(int minCapacity) {
    // 如果是第一次初始化的空数组
    if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
        // minCapacity = max(10,1) 体现出第一次 add 时,才初始化长度 10 的数组
        minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
    }

    ensureExplicitCapacity(minCapacity);
}

private void ensureExplicitCapacity(int minCapacity) {
    // 修改次数+1.用于集合的快速失败机制
    modCount++;

    // 需要扩容
    // overflow-conscious code
    if (minCapacity - elementData.length > 0)
        grow(minCapacity);
}

　　源码示例：真正扩容的方法

private void grow(int minCapacity) {
    // overflow-conscious code
    int oldCapacity = elementData.length;
    
    // 体现出扩容为原来的 1.5 倍
    int newCapacity = oldCapacity + (oldCapacity >> 1);
    
    // 当新数组长度仍然比minCapacity小,则为保证最小长度,新数组等于minCapacity
    if (newCapacity - minCapacity < 0)
        newCapacity = minCapacity;
        
    // MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8 = 2147483639
    if (newCapacity - MAX_ARRAY_SIZE > 0)
        newCapacity = hugeCapacity(minCapacity);
        
    // 将原数组拷贝到一个大小为 newCapacity 的新数组（注意是拷贝引用）
    // 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;
}

　　说明：
　　modCount给ArrayList的迭代器使用的，在并发修改时，提供快速失败行为，保证modCount在迭代期间不变，否则抛出ConcurrentModificationException异常。
　　ArrayList 的扩容，核心方法就是调用 Arrays.copyOf 方法，创建一个更大的数组，然后将原数组元素拷贝过去。
　　总结：
　　①当通过 ArrayList() 构造一个空集合，初始长度是为0的，第1次添加元素，会创建一个长度为10的数组，并将该元素赋值到数组的第一个位置。
　　②第2次添加元素，集合不为空，由于集合大小size + 1 < 数组的长度 10，所以直接添加元素到数组的第二个位置，不用扩容。
　　③第 11 次添加元素，此时 size+1 = 11 > 数组长度10。这时候创建一个长度为10+10*0.5 = 15 的数组（扩容1.5倍），然后将原数组元素引用拷贝到新数组。并将第 11 次添加的元素赋值到新数组下标为10的位置。
　　④第 Integer.MAX_VALUE - 8 = 2147483639，然后 2147483639%1.5=1431655759（这个数是要进行扩容）次添加元素，为了防止溢出，此时会直接创建一个 1431655759 + 1 大小的数组，这样一直，每次添加一个元素，都只扩大一个范围。
　　⑤第 Integer.MAX_VALUE - 7 次添加元素时，创建一个大小为 Integer.MAX_VALUE 的数组，在进行元素添加。
　　⑥第 Integer.MAX_VALUE + 1 次添加元素时，抛出 OutOfMemoryError 异常。

5、remove()方法

　　源码示例：

// 根据索引删除
public E remove(int index) {
    // 检查索引 index 是否越界
    rangeCheck(index);

    modCount++;
    // 获取索引处的元素
    E oldValue = elementData(index);

    int numMoved = size - index - 1;
    // 表示 0 <= index < (size-1),即索引不是最后一个元素
    if (numMoved > 0)
    // 将数组elementData的下标index+1之后长度为numMoved的元素拷贝到从index开始的位置
        System.arraycopy(elementData, index+1, elementData, index,
                         numMoved);
    // 将数组最后一个元素置为 null, 便于垃圾回收                     
    elementData[--size] = null; // clear to let GC do its work

    return oldValue;
}

// 删除指定元素
public boolean remove(Object o) {
    // 如果 o 为null
    if (o == null) {
        for (int index = 0; index < size; index++)
            if (elementData[index] == null) {
                fastRemove(index);
                return true;
            }
    } else {
        // 如果o不是null,则循环查找.删除第一次出现的该元素
        for (int index = 0; index < size; index++)
            if (o.equals(elementData[index])) {
                fastRemove(index);
                return true;
            }
    }
    return false;
}
private void fastRemove(int index) {
    modCount++;
    int numMoved = size - index - 1;
    if (numMoved > 0)
    // 通过System.arraycopy进行数组自身拷贝。
        System.arraycopy(elementData, index+1, elementData, index,
                         numMoved);
    elementData[--size] = null; // clear to let GC do its work
}

6、set()方法

　　源码示例：将指定索引index处的元素修改。

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

    // 获取索引处的元素
    E oldValue = elementData(index);
    // 将index处元素修改为element
    elementData[index] = element;
    return oldValue;
}

// 很简单.就是检查索引合法性
private void rangeCheck(int index) {
    if (index >= size)
        throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}

7、get()方法

　　源码示例：

public E get(int index) {
    rangeCheck(index);
    // 通过索引下标返回数组中的元素
    return elementData(index);
}

　　源码示例：很简单，略
　　indexOf(Object o)：返回集合中第一次出现该元素的下标，没有则返回 -1。
　　lastIndexOf(Object o)：返回集合中最后一次出现该元素的下标。没有则返回 -1。

8、SubList()

　　返回从 [fromIndex, toIndex) 的一个子串。但是注意，这里只是原集合的一个视图。

public class Main {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("1");
        list.add("3");
        list.add("2");

        List<String> subList = list.subList(0, 1);
        System.out.println(subList); // [1]

        subList.add("k");
        System.out.println(subList); // [1, k]

        // 对子串的添加影响了原集合
        System.out.println(list); // [1, k, 3, 2]
    }
}

　　想要独立出来一个集合，解决办法如下：

List<String> sub = new ArrayList<>(list.subList(0, 1));

9、Size()

public int size() {
    // 返回集合的大小
    return size;
}

10、isEmpty()

public boolean isEmpty() {
    // 集合是否为空
    return size == 0;
}

11、trimToSize()

public void trimToSize() {
    modCount++;
    if (size < elementData.length) {
        // 如果集合大小为 0 ,则数组为空
        elementData = (size == 0)
          ? EMPTY_ELEMENTDATA
          
          // 否则,按集合实际大小拷贝一份数组
          : Arrays.copyOf(elementData, size);
    }
}

　　该方法用于回收多余的内存。可以在确定集合不在添加多余的元素之后，调用 trimToSize() 方法会将数组大小调整为集合元素的大小。
　　注意：该方法会花时间来复制数组元素，所以应该在确定不会添加元素之后在调用。

三、迭代器

1、iterator

　　源码示例：

// 返回一个 Itr 对象.这个类是 ArrayList 的内部类。
public Iterator<E> iterator() {
    return new Itr();
}

private class Itr implements Iterator<E> {
    // 游标.下一个要返回的元素的索引
    int cursor;       // index of next element to return
    // 返回最后一个元素的索引; 如果没有返回-1.
    int lastRet = -1; // index of last element returned; -1 if no such
    int expectedModCount = modCount;

    // 通过 cursor != size 判断是否还有下一个元素
    public boolean hasNext() {
        return cursor != size;
    }

    @SuppressWarnings("unchecked")
    public E next() {
        // 迭代器进行元素迭代时同时进行增加和删除操作，会抛出异常
        checkForComodification();
        int i = cursor;
        if (i >= size)
            throw new NoSuchElementException();
        Object[] elementData = ArrayList.this.elementData;
        if (i >= elementData.length)
            throw new ConcurrentModificationException();
        // 游标向后移动一位    
        cursor = i + 1;
        // 返回索引为 i 处的元素,并将lastRet赋值为i
        return (E) elementData[lastRet = i];
    }

    public void remove() {
        if (lastRet < 0)
            throw new IllegalStateException();
        checkForComodification();

        try {
            // 调用ArrayList的remove方法删除元素
            ArrayList.this.remove(lastRet);
            // 游标指向删除元素的位置，本来是lastRet+1的，这里删除一个元素，然后游标就不变了
            cursor = lastRet;
            // 恢复默认值-1
            lastRet = -1;
            //expectedModCount值和modCount同步，因为进行add和remove操作，modCount会加1
            expectedModCount = modCount;
        } catch (IndexOutOfBoundsException ex) {
            throw new ConcurrentModificationException();
        }
    }

    @Override
    @SuppressWarnings("unchecked")
    public void forEachRemaining(Consumer<? super E> consumer) {
        Objects.requireNonNull(consumer);
        final int size = ArrayList.this.size;
        int i = cursor;
        if (i >= size) {
            return;
        }
        final Object[] elementData = ArrayList.this.elementData;
        if (i >= elementData.length) {
            throw new ConcurrentModificationException();
        }
        while (i != size && modCount == expectedModCount) {
            consumer.accept((E) elementData[i++]);
        }
        // update once at end of iteration to reduce heap write traffic
        cursor = i;
        lastRet = i - 1;
        checkForComodification();
    }


    // 在新增元素add() 和 删除元素 remove() 时, modCount++。修改set() 是没有的
    // 也就是说不能在迭代器进行元素迭代时进行增加和删除操作，否则抛出异常
    final void checkForComodification() {
        if (modCount != expectedModCount)
            throw new ConcurrentModificationException();
    }
}

　　注意：在进行 next() 方法调用的时候，会进行 checkForComodification() 调用，该方法表示迭代器进行元素迭代时，如果同时进行增加和删除操作，会抛出 ConcurrentModificationException 异常。比如：

ArrayList<String> list = new ArrayList<>();
list.add("1");
list.add("3");
list.add("2");

final Iterator<String> iterator = list.iterator();
while (iterator.hasNext()) {
    final String next = iterator.next();

    // Exception in thread "main" java.util.ConcurrentModificationException
    // list.remove(next);
    list.set(0, "k");
    
    // 正确方式是调用迭代器的 remove 方法
    iterator.remove();
}

　　注意：迭代器只能向后遍历，不能向前遍历，能够删除元素，但是不能新增元素。

2、listIterator

　　这是 list 集合特有的迭代器。可以一边遍历，一边新增或删除。

public class Main {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("1");
        list.add("3");
        list.add("2");

        final ListIterator<String> iterator = list.listIterator();
        // 向后遍历
        while (iterator.hasNext()) {
            System.out.print(iterator.next() + " "); // 1 3 2

            iterator.add("K");
        }

        // [1, K, 3, K, 2, K]
        System.out.println("\n" + list);

        // 向前遍历
        while (iterator.hasPrevious()) {
            System.out.print(iterator.previous() + " "); // K 2 K 3 K 1 
        }
    }
}

　　相比于 Iterator 迭代器， listIterator 多出了能向前迭代，以及新增元素的功能。
　　源码示例：

public interface ListIterator<E> extends Iterator<E> {
    // 正向迭代.是否有下一个
    boolean hasNext();
    // 取下一个
    E next();
    // 反向迭代.是否有上一个
    boolean hasPrevious();
    // 取上一个
    E previous();
    int nextIndex();
    int previousIndex();
    // 删除元素
    void remove();
    void set(E e);
    // 添加元素
    void add(E e);
}

　　在ArrayList类中，对上述接口的实现。

public ListIterator<E> listIterator() {
    return new ListItr(0);
}

// 一个内部类
private class ListItr extends Itr implements ListIterator<E> {
    // 进行游标初始化.默认是 0 
    ListItr(int index) {
        super();
        cursor = index;
    }
    // 是否有上一个元素
    public boolean hasPrevious() {
        return cursor != 0;
    }
    // 返回下一个元素的索引
    public int nextIndex() {
        return cursor;
    }
    // 返回上一个元素的索引
    public int previousIndex() {
        return cursor - 1;
    }

    @SuppressWarnings("unchecked")
    public E previous() {
        // 迭代器进行元素迭代时同时进行增加和删除操作，会抛出异常
        checkForComodification();
        int i = cursor - 1;
        if (i < 0)
            throw new NoSuchElementException();
        Object[] elementData = ArrayList.this.elementData;
        if (i >= elementData.length)
            throw new ConcurrentModificationException();
        // 游标指向上一个元素
        cursor = i;
        // 返回上一个元素的值
        return (E) elementData[lastRet = i];
    }

    public void set(E e) {
        if (lastRet < 0)
            throw new IllegalStateException();
        checkForComodification();

        try {
            ArrayList.this.set(lastRet, e);
        } catch (IndexOutOfBoundsException ex) {
            throw new ConcurrentModificationException();
        }
    }

    public void add(E e) {
        checkForComodification();

        try {
            int i = cursor;
            ArrayList.this.add(i, e);
            cursor = i + 1;
            lastRet = -1;
            expectedModCount = modCount;
        } catch (IndexOutOfBoundsException ex) {
            throw new ConcurrentModificationException();
        }
    }
}

　　参考文档：https://docs.oracle.com/javase/8/docs/api/java/util/ArrayList.html#