ArrayList源码分析（二）

ArrayList源码分析（二）

ArrayList源码分析（一）

link.

方法

public void trimToSize() {
        modCount++;
        if (size < elementData.length) {
            elementData = (size == 0)
              ? EMPTY_ELEMENTDATA
              : Arrays.copyOf(elementData, size);
        }
    }

注释给出 这个方法可以调整ArrayList的容量为其存储元素的大小，用户可以手动调用该方法。modCount++; 是指对ArrayList的修改次数增加
size < elementData.length，size是当前元素的个数 实际大小，elementData.length是总容量，往往比size大。

public void ensureCapacity(int minCapacity) {
        int minExpand = (elementData != DEFAULTCAPACITY_EMPTY_ELEMENTDATA)
            // any size if not default element table
            ? 0
            // larger than default for default empty table. It's already
            // supposed to be at default size.
            : DEFAULT_CAPACITY;

        if (minCapacity > minExpand) {
            ensureExplicitCapacity(minCapacity);
        }
    }

怎么理解呢，意味着，刚创建一个list时 ，minExpand 一定是10，这个时候如果我外部参数minCapacity要求的容量小于10的话 我不会扩充容量，因为我容量够了，否则扩充容量； 而一旦elementData不为空时，我的minExpand 永远为0，这样只要外部参数minCapacity>0就一定执行ensureExplicitCapacity扩充方法进行扩充，至于到底会不会扩充看ensureExplicitCapacity方法的代码。

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

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

所以并不是进入了ensureExplicitCapacity方法就一定扩充，只是有扩充的前提了，但是还有判断外部参数要求的容量minCapacity 是否大于elementData的当前容量，再进行扩充。

核心扩容代码

常量

private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

很大的一个数

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

int oldCapacity = elementData.length;
int newCapacity = oldCapacity + (oldCapacity >> 1);
这是扩容的核心代码，每次扩容为原来的1.5倍，oldCapacity >> 1是右移一位，相当于除以2

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

这个方法没有别的用处，就是对于大数的一个特殊处理。

public int size() {
        return size;
    }

很简单，直接返回当前list的元素个数

public boolean isEmpty() {
        return size == 0;
    }

很简单，判断list是否为空

public boolean contains(Object o) {
        return indexOf(o) >= 0;
    }

很简单，不说了，看看indexOf方法即可

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

indexOf方法没有找到元素时返回的是-1，否则返回的是该元素第一次出现的下标。与之相对的是lastIndexOf方法，返回元素最后一次出现的位置。
equals方法：是Object类的方法，很简单！

public boolean equals(Object obj) {
        return (this == obj);
    }

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

Clone

public Object clone() {
        try {
            ArrayList<?> v = (ArrayList<?>) super.clone();
            v.elementData = Arrays.copyOf(elementData, size);
            v.modCount = 0;
            return v;
        } catch (CloneNotSupportedException e) {
            // this shouldn't happen, since we are Cloneable
            throw new InternalError(e);
        }
    }

注意类必须实现Cloneable接口才可以进行clone,否则报异常CloneNotSupportedException ，这里源码用父类clone一个List对象，然后向下强转成ArrayList类，然后复制即可。内部调用了copyOf方法

public Object[] toArray() {
        return Arrays.copyOf(elementData, size);
    }

很简单 内部调用copyOf方法

public <T> T[] toArray(T[] a) {
        if (a.length < size)
            // Make a new array of a's runtime type, but my contents:
            return (T[]) Arrays.copyOf(elementData, size, a.getClass());
        System.arraycopy(elementData, 0, a, 0, size);
        if (a.length > size)
            a[size] = null;
        return a;
    }

toArray(T[] a)
以正确的顺序返回一个包含此列表中所有元素的数组（从第一个到最后一个元素）; 返回的数组的运行时类型是指定数组的运行时类型。
因为要改变类型，内 部肯定是调用的copyOf三个参数的方法 ，arraycopy方法和参数说明如下：

public static native void arraycopy(Object src,  int  srcPos,
                                        Object dest, int destPos,
                                        int length);
       @param      src      the source array.
     * @param      srcPos   starting position in the source array.
     * @param      dest     the destination array.
     * @param      destPos  starting position in the destination data.
     * @param      length   the number of array elements to be copied.