java.util源码之AbstractCollection(基于jdk1.7)

public Object[] toArray() {
        // 转成数组，同时考虑在执行该方法时，有其他线程删除Collection中元素和向Collection插入数据的情况
        Object[] r = new Object[size()];
        Iterator<E> it = iterator();
        for (int i = 0; i < r.length; i++) {
            if (! it.hasNext()) // 在当前线程调用该方法时，另外的线程调用this.remove或者iterator.remove
                return Arrays.copyOf(r, i);    //返回数组的长度为i，也就是实际大小
            r[i] = it.next();
        }

//在当前线程调用该方法时，另外的线程调用this.add或者iterator.add时，it.hasNext为true,执行finishToArray，当没有其他的线程调用add(iterator.add), remove(iterator.remove)时，返回r

        return it.hasNext() ? finishToArray(r, it) : r; 

}

//将执行toArray的结果写入传递过来的参数中

public <T> T[] toArray(T[] a) {
    int size = size();
    //如果参数数组长度>=Collection容量，返回参数数组，否则返回new出来的java.lang.reflect.Array，大小为Collection本身容量

    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) {  //当参数数组长度>=Collection容量时

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

private static <T> T[] finishToArray(T[] r, Iterator<?> it) {
    int i = r.length;
    while (it.hasNext()) {
        int cap = r.length;
        if (i == cap) {   

//每次当索引值指向数组的最后一个元素+1时以右移1位+1的速度进行扩容，如11扩容成11+11/2+1=17
//执行ArrayList add方法时，当数组长度不够时，以右移1位的速度进行扩容，如11扩容成11+11/2=16
//在执行toArray时，为什么要加1，我不太明白？？？？？？

            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();  //因为i初使值为r.length, 所以i++而不是++i
    }
    // 为提高效率，当while执行完成时，如果索引值恰好位于数组末端+1时,直接返回r
    //其实return (i != r.length ? Arrays.copyOf(r, i) : r)效率更高，因为i==r.length的情况非常态，特别当数组很大的时候
    return (i == r.length) ? r : Arrays.copyOf(r, i);
}