源码分析之ArrayList

ArrayList 是我们常用的集合类,是基于数组实现的。不同于数组的是 ArrayList 可以动态扩容。

类结构

ArrayListJava 集合框架 List 接口的一个实现类。提供了一些操作数组元素的方法。

实现 List 接口同时,也实现了 RandomAccess , Cloneable , java.io.Serializable

ArrayList 继承与 AbstractList

类成员

elementData

transient Object[] elementData;

elementData 是用于保存数据的数组,是 ArrayList 类的基础。

elementData 是被关键字 transient 修饰的。我们知道被 transient 修饰的变量,是不会参与对象序列化和发序列化操作的。而我们知道 ArrayList 实现了 java.io.Serializable ,这就表明 ArrayList 是可序列化的类,这里貌似出现了矛盾。

ArrayList 在序列化和反序列化的过程中,有两个值得关注的方法: writeObjectreadObject

privatevoidwriteObject(java.io.ObjectOutputStream s)
    throws java.io.IOException{
    // Write out element count, and any hidden stuff
    int expectedModCount = modCount;
    s.defaultWriteObject();

    // Write out size as capacity for behavioural compatibility with clone()
    s.writeInt(size);

    // Write out all elements in the proper order.
    for (int i=0; i<size; i++) {
        s.writeObject(elementData[i]);
    }

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

privatevoidreadObject(java.io.ObjectInputStream s)
    throws java.io.IOException, ClassNotFoundException {
    elementData = EMPTY_ELEMENTDATA;

    // Read in size, and any hidden stuff
    s.defaultReadObject();

    // Read in capacity
    s.readInt(); // ignored

    if (size > 0) {
        // be like clone(), allocate array based upon size not capacity
        ensureCapacityInternal(size);

        Object[] a = elementData;
        // Read in all elements in the proper order.
        for (int i=0; i<size; i++) {
            a[i] = s.readObject();
        }
    }
}

writeObject 会将 ArrayList 中的 sizeelement 数据写入 ObjectOutputStreamreadObject 会从 ObjectInputStream 读取 sizeelement 数据。

之所以采用这种序列化方式,是出于性能的考量。因为 ArrayListelementData 数组在 add 元素的过程,容量不够时会动态扩容,这就到可能会有空间没有存储元素。采用上述序列化方式,可以保证只序列化有实际值的数组元素,从而节约时间和空间。

size

private int size;

sizeArrayList 的大小。

DEFAULT_CAPACITY

/**
 * Default initial capacity.
 */
private static final int DEFAULT_CAPACITY = 10;

ArrayList 默认容量是10。

构造函数

ArrayList 提供了2个构造函数 ArrayList(int initialCapacity)ArrayList()

使用有参构造函数初始化 ArrayList 需要指定初始容量大小,否则采用默认值10。

add()方法

publicbooleanadd(E e){
    ensureCapacityInternal(size + 1);  // Increments modCount!!
    elementData[size++] = e;
    return true;
}

add 元素之前,会调用 ensureCapacityInternal 方法,来判断当前数组是否需要扩容。

privatevoidensureCapacityInternal(intminCapacity){
    if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
        // 如果elementData为空数组,指定elementData最少需要多少容量。
        // 如果初次add,将取默认值10;
        minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
    }
    ensureExplicitCapacity(minCapacity);
}

privatevoidensureExplicitCapacity(intminCapacity){
    modCount++;

    // overflow-conscious code
    // elementData容量不足的情况下进行扩容
    if (minCapacity - elementData.length > 0)
        grow(minCapacity);
}

privatevoidgrow(intminCapacity){
    // overflow-conscious code
    int oldCapacity = elementData.length;
    int newCapacity = oldCapacity + (oldCapacity >> 1);
    if (newCapacity - minCapacity < 0)
        newCapacity = minCapacity;
    if (newCapacity - MAX_ARRAY_SIZE > 0)
        newCapacity = hugeCapacity(minCapacity);
    // minCapacity is usually close to size, so this is a win:
    elementData = Arrays.copyOf(elementData, newCapacity);
}
  • grow 方法中可以看出, ArrayListelementData 数组如遇到容量不足时,将会把新容量 newCapacity 设置为 oldCapacity + (oldCapacity >> 1) 。二进制位操作 >> 1 等同于 /2 的效果,扩容导致的 newCapacity 也就设置为原先的1.5倍。

  • 如果新的容量大于 MAX_ARRAY_SIZE 。将会调用 hugeCapacityint 的最大值赋给 newCapacity 。不过这种情况一般不会用到,很少会用到这么大的 ArrayList

在确保有容量的情况下,会将元素添加至 elementData 数组中。

add(int index, E element) 方法

publicvoidadd(intindex, E element){
    rangeCheckForAdd(index);

    ensureCapacityInternal(size + 1);  // Increments modCount!!
    System.arraycopy(elementData, index, elementData, index + 1,
                     size - index);
    elementData[index] = element;
    size++;
}

带有 indexadd 方法相对于直接 add 元素方法会略有不同。

  • 首先会调用 rangeCheckForAdd 来检查,要添加的 index 是否存在数组越界问题;
  • 同样会调用 ensureCapacityInternal 来保证容量;
  • 调用 System.arraycopy 方法复制数组,空出 elementData[index] 的位置;
  • 赋值并增加 size

remove(int index) 方法

publicEremove(intindex){
    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; // clear to let GC do its work

    return oldValue;
}

ArryList 提供了两个删除 List 元素的方法,如上所示,就是根据 index 来删除元素。

  • 检查 index 是否越界;
  • 取出原先值的,如果要删除的值不是数组最后一位,调用 System.arraycopy 方法将待删除的元素移动至 elementData 最后一位。
  • elementData 最后一位赋值为null。

remove(Object o) 方法

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

remove(Object o) 是根据元素删除的,相对来说就要麻烦一点:

  • 当元素 o 为空的时候,遍历数组删除空的元素。
  • 当元素 o 不为空的时候,遍历数组找出于 o 元素的 index ,并删除元素。
  • 如果以上两步都没有成功删除元素,返回 false

modCount

addremove 过程中,经常发现会有 modCount++ 或者 modCount-- 操作。这里来看下 modCount 是个啥玩意。

modCount 变量是在 AbstractList 中定义的。

protected transient int modCount = 0;

modCount 是一个 int 型变量,用来记录 ArrayList 结构变化的次数。

modCount 起作用的地方是在使用 iterator 的时候。 ArrayListiterator 方法。

publicIterator<E>iterator(){
    return new Itr();
}

 private classItrimplementsIterator<E>{
    int cursor;       // index of next element to return
    int lastRet = -1; // index of last element returned; -1 if no such
    int expectedModCount = modCount;

    publicbooleanhasNext(){
        return cursor != size;
    }

    @SuppressWarnings("unchecked")
    publicEnext(){
        checkForComodification();
        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];
    }

    publicvoidremove(){
        if (lastRet < 0)
            throw new IllegalStateException();
        checkForComodification();

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

    @Override
    @SuppressWarnings("unchecked")
    publicvoidforEachRemaining(Consumer<?superE> consumer){
        Objects.requireNonNull(consumer);
        final int size = ArrayList.this.size;
        int i = cursor;
        if (i >= size) {
            return;
        }
        final Object[] elementData = ArrayList.this.elementData;
        if (i >= elementData.length) {
            throw new ConcurrentModificationException();
        }
        while (i != size && modCount == expectedModCount) {
            consumer.accept((E) elementData[i++]);
        }
        // update once at end of iteration to reduce heap write traffic
        cursor = i;
        lastRet = i - 1;
        checkForComodification();
    }

    finalvoidcheckForComodification(){
        if (modCount != expectedModCount)
            throw new ConcurrentModificationException();
    }
}

iterator 方法会返回私有内部类 Itr 的一个实例。这里可以看到 Itr 类中很多方法,都会调用 checkForComodification 方法。来检查 modCount 是够等于 expectedModCount 。如果发现 modCount != expectedModCount 将会抛出 ConcurrentModificationException 异常。

这里写一个小例子来验证体会下 modCount 的作用。简单介绍一下这个小例子:准备两个线程 t1t2 ,两个线程对同一个 ArrayList 进行操作, t1 线程将循环向 ArrayList 中添加元素, t2 线程将把 ArrayList 元素读出来。

Test 类:

public classTest{

    List<String> list = new ArrayList<String>();


    publicTest(){

    }


    publicvoidadd(){

        for (int i = 0; i < 10000; i++) {
            list.add(String.valueOf(i));
        }

    }

    publicvoidread(){

        Iterator iterator = list.iterator();
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }

    }

t1 线程:

public classTest1ThreadimplementsRunnable{

    private Test test;

    publicTest1Thread(Test test){
        this.test = test;
    }

    publicvoidrun(){

        test.add();

    }

t2 线程:

public classTest2ThreadimplementsRunnable{

    private Test test;

    publicTest2Thread(Test test){
        this.test = test;
    }


    publicvoidrun(){
        test.read();
    }
}

main

publicstaticvoidmain(String[] args)throwsInterruptedException{

    Test test = new Test();
    Thread t1  = new Thread(new Test1Thread(test));
    Thread t2  = new Thread(new Test2Thread(test));

    t1.start();
    t2.start();

}

执行这个 mian 类就会发现程序将抛出一个 ConcurrentModificationException 异常。

由异常可以发现抛出异常点正处于在调用 next 方法的 checkForComodification 方法出现了异常。这里也就出现上文描述的 modCount != expectedModCount 的情况,原因是 t2 线程在读数据的时候, t1 线程还在不断的添加元素。

这里 modCount 的作用也就显而易见了,用 modCount 来规避多线程中并发的问题。由此也可以看出 ArrayList 是非线程安全的类。

我来评几句
登录后评论

已发表评论数()

相关站点

热门文章