ArrayList源码解读

ArrayList源码解读

底层数据结构

ArrayList是在底层维护了一个elementData数组，添加了自动扩容等功能，最终形成了一个动态数组。

基本属性

// 初始化大小
private static final int DEFAULT_CAPACITY = 10;

// 初始化一个空数组
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

// 底层存放数据的数组
transient Object[] elementData;

// list的实际大小
private int size;

初始化

/**
  * 指定大小初始化
  */
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);
    }
}

/**
  * 无参数初始化，直接初始化一个空的数组
  */
public ArrayList() {
    this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}

/**
  * 指定数据初始化
  */
public ArrayList(Collection<? extends E> c) {
    // 转化成数组
    elementData = c.toArray();
    // 如果有数据，
    if ((size = elementData.length) != 0) {
        // 如果集合元素类型不是 Object 类型，我们会转成 Object
        if (elementData.getClass() != Object[].class)
            elementData = Arrays.copyOf(elementData, size, Object[].class);
    } else {
        // 如果没有数据，初始化为空数组
        this.elementData = EMPTY_ELEMENTDATA;
    }
}

add()方法

public boolean add(E e) {
    // 判断是否需要扩容
    ensureCapacityInternal(size + 1);  // Increments modCount!!
    // 赋值操作
    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);
}

private void grow(int minCapacity) {
    int oldCapacity = elementData.length;
    // 1.5倍扩容
    int newCapacity = oldCapacity + (oldCapacity >> 1);
    // 1.5倍算出来的数还是不够，就用我们期望值minCapacity
    if (newCapacity - minCapacity < 0)
        newCapacity = minCapacity;
    // 如果新容量大于jvm能分配的最大值，就去Interger的最大值
    if (newCapacity - MAX_ARRAY_SIZE > 0)
        newCapacity = hugeCapacity(minCapacity);
    // 复制数组的方式扩容
    elementData = Arrays.copyOf(elementData, newCapacity);
}

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

remove()

// 根据值删除
public boolean remove(Object o) {
    // 如果为null，删除第一个为null的元素
    if (o == null) {
        for (int index = 0; index < size; index++)
            if (elementData[index] == null) {
                fastRemove(index);
                return true;
            }
    } else {
        // 如果不为null，遍历数组，删除找到的第一个元素
        for (int index = 0; index < size; index++)
            if (o.equals(elementData[index])) {
                fastRemove(index);
                return true;
            }
    }
    return false;
}

private void fastRemove(int index) {
    // 记录list发生一次改变
    modCount++;
    // 删除index位置的元素，要从后面移动到前面的元素数量
    int numMoved = size - index - 1;
    if (numMoved > 0)
        // 将index+1开始往后的元素拷贝到index位置开始
        System.arraycopy(elementData, index+1, elementData, index,
                         numMoved);
    elementData[--size] = null; // clear to let GC do its work
}

遍历集合时候错误的删除方法

for循环遍历删除

public static void main(String[] args) {
    List array = new ArrayList();
    array.add("1");
    array.add("2");
    array.add("2");
    array.add("3");

    for (int i = 0; i < array.size(); i++) {
        if ("2".equals(array.get(i))) {
            array.remove("2");
        }
    }

    for (int i = 0; i < array.size(); i++) {
        System.out.print(array.get(i) + "---");
    }
}

// 输出：1---2---3---

这种格式不能正常删除，原因如图所示：在i = 2的时候，本来位于2位置的元素是2，但现在已经移动到了1的位置，所以删不掉

增强for循环遍历删除

public static void main(String[] args) {
    List<String> array = new ArrayList<>();
    array.add("1");
    array.add("2");
    array.add("2");
    array.add("3");

    for (String s: array) {
        if ("2".equals(s)) {
            array.remove("2");
        }
    }

    for (int i = 0; i < array.size(); i++) {
        System.out.print(array.get(i) + "---");
    }
}

------输出
Exception in thread "main" java.util.ConcurrentModificationException
	at java.util.ArrayList$Itr.checkForComodification(ArrayList.java:901)
	at java.util.ArrayList$Itr.next(ArrayList.java:851)
	at Main.main(Main.java:15)

增强for循环底层是通过Iterator实现的，当foreach通过next取下一个元素时候，首先检查checkForComodification();，发现是相等的，那么执行删除，结果在删除的时候会修改modCount，导致下一次在进来到modCount != expectedModCount这一行的时候发现不相等了，所以抛出异常throw new ConcurrentModificationException();，这种机制叫fail-fast。

// ArrayList对迭代器的实现，我们这里只粘了一部分相关的代码
private class Itr implements Iterator<E> {
    int expectedModCount = modCount; // expectedModCount的值
    
    @SuppressWarnings("unchecked")
    public E next() {
        checkForComodification(); // 检查modCount != expectedModCount
        int i = cursor;
        if (i >= size)
            throw new NoSuchElementException();
        Object[] elementData = ArrayList.this.elementData;
        if (i >= elementData.length)
            throw new ConcurrentModificationException();
        cursor = i + 1;
        return (E) elementData[lastRet = i];
    }

    public void remove() {
        if (lastRet < 0)
            throw new IllegalStateException();
        checkForComodification();

        try {
            ArrayList.this.remove(lastRet);
            cursor = lastRet;
            lastRet = -1;
            expectedModCount = modCount;
        } catch (IndexOutOfBoundsException ex) {
            throw new ConcurrentModificationException();
        }
    }

    final void checkForComodification() {
        if (modCount != expectedModCount)
            throw new ConcurrentModificationException();
    }
}

正确的删除方法

public static void main(String[] args) {
    List<String> array = new ArrayList<>();
    array.add("1");
    array.add("2");
    array.add("2");
    array.add("3");

    Iterator<String> iterator = array.iterator();
    while (iterator.hasNext()) {
        String next = iterator.next();
        if ("2".equals(next)) {
            iterator.remove();
        }
    }

    for (int i = 0; i < array.size(); i++) {
        System.out.print(array.get(i) + "---");
    }
}

通过迭代器的remove()方法删除，看上面迭代器的代码，其中删除方法中有这样一行代码expectedModCount = modCount;，对expectedModCount重新进行赋值，避免了fail-fast。