Java集合——ArrayList源码浅析

一、继承关系

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

继承自AbstractList父类：可以从父类中拿到一些通用方法，使代码更简洁
List接口：可以存储重复性数据，数据可以为null，插入有序
RandomAccess接口：用来快速随机存取，可以提高效率
Cloneable接口：可以使用Object.clone()方法即克隆
Serializable接口：可以被序列化，简单的说就是可以将对象存储在磁盘中

二、属性及默认值

//版本号
private static final long serialVersionUID = 8683452581122892189L;
//默认容量大小为10
private static final int DEFAULT_CAPACITY = 10;
//空数组
private static final Object[] EMPTY_ELEMENTDATA = {};
//底层数据结构为数组
private transient Object[] elementData;
//有效个数
private int size;

三、构造方法

1.无参构造

public ArrayList() {
        super();//调用父类中的无参构造方法，父类中是空的构造方法
        
        //此时数组未初始化，在add方法中进行初始化
        this.elementData = EMPTY_ELEMENTDATA;
    }

2.有参构造一

public ArrayList(int initialCapacity) {//给定数组容量
        super();//父类中空的构造方法
        if (initialCapacity < 0)//检查参数合法性，若小于0则抛出异常
            throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
                                               
        //初始化elementData为自定义大小
        this.elementData = new Object[initialCapacity];
    }

3.有参构造二（不常用，这里不过多讲解）

public ArrayList(Collection<? extends E> c) {
        elementData = c.toArray();
        size = elementData.length;
        if (elementData.getClass() != Object[].class)
            elementData = Arrays.copyOf(elementData, size, Object[].class);
    }

四、基本方法（CRUD）

1.增加

public boolean add(E e) {
        ensureCapacityInternal(size + 1);//判断容量
        elementData[size++] = e;//添加元素且size+1
        return true;
    }

add()
判断ArrayList容量是否足够，不够则扩容，按照原来的数组长度（element.length）的1.5倍扩容，之后进行数据添加。

private void ensureCapacityInternal(int minCapacity) {
        if (elementData == EMPTY_ELEMENTDATA) {
        
        	//若是无参构造，初始化数组容量大小为10
            minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
        }
        ensureExplicitCapacity(minCapacity);
    }

ensureCapacityInternal()
若是无参构造，将数组进行初始化，大小为10。

private void ensureExplicitCapacity(int minCapacity) {
        modCount++;
        if (minCapacity - elementData.length > 0)//容量不够
            grow(minCapacity);//扩容
    }

ensureExplicitCapacity()
若容量不够，则需要扩容

private void grow(int minCapacity) {
        int oldCapacity = elementData.length;
        //1.5倍扩容，用移位操作可以在数组容量大时节省时间
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        if (newCapacity - minCapacity < 0)//只在初次分配10个空间时执行
            newCapacity = minCapacity;
        if (newCapacity - MAX_ARRAY_SIZE > 0)//判断有没超过最大限制
            newCapacity = hugeCapacity(minCapacity);
        //创建一个新的大小为newCapacity的数组并将原来的数据添加
        elementData = Arrays.copyOf(elementData, newCapacity);
    }

grow()
扩容操作，1.5倍扩容。

2.查找

public E get(int index) {
        rangeCheck(index);//检查传入下标的合法性
        return elementData(index);
    }

get()
首先检查index的合法性，再直接通过数组elementData下标访问获取数据。

 private void rangeCheck(int index) {
            if (index < 0 || index >= this.size)
                throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
        }

rangeCheck()
合法性检查，当0≤index<size时合法。

3.删除

public boolean remove(Object o) {
        if (o == null) {//传入元素为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])) {//注意用equals方法判等
                    fastRemove(index);//通过下标删除元素
                    return true;
                }
        }
        return false;
    }

remove()
先判断当前对象是否为null（null对象通过==来判断集合中是否存在，非null值对象通过equals来判断），之后进行数据移动，将删除元素之后的数据前移一位。

若存在重复性元素，找到第一个元素直接删除，后续的重复性元素不再处理。

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
    }

fastRemove()
将删除元素后的元素依次向前移动一位。

4.修改

public E set(int index, E element) {
        rangeCheck(index);
        E oldValue = elementData(index);
        elementData[index] = element;//重新赋值
        return oldValue;//返回原来的数据
    }