JDK 1.8 ArrayList类源码阅读记录

JDK 1.8 ArrayList类源码阅读记录

一、简介

1. permits all elements, including null ,ArrayList可以加入null,并且多个
2. ArrayList是由数组来实现数据存储的
3. ArrayList 基本等同于Vector,除了ArrayList是线程不安全(执行效率高）看源码.,在多线程情况下，不建议使用ArrayList
4. size 、 isEmpty 、 get 、 set 、 iterator和listIterator操作在恒定时间内运行。
5. ArrayList类的iterator和listIterator方法返回的iterator是快速失败的：如果在创建迭代器后的任何时间以任何方式修改了列表的结构，除了通过迭代器自己的remove或add方法（listIterator），迭代器将抛出ConcurrentModificationException 。
   请注意，无法保证迭代器的快速抛出异常，因为一般，在存在非同步并发修改的情况下不可能做出任何硬保证。 编写一个依赖此异常来确保其正确性的程序是错误的，迭代器的快速失败行为应该仅用于检测错误。
6. iterator 只能向后遍历，不能向前遍历，能够删除元素，但是不能新增元素。
7. listIterator 多出了能向前迭代，以及新增元素的功能。

二、属性

//序列化UID，由于ArrayList实现了Serializable接口，所以添加了一个方便于序列化和反序列化的UID。
private static final long serialVersionUID = 8683452581122892189L;
//默认容量10
private static final int DEFAULT_CAPACITY = 10;
//一个空数组
private static final Object[] EMPTY_ELEMENTDATA = {};
//默认的空数组。
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
//真正存储元素的数组，transient修饰的变量不可以被序列化和反序列化。
transient Object[] elementData;
//当前存储元素的个数
private int size;

三、构造方法

无参构造
public ArrayList() {
		//将默认空数组赋值给真正存储元素的数组
    this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}
传入参数为集合长度
public ArrayList(int initialCapacity) {
    //如果长度大于0，则创建一个对应大小的数组赋给存储数组
    if (initialCapacity > 0) {
        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();
		//如果数组长度不等于0，进入if
    if ((size = elementData.length) != 0) {
        //如果c.toArray()返回的不是Object[]，则使用Arrays.copy方法将集合c中的元素传到数组中
        if (elementData.getClass() != Object[].class)
            elementData = Arrays.copyOf(elementData, size, Object[].class);
    } else {
        //如果个数为0，就令空数组为存储数组
        this.elementData = EMPTY_ELEMENTDATA;
    }
ss}

四、ArrayList扩容机制

1. ArrayList中维护了一个Object类型的数组elementData. transient Object[] elementData;
transient表示瞬间、短暂，被transient修饰表示该属性不能被序列化。
2. 当创建ArrayList对象时，如果使用的是无参构造器，则初始elementData容量为0，第1
   次添加，则扩容elementData为10，如需要再次扩容，则扩容elementData为1.5倍。
3. 如果使用的是指定大小的构造器，则初始elementData容量为指定大小，如果需要扩容,则直接扩容elementData为1.5倍。

Excplicit 精确的

五、方法

5.1 增

add(E e)

public boolean add(E e) {
    ensureCapacityInternal(size + 1);//先确定是否要扩容
    elementData[size++] = e;//再赋值
    return true;
}

ensureCapacityInternal()用来确定minCapacity（最小容量），第一次执行完后后minCapacity为10
private void ensureCapacityInternal(int minCapacity) {
		//判断存储数组为默认数组，才能将minCapacity变为默认容量（DEFAULT_CAPACITY）与最小容量中的较大值
    if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
        minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
    }
    ensureExplicitCapacity(minCapacity);
}

ensureExplicitCapacity()判断是否要扩容
private void ensureExplicitCapacity(int minCapacity) {
    modCount++;
//记录集合被修改次数，为了保证线程安全，再次遍历集合时如果发现modCount与之前不同，
//则说明其他线程中对集合有过修改

    // 如果最小**需要的容量**大于现有的elementData的长度，大小不够,就调用grow()去扩容
    if (minCapacity - elementData.length > 0)
        grow(minCapacity);
}

扩容
minCapacity是最小所需容量；oldCapacity是当前的容量；newCapacity是扩容1.5倍后的容量。
private void grow(int minCapacity) {
    int oldCapacity = elementData.length;
    int newCapacity = oldCapacity + (oldCapacity >> 1);
//如果扩容后容量小于最小所需容量，则直接使用最小所需容量
    if (newCapacity - minCapacity < 0)
        newCapacity = minCapacity;
//如果扩容长度大于数组最大的长度，就调用hugeCapacity(minCapacity)方法确定数组长度。
    if (newCapacity - MAX_ARRAY_SIZE > 0)
        newCapacity = hugeCapacity(minCapacity);
    elementData = Arrays.copyOf(elementData, newCapacity);
}

扩容使用的是Arrays.copyof()，是为了在保存原先数据的基础上复制到新数组进行扩容。

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

如果所需最小容量minCapacity大于最大容量，则新容量则为Integer.MAX_VALUE，否则，新容量大小则为 MAX_ARRAY_SIZE 即为 Integer.MAX_VALUE - 8。

add(int index, E element)

public void add(int index, E element) {
    if (index > size || index < 0)//检查是否越界
        throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
    ensureCapacityInternal(size + 1); //确定最小容量，判断是否**扩容**
//arraycopy(原数组，源数组中的起始位置，目标数组，目标数据中的起始位置，要复制的数组元素的数量)
    System.arraycopy(elementData, index, elementData, index + 1,size - index);
    elementData[index] = element;//将添加元素置于index处
    size++;
}

addAll（Collection<? extends E> c）

public boolean addAll(Collection<? extends E> c) {
    Object[] a = c.toArray();//将传入的集合转换为数组
    int numNew = a.length;
    //根据传入集合长度和已有数组长度确定最小需要长度，判断是否需要扩容。
		ensureCapacityInternal(size + numNew);
//arraycopy(原数组，源数组中的起始位置，目标数组，目标数据中的起始位置，要复制的数组元素的数量)
//将新数组的内容从size开始全部添加到elementData数组中
    System.arraycopy(a, 0, elementData, size, numNew);
//更新size
    size += numNew;
    return numNew != 0;
}

addAll(int index, Collection<? extends E> c)

public boolean addAll(int index, Collection<? extends E> c) {
    if (index > size || index < 0)//判断越界
        throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
    Object[] a = c.toArray();//将传入的集合转换为数组
    int numNew = a.length;
		//根据传入集合长度和已有数组长度确定最小需要长度，判断是否需要扩容。
    ensureCapacityInternal(size + numNew);  // Increments modCount
		//将原数组从index开始向后移动
    int numMoved = size - index;
    if (numMoved > 0)
        System.arraycopy(elementData, index, elementData, index + numNew,numMoved);
		//将新数组的内容从index开始全部添加到elementData数组中
    System.arraycopy(a, 0, elementData, index, numNew);
		//更新size
    size += numNew;
    return numNew != 0;
}

小结

• 如果是无参构造，add()第一次执行完grow()，newCapacity 赋值为10。第二次及其以后，按照1.5倍扩容。
• 如果是有参数的构造器,第一次扩容就按照elementData的1.5倍扩容，之后执行流程和无参一样。因为在grow()中，elementData.length也就是oldCapacity不是0，newCapacity - minCapacity 就大于等于 0，就不执行newCapacity = minCapacity;，直接扩1.5。
• 无论是add还是addAll都要先判断越界，然后判断是否需要扩容，最后移动。
• 如果需要扩容，默认扩容为原来的1.5倍；如果还不够，那就直接将目标size作为扩容后的大小

5.2 删

remove(int index)

public E remove(int index) {
    if (index >= size)
        throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
		//第一步：修改集合结构和长度，要先修改modCount
    modCount++;
    //第二步：获取处于index处的元素
    E oldValue = (E) elementData[index];
		//第三步：利用numMoved判断删除的元素是否是**最后一个元素**，如果不是，则要将index后面的元素往前移动
    int numMoved = size - index - 1;
    if (numMoved > 0)
//arraycopy(原数组，源数组中的起始位置，目标数组，目标数据中的起始位置，要复制的数组元素的数量)
        System.arraycopy(elementData, index+1, elementData, index,numMoved);
    //第四步：将最末尾元素置null
    elementData[--size] = null;
    return oldValue;
}

remove(Object o)

public boolean remove(Object o) {
    if (o == null) {
				//第一步：查找元素如果是null，用==从头到尾遍历null。
        for (int index = 0; index < size; index++)
            if (elementData[index] == null) {
                fastRemove(index);
                return true;
            }
    } else {
				//如果不是null，用equals从头到尾遍历。
        for (int index = 0; index < size; index++)
            if (o.equals(elementData[index])) {
                fastRemove(index);
                return true;
            }
    }
    return false;
}

删除操作是调用的fastRemove(index)方法：

private void fastRemove(int index) {
//第一步：修改集合结构和长度，要先修改modCount
    modCount++;
    int numMoved = size - index - 1;
//第二步：利用numMoved来判断删除的元素是否是最后一个元素，如果不是，则要将index后面的元素往前移动
    if (numMoved > 0)
        System.arraycopy(elementData, index+1, elementData, index,numMoved);
//第三步：将最末尾元素置null
    elementData[--size] = null; // clear to let GC do its work
}

removeAll(Collection<?> c)

删除集合中所有与参数相同的数据。

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

private boolean batchRemove(Collection<?> c, boolean complement) {
    final Object[] elementData = this.elementData;
    int r = 0, w = 0;
    boolean modified = false;
    try {
        //第一步：将两个集合中不重复的数据放到前面
//遍历自己的elementData，如果集合中包含就给赋值到数组前面，双指针法在一个数组中
        for (; r < size; r++)
            if (c.contains(elementData[r]) == complement)
                elementData[w++] = elementData[r];
    } finally {
        //第二步：将后面的元素全部置空
//如果
        if (r != size) {
//arraycopy(原数组，源数组中的起始位置，目标数组，目标数据中的起始位置，要复制的数组元素的数量)
            System.arraycopy(elementData, r,elementData, w,size - r);
//为什么要这样不懂了。
            w += size - r;
        }
        if (w != size) {
//不重复的元素全置空
            // clear to let GC do its work
            for (int i = w; i < size; i++)
                elementData[i] = null;
	          modCount += size - w;//置空一个元素就加一次
            size = w;
            modified = true;
        }
    }
    return modified;
}

clear()

public void clear() {
    modCount++;
    // 直接遍历每一位，然后把每一位都置空，让GC清理
    for (int i = 0; i < size; i++)
        elementData[i] = null;
    size = 0;
}

小结

正常的数组删除操作，就是判断是不是末尾，如果是赋值为null，如果不是，就将数组后面的内容全部往前移1位，然后把最后面赋值为null。所有的删除操作都会修改modCount。

5.3 改

不修改modCount

public E set(int index, E element) {
    //第一步：越界判断
    if (index >= size)
        throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
    //第二步：赋值原元素
    E oldValue = (E) elementData[index];
    //第三步：更改元素
    elementData[index] = element;
    return oldValue;
}

5.4 查

get(int index)

不需要更改modCount

public E get(int index) {
    if (index >= size)
        throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
    return (E) elementData[index];
}

contains()

public boolean contains(Object o) {
    return indexOf(o) >= 0;
}
public int indexOf(Object o) {
    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;
    }
//没有则返回-1到contains方法中，然后contains方法返回false。
    return -1;
}

isEmpty()

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

trimToSize()

public void trimToSize() {
    //第一步：修改modCount
    modCount++;
    //第二步：如果size为0，则直接赋值空数组EMPTY_ELEMENTDATA，否则调用Arrays.copyOf方法复制
    if (size < elementData.length) {
        elementData = (size == 0)? EMPTY_ELEMENTDATA : Arrays.copyOf(elementData, size);
    }
}

六、总结

6.1 ArrayList频顿繁扩容导致添加性能急剧下降，如何处理?

使用有参构造函数，减少扩容次数，不用频繁扩容。

6.2 ArrayList的扩容因子为什么是1.5？

k = 2, capacity = 4
0123
    01234567
            0123456789101112131415
                                  012345678910111213141516171819202122232425262728293031
                                                                                        0123...

k = 1.5, capacity = 4
0123
    012345
          012345678
                <--(0123456789101112)
0123456789101112
                ...

k=1.5时，就能充分利用前面已经释放的空间。如果k >= 2，新容量刚刚好永远大于过去所有废弃的数组容量。

6.3 为什么不取扩容固定容量呢？

• 扩容容量不能太小，防止频繁扩容、频繁申请内存空间 和 数组频繁复制
• 扩容容量不能太大，需要充分利用空间，避免浪费过多空间；
• 如果扩容固定容量，取任何具体值都不太合适，因为所需数据量往往由数组的客户端在具体应用场景决定。依赖于当前已经使用的量 * 系数， 更符合实际应用场景。比如，我现在已经用到一个数组100的容量，接下来很可能会有这个数量级的数据需要插入。

6.4 为什么是1.5，而不是1.2，1.25，1.8或者1.75？

因为1.5 （旧容量加上旧容量右移一位）可以充分利用移位操作，减少浮点数或者运算时间和运算次数。

6.5 为什么数组长度的最大值MAX_ARRAY_size是Integer.MAX_VALUE - 8

数组作为一个对象，需要8bytes的存储大小存储数组的长度等头信息，对象头信息最大占用内存不可超过8字节。

6.6 modCount是什么

用到modCount的地方，比如ArrayList、hashMap、LinkedList等等，他们都是线程不安全的，所以只要是修改了结构的地方，就会将modCount++，然后再遍历时就会去判断当前的modCount是否相等，如果不相等则证明此线程在遍历时有其他线程对集合发生了修改。

6.7 Fial-Fast机制

我们都知道这些集合是线程不安全的，如果在使用迭代器的过程中，有其他线程对集合进行了修改，那么就会抛出ConcurrentModificationException异常，这就是Fail-Fast策略。而这个时候源码中就通过modCount进行了操作。迭代器在创建时，会创建一个变量等于当时的modCount，如果在迭代过程中，集合发生了变化，modCount就是++。这时迭代器中的变量的值和modCount不相等了，那就抛异常。所以，遍历线程不安全的集合时，尽量使用迭代器

6.8 如何实现线程安全的ArrayList

1. 所有涉及到改变 modCount 值得地方全部加上 synchronized
2. 直接使用 Collections.synchronizedList(new ArrayList)
3. 使用 Vector
4. 使用 CopyOnWriteArrayList替换ArrayList

6.9 ArrayList和Vector的区别

• ArrayList线程不安全，Vector线程安全。都允许值为null。
• 默认大小都是10
• 扩容的时候ArrayList默认扩容原大小的1.5倍，Vector默认扩容原大小的2倍(可自定义)。

6.10 ArrayList和LinkedList的区别

• 都允许空值。
• ArrayList是数组实现的，有扩容操作。LinkedList是链表实现，双向链表。
• LinkedList同时还支持堆栈、队列的API，所以也可以把它当做堆栈、队列使用。
• ArrayList的遍历就是简单的从0开始遍历，而LinkedList他会判断当前的值是前半部分还是后半部分，对应的就从头还是尾开始遍历。

6.11 ArrayList插入或删除与LinkedList比较

• ArrayList 的get/set速度一流，无论查询的是哪个位置的元素。
• ArrayList 除了尾部插入的性能较好外（位置越靠后性能越好），其他位置性比较慢。
• LinkedList 在头尾查找、插入都很快的，但是在中间位置进行操作比较慢，而且比 ArrayList慢很多。