Java容器类研究3：AbstractCollection

ArrayList继承自AbstractList，AbstractList为“random access”的数组提供了基本的实现。随机访问数据是相对于顺序访问数据而言，例如链表的形式。AbstractSequentialList为链表形式的顺序访问提供了基本实现。AbstractList提供了默认的随机访问数据的iterator。AbstractList继承自AbstractCollection，AbstractCollection为Collection提供了基本实现。

java.util.AbstractCollection

<!--more-->

contains

AbstractCollection实现了查询是否包含某一个元素的方法。最好使用Iterator遍历集合中的元素，由于能够屏蔽集合内部元素存储的具体实现，而且根据不一样的数据存储特色，优化访问策略。这里还能够正确查找null元素，须要注意的是对null元素的查询须要特别的处理，有时候本身实现方法时，每每会忽略传入参数为null时的处理，致使方法没法处理特殊状况。

public boolean contains(Object o) {
        Iterator<E> it = iterator();
        if (o==null) {
            while (it.hasNext())
                if (it.next()==null)
                    return true;
        } else {
            while (it.hasNext())
                if (o.equals(it.next()))
                    return true;
        }
        return false;
    }

toArray

toArray方法将容器中的元素转化为数组的形式。这里元素的复制，采用的是直接复制引用。这里还考虑到了并发运算时，元素数量在复制时产生变化的状况，当数量减小时，就用Arrays.copy()截取结果。当数量增长时，会调用finishToArray函数扩容。

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

在finishToArray函数中，对容量每次扩展1/2+1的大小，而且会检查是否会超过设定的最大数组长度MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8。若是长度超过了限定值，则以原容量+1为底线，返回一个最大容量。最后返回的数组也会修剪掉多余的位置。

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

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

这里有一个toArray的重载，须要传入一个数组做为参数，据我观察，目的是将集合中的元素存入指定的数组，重利用已有数组的存储。若是元素过多，而目标数组容纳不下，只能从新申请数组来进行存储。

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) {
                    //利用的原数组，且元素不足，则补null表示结束
                    r[i] = null; // null-terminate
                } else if (a.length < i) {
                    //元素较少，但数量超过原始数组，只能用新数组
                    return Arrays.copyOf(r, i);
                } else {
                    //元素减小，致使原始数组能够容纳下，则copy回原始数组，折腾呗
                    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;
    }

removeAll

removeAll方法删除目标集合中的全部重叠元素。Iterator能够作到在遍历时，安全的删除元素，而经过index循环删除则可能致使index偏移。

public boolean removeAll(Collection<?> c) {
        Objects.requireNonNull(c);
        boolean modified = false;
        Iterator<?> it = iterator();
        while (it.hasNext()) {
            if (c.contains(it.next())) {
                it.remove();
                modified = true;
            }
        }
        return modified;
    }

toString

AbstractCollection的toString实现，比较令我震惊的是e == this的做用。这里为何要判断打印的内容是否为本身自己？由于sb.append(e == this ? "(this Collection)" : e);会调用e的toString函数来生成字符串，若不加判断，则会造成无限的toString递归调用。我猜测一下，估计当时toString的实现者没有注意到该问题的存在，直到该bug出现，脑洞不大还真难想起来这个问题。

public String toString() {
        Iterator<E> it = iterator();
        if (! it.hasNext())
            return "[]";

        StringBuilder sb = new StringBuilder();
        sb.append('[');
        for (;;) {
            E e = it.next();
            sb.append(e == this ? "(this Collection)" : e);
            if (! it.hasNext())
                return sb.append(']').toString();
            sb.append(',').append(' ');
        }
    }