ArrayList源码解析

ArrayList源码分析

简介

ArrayList是一种以数组实现的List，与数组相比，它具有动态扩展的能力，因此又称为动态数组；在添加大量元素前，应用程序可以使用ensureCapacity操作来增加 ArrayList 实例的容量。这可以减少递增式再分配的数量。

ArrayList继承于AbstractList，实现了List，RandomAccess，Cloneable，Serializable这些接口；

1. 实现了List接口，是一个数组队列，提供了相关的添加，删除，修改，遍历等功能
2. 实现了RandomAccess接口，即提供了随机访问功能，RandmoAccess是java中用来被List实现，为List提供快速访问功能的。在ArrayList中，我们即可以通过元素的序号快速获取元素对象；这就是快速随机访问
3. 实现了Cloneable接口，能被克隆
4. 实现了Serializable接口，能通过序列化去传输

ArrayList是线程不安全的，建议在单线程中才使用ArrayList，而在多线程中可以选择CopyOnWriteArrayList

ArrayList源码

package java.util;

import java.util.function.Consumer;
import java.util.function.Predicate;
import java.util.function.UnaryOperator;
import sun.misc.SharedSecrets;

public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{
    
    private static final long serialVersionUID = 8683452581122892189L;

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

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

    // 用于默认大小空实例的共享空数组实例,从EMPTY_ELEMENTDATA数组中区分出来，以知		道		在        添加第一个元素时容量需要增加多少
    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

    // 使用transient关键字保证不被序列化，保存ArrayList数据的数组
    transient Object[] elementData; 

    // ArrayList元素个数
    private int size;

    /**
     * 带initialCapacity参数的构造函数，（可以自定义容量）
    */
    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);
        }
    }

    /**
     * 无参构造函数，初始是空数组，当添加第一个元素之后，数组的容量变成10
    */
    public ArrayList() {
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }

    /**
     * 指定集合元素的构造函数
    */
    public ArrayList(Collection<? extends E> c) {
        elementData = c.toArray();
        if ((size = elementData.length) != 0) {
            if (elementData.getClass() != Object[].class)
                elementData = Arrays.copyOf(elementData, size, Object[].class);
        } else {
            this.elementData = EMPTY_ELEMENTDATA;
        }
    }

    /**
     * 修改这个ArrayList实例的容量是列表的当前大小
    */
    public void trimToSize() {
        modCount++;
        if (size < elementData.length) {
            elementData = (size == 0) ? EMPTY_ELEMENTDATA
              : Arrays.copyOf(elementData, size);
        }
    }

    /**
     * 增加此ArrayList实例的容量，以确保它至少能容纳元素的数量
    */
    public void ensureCapacity(int minCapacity) {
        int minExpand = (elementData != DEFAULTCAPACITY_EMPTY_ELEMENTDATA)
            ? 0 : DEFAULT_CAPACITY;
        if (minCapacity > minExpand) {
            ensureExplicitCapacity(minCapacity);
        }
    }
	
    /**
     * 计算出最小扩容数量
    */
    private static int calculateCapacity(Object[] elementData, int minCapacity) 	{
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            return Math.max(DEFAULT_CAPACITY, minCapacity);
        }
        return minCapacity;
    }

    /**
     * 得到最小扩容数量
    */
    private void ensureCapacityInternal(int minCapacity) {
        ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
    }

    /**
     * 判断是否需要扩容
    */
    private void ensureExplicitCapacity(int minCapacity) {
        modCount++;
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }

    /**
     * 要分配的最大数组大小，Integer的最大值减8，也就是2147483647-8 = 2147483639
     */
    private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

    /**
    * ArrayList扩容核心方法
    */
    private void grow(int minCapacity) {
        // 把当前数组的长度大小赋值给oldCapacity
        int oldCapacity = elementData.length;
        // 新的容量 = oldCapacity + oldCapacity右移一位（除以2）的和
        // 用个人的话简单理解就是，新数组容量是老数组容量的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);
    }
	
    /**
    * 比较minCapacity和MAX_ARRAY_SIZE
    */
    private static int hugeCapacity(int minCapacity) {
        if (minCapacity < 0)
            throw new OutOfMemoryError();
        return (minCapacity > MAX_ARRAY_SIZE) ?
            Integer.MAX_VALUE : MAX_ARRAY_SIZE;
    }

    /**
    * ArrayList元素个数
    */
    public int size() {
        return size;
    }

    /**
    * 判断是否为空
    */
    public boolean isEmpty() {
        return size == 0;
    }

    /**
    * 判断ArrayList里面是否包含o这个元素
    */ 
    public boolean contains(Object o) {
        return indexOf(o) >= 0;
    }

    /**
    * 返回o这个元素首次出现对应的索引位置，如果不含有，则返回-1
    */ 
    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;
        }
        return -1;
    }

    /**
    * 返回含有o元素的最后出现对应的索引位置，如果不含有，则返回-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;
    }

    /**
    * 克隆
    */
    public Object clone() {
        try {
            ArrayList<?> v = (ArrayList<?>) super.clone();
            v.elementData = Arrays.copyOf(elementData, size);
            v.modCount = 0;
            return v;
        } catch (CloneNotSupportedException e) {
            // this shouldn't happen, since we are Cloneable
            throw new InternalError(e);
        }
    }

    /**
    * 以正确的顺序（从第一个到最后一个元素）返回一个包含此列表中所有元素的数组
    */
    public Object[] toArray() {
        return Arrays.copyOf(elementData, size);
    }
    
    /**
    * 以正确的顺序返回一个包含此列表中所有元素的数组（从第一个到最后一个元素）
    */
    @SuppressWarnings("unchecked")
    public <T> T[] toArray(T[] a) {
        if (a.length < size)
            // Make a new array of a's runtime type, but my contents:
            return (T[]) Arrays.copyOf(elementData, size, a.getClass());
        System.arraycopy(elementData, 0, a, 0, size);
        if (a.length > size)
            a[size] = null;
        return a;
    }

    /**
    * 自定义大小的elementData
    */
    @SuppressWarnings("unchecked")
    E elementData(int index) {
        return (E) elementData[index];
    }

    /**
    * 返回此列表中指定位置的元素。
    */
    public E get(int index) {
        rangeCheck(index);

        return elementData(index);
    }

    /**
    * 用指定的元素替换此列表中指定位置的元素。 
    */
    public E set(int index, E element) {
        rangeCheck(index);

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

    /**
    * 将指定的元素追加到此列表的末尾
    */
    public boolean add(E e) {
        ensureCapacityInternal(size + 1); 
        // 这里能看得到的是，ArrayList添加元素的本质，就是给指定位置的数组赋值
        elementData[size++] = e;
        return true;
    }

    /**
    * 在此列表中的指定位置插入指定的元素。 
    * 先进行界限检查；然后调用 ensureCapacityInternal方法保证capacity足够大；
    * 再将从index开始之后的所有成员后移一个位置；
    * 将element插入index位置；最后size加1；
    */
    public void add(int index, E element) {
        rangeCheckForAdd(index);
        ensureCapacityInternal(size + 1);
        System.arraycopy(elementData, index, elementData, index + 1,
                         size - index);
        elementData[index] = element;
        size++;
    }

    /**
    * 删除该列表中指定位置的元素
    */
    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;
        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 {
            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(elementData, index+1, elementData, index,
                             numMoved);
        elementData[--size] = null; // clear to let GC do its work
    }

    /**
    * 清空列表的所有元素
    */
    public void clear() {
        modCount++;

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

        size = 0;
    }

    /**
    * 把一个列表添加到当前列表的末尾
    */
    public boolean addAll(Collection<? extends E> c) {
        Object[] a = c.toArray();
        int numNew = a.length;
        ensureCapacityInternal(size + numNew);
        System.arraycopy(a, 0, elementData, size, numNew);
        size += numNew;
        return numNew != 0;
    }

    /**
    * 在指定位置添加一个列表
    */
    public boolean addAll(int index, Collection<? extends E> c) {
        rangeCheckForAdd(index);

        Object[] a = c.toArray();
        int numNew = a.length;
        ensureCapacityInternal(size + numNew);  // Increments modCount

        int numMoved = size - index;
        if (numMoved > 0)
            System.arraycopy(elementData, index, elementData, index + numNew,
                             numMoved);

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

    /**
    * 从列表中删除所有索引为fromIndex （含）和toIndex之间的元素
    */
    protected void removeRange(int fromIndex, int toIndex) {
        modCount++;
        int numMoved = size - toIndex;
        System.arraycopy(elementData, toIndex, elementData, fromIndex,
                         numMoved);
        int newSize = size - (toIndex-fromIndex);
        for (int i = newSize; i < size; i++) {
            elementData[i] = null;
        }
        size = newSize;
    }

    /**
    * 检查index是否在范围内
    */
    private void rangeCheck(int index) {
        if (index >= size)
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
    }

    /**
    * add和addAll使用的rangeCheck的一个版本
    */
    private void rangeCheckForAdd(int index) {
        if (index > size || index < 0)
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
    }

    /**
    * 返回IndexOutOfBoundsException细节信息
    */
    private String outOfBoundsMsg(int index) {
        return "Index: "+index+", Size: "+size;
    }

    /**
    * 从此列表中删除指定集合中包含的所有元素
    */
    public boolean removeAll(Collection<?> c) {
        Objects.requireNonNull(c);
        return batchRemove(c, false);
    }

    /**
    * 从此列表中删除其中不包含在指定集合中的所有元素
    */
    public boolean retainAll(Collection<?> c) {
        Objects.requireNonNull(c);
        return batchRemove(c, true);
    }

    /**
    * 批量删除
    */
    private boolean batchRemove(Collection<?> c, boolean complement) {
        final Object[] elementData = this.elementData;
        int r = 0, w = 0;
        boolean modified = false;
        try {
            for (; r < size; r++)
                if (c.contains(elementData[r]) == complement)
                    elementData[w++] = elementData[r];
        } finally {
            // Preserve behavioral compatibility with AbstractCollection,
            // even if c.contains() throws.
            if (r != size) {
                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;
    }
  
}

ArrayList扩容的核心方法

 private void grow(int minCapacity) {
       	// 把当前数组的长度大小赋值给oldCapacity
        int oldCapacity = elementData.length;
        // 新的容量 = oldCapacity + oldCapacity右移一位（除以2）的和
        // 用个人的话简单理解就是，新数组容量是老数组容量的1.5倍
        int newCapacity = oldCapacity + (oldCapacity >> 1);
     	// 检查新容量是否大于最小需要容量，若还是小于最小需要容量，那么就把最小需要容量当作数		   组的新容量
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
     	// 检查新容量是否大于最大容量的值，如果超过了，则调用hugeCapacity()来比较				   minCapacity和 MAX_ARRAY_SIZE
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
        // 数组拷贝
        elementData = Arrays.copyOf(elementData, newCapacity);
 }

ArrayList内部类

private class Itr implements Iterator<E> 

private class ListItr extends Itr implements ListIterator<E> 

private class SubList extends AbstractList<E> implements RandomAccess

static final class ArrayListSpliterator<E> implements Spliterator<E>

System.arraycopy方法和Arrays.copyOf方法

1. System.arraycopy方法

   参数	说明
   src	原数组
   srcPos	原数组的起始位置
   dest	目标数组
   destPos	目标数组的起始位置
   length	要复制的数组元素的数目

2. Arrays.copyOf方法

   参数	说明
   original	要复制的数组
   newLength	要返回的副本的长度
   newType	要返回的副本的类型

它们的联系在于：

public static <T,U> T[] copyOf(U[] original, int newLength, Class<? extends T[]> newType) {
        @SuppressWarnings("unchecked")
        T[] copy = ((Object)newType == (Object)Object[].class)
            ? (T[]) new Object[newLength]
            : (T[]) Array.newInstance(newType.getComponentType(), newLength);
        System.arraycopy(original, 0, copy, 0,
                         Math.min(original.length, newLength));
        return copy;
    }

可以看到Arrays.copyOf方法中调用了System.arraycopy方法，而System.arraycopy方法是native方法

ArrayList的优缺点

1. 优点 根据下标遍历元素效率较高； 根据下标访问元素效率较高； 在数组的基础上封装了对元素操作的方法； 自动扩容

2. 缺点 插入和删除的效率比较低； 根据内容查找元素的效率较低；

转载于:https://my.oschina.net/lsf930709/blog/3083876