ArrayList 类的几个方法

ArrayList 类

ArrayList 类的是使用 Object 数组实现的。初始容量为 10，还有一个 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) {
            // 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;
        }
    }

一共有这三个构造方法，先来看第一个，它需要提供一个初始化的容量，然后通过 if 判断这个容量是否是一个合法的容量，若合法，创建对应大小的数组，若为 0，利用声明好的空的 EMPTY_ELEMENTDATA Object 数组给 elementData 赋值，其他的情况则抛出不合法参数异常。

第二个构造方法，是无参数构造方法，只需要给数据集合 elementData 赋值 DEFAULTCAPACITY_EMPTY_ELEMENTDAT 即可。

第三个构造方法，需要传入的是一个 E 泛型的类型或者它子类的集合，使用它的 toArray() 方法赋值给这个 ArrayList 的数据容器 elementData，如果返回的数组长度不为零，则进行下一个判断，判断返回的数据集合是不是 Object 数组，若不是，则利用 Arrays.copyOf() 方法进行重新赋值。若返回的数组长度为零，则对 elementData 赋值为空数组。

其他方法

	public void trimToSize() {
        modCount++;
        if (size < elementData.length) {
            elementData = (size == 0)
              ? EMPTY_ELEMENTDATA
              : Arrays.copyOf(elementData, 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);
        }
    }

    private static int calculateCapacity(Object[] elementData, int minCapacity) {
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            return Math.max(DEFAULT_CAPACITY, minCapacity);
        }
        return minCapacity;
    }

    private void ensureCapacityInternal(int minCapacity) {
        ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
    }

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

        // overflow-conscious code
        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);
    }
    
    private static int hugeCapacity(int minCapacity) {
        if (minCapacity < 0) // overflow
            throw new OutOfMemoryError();
        return (minCapacity > MAX_ARRAY_SIZE) ?
            Integer.MAX_VALUE :
            MAX_ARRAY_SIZE;
    }

先看第一个方法，是说再必要时增加数据集合的容量，需要传入一个我们所需要的最小容量，先是计算一个当前集合的最小容量，判断 elementData 和 DEFAULTCAPACITY_EMPTY_ELEMENTDATA 是否是同一个数组，如果不是，返回 0，否则，返回 DEFAULT_CAPACITY，也就是 10，对比传入的 minCapacity，如果小于它，则执行 ensureExplicitCapacity 方法，这个方法中，我们对比我们传入的需要的最小容量和我们当前数据集合的长度，如果前者的数值更大，我们调用 grow() 增加集合的长度，在 grow() 方法中，我们显示获取当前数据数组的长度，然后声明一个变量（新容量）为旧数组长度的 1.5 倍，如果新容量还是小于我们需要的容量，那我们就将新容量改变为我们需要的容量的值，再进行最大值的判断，如果新容量大于 MAX_ARRAY_SIZE，调用 hugeCapacity() 方法获取应该新容量的最大值，最后声明 elementData 为新容量的数组。

简言之就是 1.5 倍扩容的方法。这个 ensureCapacityInternal() 方法，就是在 add() 方法中调用的扩容的方法。

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

最后扩容的容量为 1.5 倍原容量 + 1，写这篇博客也就是为了记录一下这个，其他的方法也没有什么特别的地方，如果有人想看，评论里说评论一下，补充。