AbstractCollection源码解析

按照List家族的继承结构，一层一层的解析下去

List家族整体使用的是抽象模板模式

源码解析

package java.util;//放在util包中，不说了
//这个实现了Collection的一些接口方法，使用了抽象模板的设计模式
public abstract class AbstractCollection<E> implements Collection<E> {
    
    protected AbstractCollection() {
    }

    //其实这两个接口Collection已经有了，AbstractCollection并没有实现
    //那么，再写一遍感觉怪怪的
    public abstract Iterator<E> iterator();

    public abstract int size();

    //size方法就是看这个容器筐子装了多少，所以这个地方用了抽象模板
    //下面只要是这类容器，isEmpty都是这么写，写不出花来
    public boolean isEmpty() {
        return size() == 0;
    }

    //这个容器筐子是否包含某个对象
    //也是拿到迭代器，一个一个的遍历就行了
    //不过从这个地方看，好像筐子里面是可以放null的
    public boolean contains(Object o) {
        //其实这个地方处理null问题，主要是因为null调用equals会出现NullPointerException问题
        Iterator<E> it = iterator();
        if (o==null) {
            while (it.hasNext())
                if (it.next()==null)
                    //这个地方也就是说，如果有多个null，那么就找到第一个就代表有了
                    return true;
        } else {
            while (it.hasNext())
                if (o.equals(it.next()))
                    return true;
        }
        return false;
    }

    //转成数组，还是使用迭代器
    public Object[] toArray() {
        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;
    }

    //带有类型的数组，一般这个使用居多吧，还是使用迭代器
    public <T> T[] toArray(T[] a) {
        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();
        }
        return it.hasNext() ? finishToArray(r, it) : r;
    }

    //在这个地方可以看到，存储的数组长度的最大值不是Integer.MAX_VALUE
    //因为，数组也是对象，然后需要点字节存储长度等一些信息
    private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

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

    
    public boolean add(E e) {
        throw new UnsupportedOperationException();
    }

    //也是抽象模板，使用迭代器找到，然后迭代器删除
    public boolean remove(Object o) {
        Iterator<E> it = iterator();
        if (o==null) {
            while (it.hasNext()) {
                if (it.next()==null) {
                    it.remove();
                    return true;
                }
            }
        } else {
            while (it.hasNext()) {
                if (o.equals(it.next())) {
                    it.remove();
                    return true;
                }
            }
        }
        return false;
    }
       
    /////下面都是批量操作,上面的都是单个元素操作  
    /////感觉凡是可以用迭代器能搞定的，就都在这个类中实现了 
       
    //这个地方只要有一个不包含就返回false
    //也就是说传入的容器里面的对象要是本容器的子集才返回true    
    public boolean containsAll(Collection<?> c) {
        for (Object e : c)
            if (!contains(e))
                return false;
        return true;
    }

    
    public boolean addAll(Collection<? extends E> c) {
        boolean modified = false;
        for (E e : c)
            if (add(e))
                modified = true;
        return modified;
    }

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

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

    //ArrayList好像重写了这个方法
    public void clear() {
        Iterator<E> it = iterator();
        while (it.hasNext()) {
            it.next();
            it.remove();
        }
    }


    //Object的toString方法
    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(' ');
        }
    }

}

复制代码

总结

AbstractCollection毕竟是和Collection接头的第一线战场，所以，能实现的方法不是很多，但是，他抓住了Iterator 这个东西，那么对容器进行增删改查，批量的增删改查就找到了门路，凡是通过Iterator能实现的，AbstractCollection 都尽最大努力实现了.整体使用了抽象模板设计模式