jdk欣赏-ArrayList（1）

《深入理解java虚拟机》这本书大概看了一遍，收获很大，博客就暂时告于段落，不过学习还是继续，下一本书读《java并发编程实战》，配合之前学习的内容，应该可以串联上。

博客新开一个系列，jdk源码系列，读并发和jvm比较枯燥，jdk源码就当做调味品。

从集合类开始，最简单的ArrayList类，我们可以看到ArrayList实现了Serializable接口，并且有一个静态的long型变量serialVersionUID。Serializable接口作用就是使对象可以进行序列化和反序列化，这个接口没有任何方法需要实现。如果一个类没有实现Serializable接口，进行序列化或者反序列时会抛出异常，java.io.NotSerializableException。那么serialVersionUID的作用是什么呢？

我做一个测试，把一个类先进行序列化，写到文件中，再从文件读取反序列化，前后对这个类做一下修改。

情景一：都没有显示的serialVersionUID，是否可以互相序列化与反序列化。

情景二：前后两次类的serialVersionUID不相同，是否可以互相序列化与反序列化。

情景三：前后两次类serialVersionUID相同，但是成员变量不一样，是否可以序列化与反序列化。

经过测试：

情景一可以进行序列化与反序列化。

情景二会抛出异常java.io.InvalidClassException:  local class incompatible: stream classdesc serialVersionUID = 1, local class serialVersionUID = 111。

情景三可以正常进行序列化与反序列化，但是只会反序列化能对应上的成员变量，无法对应的将被忽略。

继续看ArrayList，是一个可以自动扩容的数组，可以保存null，增加、删除、查找时间复杂度都是O(1)；

首先第一个成员变量：

private static final int DEFAULT_CAPACITY = 10;

默认数据的大小，在无参构造函数的时候，第一次添加对象的时候初始化数组大小为10；

接下来是两个相近的成员变量：

private static final Object[] EMPTY_ELEMENTDATA = {};

private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

两个成员变量都是在创建时，用来表示空数组的。EMPTY_ELEMENTDATA 是在有参构造函数时使用，DEFAULTCAPACITY_EMPTY_ELEMENTDATA 是在无参构造函数时使用，目的是为了在第一次添加数据时，是否要初始化数据大小为默认值。具体可以看add方法中：

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

可以看到ensureCapacityInternal()中：

private void ensureCapacityInternal(int minCapacity) {
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
        }

        ensureExplicitCapacity(minCapacity);
    }

可以看到如果数据是DEFAULTCAPACITY_EMPTY_ELEMENTDATA，会初始化数组大小为默认大小即10和最小容量的最大值。也就是说，如果是无参构造函数，增加对象时最小会初始化数组大小为10。如果是有参数的构造函数，会按照需求来初始化大小。

下一个成员变量就是实际保存数据的数组：

transient Object[] elementData;

最后一个成员变量就是大小：

private int size；

构造函数有三个：

无参构造函数，可以看到初始化的数组为DEFAULTCAPACITY_EMPTY_ELEMENTDATA：

public ArrayList() {
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }

带参数的两个构造函数：

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(Collection<? extends E> c) {
        elementData = c.toArray();
        if ((size = elementData.length) != 0) {
            // c.toArray might (incorrectly) not return Object[] (see 6260652)
            if (elementData.getClass() != Object[].class)
                elementData = Arrays.copyOf(elementData, size, Object[].class);
        } else {
            // replace with empty array.
            this.elementData = EMPTY_ELEMENTDATA;
        }
    }

接下来看比较关键的方法：

首先是如何添加一个元素：

最简单的就是在最后一位添加一个元素，首先要先判断是否需要扩容，在最后一个增加元素，并且size加一。

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

还可以在指定位置添加元素，首先判断指定的位置是否越界，然后在判断是否需要扩容，再把原数据在index位置后的所有数据向后挪移一位，在index处增加待新增的元素，并且size加一：

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

还可以直接添加一个集合：

public boolean addAll(Collection<? extends E> c) {
        Object[] a = c.toArray();
        int numNew = a.length;
        ensureCapacityInternal(size + numNew);  // Increments modCount
        System.arraycopy(a, 0, elementData, size, numNew);
        size += numNew;
        return numNew != 0;
    }

public boolean addAll(int index, Collection<? extends E> c) {
        rangeCheckForAdd(index);

        Object[] a = c.toArray();
        int numNew = a.length;
        ensureCapacityInternal(size + numNew);  // Increments modCount

        int numMoved = size - index;
        if (numMoved > 0)
            System.arraycopy(elementData, index, elementData, index + numNew,
                             numMoved);

        System.arraycopy(a, 0, elementData, index, numNew);
        size += numNew;
        return numNew != 0;
    }

其时最关键的就是扩容方法，首先是判断是否是无参构造函数新创建的对象，如果是那么扩容的大小为默认大小；再判断是否需要扩容，进行扩容：

private void ensureCapacityInternal(int minCapacity) {
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
        }

        ensureExplicitCapacity(minCapacity);
    }

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

        // overflow-conscious code
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }

扩容的方法比较简单，首先是增加1.5倍，然后判断是否达到最小容量要求，否则就设置大小为需求的最小的容量。如果大小超过了默认的最大数组长度Integer.MAX_VALUE - 8，则设置为 Integer.MAX_VALUE大小，

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

查找的方法，分为null和非null两种情况，都是从头遍历数组：

public int indexOf(Object o) {
        if (o == null) {
            for (int i = 0; i < size; i++)
                if (elementData[i]==null)
                    return i;
        } else {
            for (int i = 0; i < size; i++)
                if (o.equals(elementData[i]))
                    return i;
        }
        return -1;
    }

还有一个从后遍历查找的方法：

public int lastIndexOf(Object o) {
        if (o == null) {
            for (int i = size-1; i >= 0; i--)
                if (elementData[i]==null)
                    return i;
        } else {
            for (int i = size-1; i >= 0; i--)
                if (o.equals(elementData[i]))
                    return i;
        }
        return -1;
    }

第一个是返回数组中第一个匹配的位置，第二个是返回数据中最后一个匹配的位置。

其余的还有set(int index, E element)替换指定位置的数据；

remove(int index)删除指定位置的数据，并把其后的数据向前移动一位；

remove(Object o)删除第一个出现的元素，并把其后数据向前移动一位；

等等很多方法，其中还有一个比较关键的就是迭代器，一般jdk中的集合类都会实现迭代器模式，方便遍历内容。

ArrayList中有两种迭代器，Itr和ListIterator。Itr实现了Iterator接口，并且Itr是ListIterator的父类。

基本的迭代器有hasNext()，next()，remove()，以及jkd1.8中新增加的forEachRemaining(Consumer<? super E> action)。

主要看next()方法中，首先进行了一个判断：

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

这也就说明了，为什么在进行遍历时删除数据，一定要通过迭代器的remove方法，而不能通过ArrayList自带的方法删除。

根本因为是因为ArrayList方法删除数据时，会把其后数据向前移动，导致遍历到重复的数据，甚至会有数组越界的可能。

而迭代器中的remove方法如下：

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

            try {
                AbstractList.this.remove(lastRet);
                if (lastRet < cursor)
                    cursor--;
                lastRet = -1;
                expectedModCount = modCount;
            } catch (IndexOutOfBoundsException e) {
                throw new ConcurrentModificationException();
            }
        }

其会先调用ArrayList本身的remove方法后，把当前迭代的游标减一，并重新设置expectedModCount保证下次迭代不会抛出异常，并且设置lastRet为-1，使得remove方法不能连续调用。

未完待续......