源码系列1-ArrayList

• 继承关系
• 属性
• 构造函数
• 核心方法

环境: 基于jdk8

一.继承关系

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

1.继承了AbstractList, 实现了List
基于Object[]数组实现, 提供了添加、删除、修改、遍历等功能

2.实现了RandmoAccess接口
提供了随机访问功能, 使用for循环的方式获取数据会优于用迭代器获取数据

3.实现了Cloneable接口
重写函数clone(), 能被克隆

4.实现了java.io.Serializable接口
支持序列化, 能通过序列化去传输

5.ArrayList
a.可存放null
b.本质是一个数组, 查询元素很快, 而插入删除元素, 性能不高, 要移动很多元素
c.与数组区别在于能够自动扩展大小, 扩容1.5倍
d.Vector是线程安全的, ArrayList中的操作不是线程安全的
建议在单线程中才使用ArrayList, 而在多线程中可选择Vector或CopyOnWriteArrayList
e.默认容量为10, 实例化时定义容量可避免自动扩容(添加元素时才进行扩容)

二.属性

    // 默认容量和最大数组大小
    private static final int DEFAULT_CAPACITY = 10;
    private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

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

    // 元素数组
    // 用transient关键字标记的成员变量不参与序列化过程
    transient Object[] elementData;

    // 实际元素个数
    private int size;

三.构造函数

    // 无参构造函数
    public ArrayList() {
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }

    // 含自定义初始化容量的构造函数
    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);
        }
    }

    // 利用已存在的Collection创建ArrayList
    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;
        }
    }

四.核心方法
1.添加

	// 结构化修改次数, fail-fast机制
    protected transient int modCount = 0;
    
	// 直接在末尾添加元素
    public boolean add(E e) {
        // 确定内部容量, 不足进行扩容
        ensureCapacityInternal(size + 1);
        elementData[size++] = e;
        return true;
    }

    // 在特定位置添加元素
    public void add(int index, E element) {
        // 检查插入位置是否合理
        rangeCheckForAdd(index);

        // 确定内部容量, 不足进行扩容
        ensureCapacityInternal(size + 1);
        // 插入元素后, index后的元素都后移一位
        // 5个参数, 原数组, 原数组起始位置, 目标数组, 目标数组起始位置, 复制的数组长度
        System.arraycopy(elementData, index, elementData, index + 1, size - index);
        elementData[index] = element;
        size++;
    }

    // 将Collection元素从末尾添加到数组
    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;
    }

    // 将Collection元素从特定位置添加到数组
    public boolean addAll(int index, Collection<? extends E> c) {
        // 检查插入位置是否合理
        rangeCheckForAdd(index);

        Object[] a = c.toArray();
        int numNew = a.length;
        // 确定内部容量, 不足进行扩容
        ensureCapacityInternal(size + numNew);

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

2.删除

	// 删除指定位置上的元素
    public E remove(int index) {
        // 检查指定位置是否合法
        rangeCheck(index);

        modCount++;
        // 根据指定位置找到元素
        E oldValue = elementData(index);

        // 计算需要移动的位数
        int numMoved = size - index - 1;
        if(numMoved > 0) {
            // 删除元素后, index+1后的元素都前移一位
            // 5个参数, 原数组, 原数组起始位置, 目标数组, 目标数组起始位置, 复制的数组长度
            System.arraycopy(elementData, index + 1, elementData, index, numMoved);
        }
        // 让gc(垃圾回收)更快的回收
        elementData[--size] = null;
        // 返回删除元素
        return oldValue;
    }

    // 删除指定元素, ArrayList可存储null
    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;
    }

    // 清除所有元素, 将数组元素都赋值为null, 等待gc(垃圾回收)
    public void clear() {
        modCount++;

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

    // 删除所有元素
    public boolean removeAll(Collection<?> c) {
        Objects.requireNonNull(c);
        return batchRemove(c, false);
    }

    // 删除指定范围的元素
    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;
    }

3.查找

	// 获取指定下标的元素
    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 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;
    }

    // 从后向前查找数组里是否含有指定元素
    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 boolean contains(Object o) {
        return indexOf(o) >= 0;
    }

4.公共方法

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

        // 如果minCapacity大于实际elementData的长度, 进行自动扩容
        if(minCapacity - elementData.length > 0) {
            // 自动扩容
            grow(minCapacity);
        }
    }

    // 自动扩容
    private void grow(int minCapacity) {
        // 扩容前容量
        int oldCapacity = elementData.length;
        // 扩容后容量是扩容前的1.5倍
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        // 空数组时, 初始化为10
        if(newCapacity - minCapacity < 0) {
            newCapacity = minCapacity;
        }
        // 超过最大容量限制时, 赋值最大容量
        if(newCapacity - MAX_ARRAY_SIZE > 0) {
            newCapacity = hugeCapacity(minCapacity);
        }
        elementData = Arrays.copyOf(elementData, newCapacity);
    }

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

    // 检查插入位置是否合法
    private void rangeCheckForAdd(int index) {
        if(index > size || index < 0) {
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
        }
    }

    private String outOfBoundsMsg(int index) {
        return "Index: " + index + ", Size: " + size;
    }

    // 检查指定位置是否合法
    private void rangeCheck(int index) {
        if(index >= size) {
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
        }
    }

    // 快速删除
    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;
    }

    // 批量删除, 用于2个方法
    // removeAll(), complement为false, 用于删除指定集合的交集元素
    // retainAll(), complement为true, 用于检测2个集合是否有交集
    private boolean batchRemove(Collection<?> c, boolean complement) {
        final Object[] elementData = this.elementData;
        // r控制循环, w记录多少个交集
        int r = 0, w = 0;
        boolean modified = false;
        try {
            for(; r < size; r++) {
                // 检测指定集合是否含有原数组元素
                if(c.contains(elementData[r]) == complement) {
                    elementData[w++] = elementData[r];
                }
            }
        } finally {
            if(r != size) {
                System.arraycopy(elementData, r, elementData, w, size - r);
                w += size - r;
            }
            // removeAll()时, 2个集合全交时则w=0, 和clear()方法一样, 全赋值null, 返回true
            // 无交集则w=size返回false, 有交集赋值null返回true
            // retainAll()时, 2个集合全交时则w=size返回false
            // 无交集w=0, 返回true, 有交集返回true,
            // 因此不能根据返回值来确认两个集合是否有交集,
            // 而是通过原集合的大小是否发生改变来判断, 如果原集合中还有元素, 则代表有交集,
            // 而原集合没有元素了, 说明两个集合没有交集
            if(w != size) {
                for(int i = w; i < size; i++) {
                    elementData[i] = null;
                }
                modCount += size - w;
                size = w;
                modified = true;
            }
        }
        return modified;
    }

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