AbstractCollection的toArray()分析

    public Object[] toArray() {
        // Estimate size of array; be prepared to see more or fewer elements
        Object[] r = new Object[size()];
        Iterator<E> it = iterator();
        for (int i = 0; i < r.length; i++) {
            if (! it.hasNext()) // fewer elements than expected
                return Arrays.copyOf(r, i);
            r[i] = it.next();
        }
        return it.hasNext() ? finishToArray(r, it) : r;

1. 先根据size()的大小生成一个数组，然后根据迭代器的hasNext来判断，当前迭代器后面还有没有值，并用i记录当前的已经存入的元素数量。
2. 如果迭代器实际迭代的数量的大小比size小，则使用Arrays.copyOf来截断当前的数组，然后直接返回。
3. 需要说明的是Arrays的静态方法是java针对数组来实现的一系列方法。其中copyOf将传入的数组复制到一个新的数组中，新的数组的大小由第二个参数来指定。
4. 如果迭代器实际迭代的数量的大小比size大，则调用finishToArray来完成之后迭代器的实现。

 

    @SuppressWarnings("unchecked")
    private static <T> T[] finishToArray(T[] r, Iterator<?> it) {
        int i = r.length;
        while (it.hasNext()) {
            int cap = r.length;
            if (i == cap) {
                int newCap = cap + (cap >> 1) + 1;
                // overflow-conscious code
                if (newCap - MAX_ARRAY_SIZE > 0)
                    newCap = hugeCapacity(cap + 1);
                r = Arrays.copyOf(r, newCap);
            }
            r[i++] = (T)it.next();
        }
        // trim if overallocated
        return (i == r.length) ? r : Arrays.copyOf(r, i);
    }

1. i表示当前的迭代的元素的数量，总的来说i每次进入循环体就增加一个.而另一个cap表示当前的数组的大小。
2. 第一次进入i==cap,说明需要增大cap。这里增加的cap的一半并加1的大小，然后判断下新的数组的大小是否超过VM的最大界限，如果没有就将继续循环体。
3. 每次进入循环体，先用cap确认下当前数组的长度。如果i还没有增长到cap相同的程度则只要将迭代器的下一个元素放入数组并将i加一就行
4. 在返回的时候使用根据已经迭代的元素i来复制当前数组到一个新的数组中。

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

1.  如果当前的cap最大值不可在继续增大，即cap+1为负值则抛出一个超出内存大小的异常。Integer.MAX_VALUE+1 <0
2. 如果当前的值可以分配，则分配一个MAX_ARRAY_SIZE和MAX_VALUE 中的满足条件的值。

    @SuppressWarnings("unchecked")
    public <T> T[] toArray(T[] a) {
        // Estimate size of array; be prepared to see more or fewer elements
        int size = size();
        T[] r = a.length >= size ? a :
                  (T[])java.lang.reflect.Array
                  .newInstance(a.getClass().getComponentType(), size);
        Iterator<E> it = iterator();

        for (int i = 0; i < r.length; i++) {
            if (! it.hasNext()) { // fewer elements than expected
                if (a == r) {
                    r[i] = null; // null-terminate
                } else if (a.length < i) {
                    return Arrays.copyOf(r, i);
                } else {
                    System.arraycopy(r, 0, a, 0, i);
                    if (a.length > i) {
                        a[i] = null;
                    }
                }
                return a;
            }
            r[i] = (T)it.next();
        }
        // more elements than expected
        return it.hasNext() ? finishToArray(r, it) : r;
    }

1. i表示当前的迭代的元素的数量,传入的参数a的大小,以及size返回的大小
2. 如果是比预期少的元素，需要分情况讨论，r引用的就是a，则让a数组位置i为null。
3. r引用不是a。说明a.length<size,新的数组说明是根据size新建的数组。如果a的长度小于i，说明这些值没办法放入到a中，则需要返回自建建立的数组而没办法返回原先的参数a，所有只要对r进行截断后返回就可以了
4. 如果是a的长度>i，这说明了传入的参数a是可以放入足够的参数的，这里将r中的所有元素复制到a中，并进行截断然后返回，则让a数组位置i为null。
5. 下同toArray().