ArrayList 源码分析

ArrayList 源码分析

版本：JDK 1.8

        ArrayList list = new ArrayList(5);

        list.add('a');
        list.add('b');
        list.add('c');
        list.add('d');
        list.add('e');
        list.add('f');
        list.add('g');

Debug

继承关系如下：

// 默认初始容量为 10（当ArrayList的容量低于9时才会用到）
private static final int DEFAULT_CAPACITY = 10;
// 存放数据的数组，数组的每个位置并不一定都填充数据，用transient修饰避免序列化、避免浪费资源
transient Object[] elementData;
// 记录实际存放的元素个数
private int size;
// 记录着ArrayList的修改次数,也就每次add或remove，它的值都会加1
protected transient int modCount = 0;

1、 构造函数 初始化

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

2、添加数据

public boolean add(E e) {
    // modCount++，并且校验容量，不够用就扩容
    ensureCapacityInternal(size + 1);  // 增加 modCount
    // 将新元素添加到新数组size位置，并将size加1（千万不要理解成将新元素添加到size+1的位置）
    elementData[size++] = e;
    return true;
}

// 确保容量够用
private void ensureCapacityInternal(int minCapacity) {
    if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
        minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
    }

    ensureExplicitCapacity(minCapacity);
}

private void ensureExplicitCapacity(int minCapacity) {
    modCount++;
    
    // 下标溢出表示容量不够用
    if (minCapacity - elementData.length > 0)
    	
    	//不够用扩容
        grow(minCapacity);
}

ArrayList 扩容方法 grow(int minCapacity)

private void grow(int minCapacity) {
    // oldCapaticy表示当前长度
    int oldCapacity = elementData.length;
    
    // ArrayList 的扩容是 1.5 倍 或 1.5 倍 - 1
    // oldCapacity为偶数按1.5倍扩容，oldCapacity为奇数按1.5倍-1扩容
    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);
}

删除元素

public boolean remove(Object o)

如果添加的是 list.remove(“a”) 或者 list.remove(‘a’) 有什么区别呢？

如果添加的为'a'为字符串，需要进行转换为Character。由Debug可知，也就相当于 new Character© 与 “a”，一个在堆中，一个地址在常量池中，地址不同

如果删除list.remove(‘a’) ，为什么不能成功？

删除时地址是用o.equals(elementData[index])进行比较，地址不一样，则无法删除。

public boolean remove(Object o) {
    // 两种情况，被删除的元素是否为 null
    // for 循环遍历、判断、删除（请注意：千万不要使用 foreach 进行删除！！！）
    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;
            }
    }
    // 如果删除了，返回为true，否则返回false。
    return false;
}

/*
 * Private remove method that skips bounds checking and does not
 * return the value removed.
 * 跳过边界检查的私有移除方法，并且不返回删除的值
 */
private void fastRemove(int index) {
    modCount++;
    int numMoved = size - index - 1;
    if (numMoved > 0)
        // 重点在这里，数据向前移动
        System.arraycopy(elementData, index+1, elementData, index,
                         numMoved);
    // 清除 size-1 位置上的元素（设置空引用），让GC去收集该元素，同时 size 减 1
    elementData[--size] = null; 
}

💣💣💣注意:

1. 如果存在多个对象o,仅仅删除距离 index = 0 处最近的一个元素;
2. 元素被删除后，该位置不会空出来，后面的元素会前移。

所以 ArrayList 适合读多删少场景。

3、重新设置指定index位置的元素值public E set(int index, E element)

public E set(int index, E element) {
    // 有index，必检查
    rangeCheck(index);
    // 返回旧的（被重置的）元素
    E oldValue = elementData(index);
    // 直接把 index位置的元素覆盖掉行了
    elementData[index] = element;
    return oldValue;
}

4、获取指定index位置的元素 public E get(int index)

public E get(int index) {
   // 还是那句话，凡是遇到index索引，必检查
    rangeCheck(index);
    // 直接返回index的元素，数组查询还不快吗。
    return elementData(index);
}

E elementData(int index) {
    // 因为 ArrayList 本质上是个数组，直接通过index获取元素
    return (E) elementData[index];
}

5、判断元素是否存储 public boolean contains(Object o) 判断是否存在某个元素

public boolean contains(Object o) {
    // 简单粗暴，直接遍历查看index是否大于0
    return indexOf(o) >= 0;
}

// 查找元素是否存在，如果存在返回下标，否则返回 -1
public int indexOf(Object o) {
    // 遍历的时候分两种情况，是否为 null
    if (o == null) {
        for (int i = 0; i < size; i++)
            if (elementData[i]==null)
                return i;
    } else {
        for (int i = 0; i < size; i++)
            // 用 equals 判断值是否相等
            if (o.equals(elementData[i]))
                return i;
    }
    return -1;
}
a[i]==null)
                return i;
    } else {
        for (int i = 0; i < size; i++)
            // 用 equals 判断值是否相等
            if (o.equals(elementData[i]))
                return i;
    }
    return -1;
}