技术Java 杂谈Android知识

源码分析之ArrayList

2017-04-12  本文已影响592人  特立独行的猪手

概念

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

类结构

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

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

ArrayList继承与AbstractList

ArrayList类图ArrayList类图

类成员

elementData

   transient Object[] elementData;

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

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

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


    private void writeObject(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();
        }
    }
    
    private void readObject(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()方法

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

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

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

    private void ensureExplicitCapacity(int minCapacity) {
        modCount++;

        // overflow-conscious code
        // elementData容量不足的情况下进行扩容
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }
    
    private void grow(int minCapacity) {
        // 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);
    }

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

add(int index, E element) 方法

    public void add(int index, E element) {
        rangeCheckForAdd(index);

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

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

remove(int index) 方法

    public E remove(int index) {
        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来删除元素。

remove(Object o) 方法

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

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

modCount

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

modCount变量是在AbstractList中定义的。

    protected transient int modCount = 0;

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

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

    public Iterator<E> iterator() {
        return new Itr();
    }
    
     private class Itr implements Iterator<E> {
        int cursor;       // index of next element to return
        int lastRet = -1; // index of last element returned; -1 if no such
        int expectedModCount = modCount;

        public boolean hasNext() {
            return cursor != size;
        }

        @SuppressWarnings("unchecked")
        public E next() {
            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];
        }

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

        @Override
        @SuppressWarnings("unchecked")
        public void forEachRemaining(Consumer<? super E> 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();
        }

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

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

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

Test类:

public class Test {

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


    public Test() {

    }


    public void add() {

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

    }

    public void read() {

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

    }

t1线程:

public class Test1Thread implements Runnable {

    private Test test;

    public Test1Thread(Test test) {
        this.test = test;
    }

    public void run() {

        test.add();

    }

t2线程:

public class Test2Thread implements Runnable {

    private Test test;

    public Test2Thread(Test test) {
        this.test = test;
    }


    public void run() {
        test.read();
    }
}

main

    public static void main(String[] args) throws InterruptedException {

        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是非线程安全的类。

上一篇下一篇

猜你喜欢

热点阅读