JAVA集合源码攻坚战（5）——AbstractCollection

前言

前面讲到Collection后，把这个类给漏掉了。
AbstractCollection是对Collection接口的一个直接实现，而像list和set集合的具体实现的抽象类，也都是通过继承它来实现的。

正文

根据官方文档：

This class provides a skeletal implementation of the Collection interface, to minimize the effort required to implement this interface.

该实现类是一个抽象类，主要是对Collection的一个骨架型的实现，为了减少实现Collection接口减少工作量。
在实际代码中，该类实现了一些基本方法，也定义了一些抽象方法留给子类实现。

抽象方法

public abstract Iterator<E> iterator();

public abstract int size();

如果要实现一个不可修改的集合，那么只需要实现Iterator()和size()方法即可；但如果要实现一个可修改的集合，那么还需要额外实现add(E，e)方法。
默认情况下，直接调用AbstractCollection的add方法会直接抛出异常。

实现的方法

1. isEmpty() 判断集合是否为空

public boolean isEmpty() {
        return size() == 0;
    }

2. contains(Object o) 判断是否包含指定元素

public boolean contains(Object o) {
    	// 获取迭代器
        Iterator<E> it = iterator();
        // 允许元素为null
        if (o==null) {
            while (it.hasNext())
                if (it.next()==null)
                    return true;
        } else {
            while (it.hasNext())
            	// 通过equals来判断，所以o这个对象所在的类，需要重写equals方法
                if (o.equals(it.next()))
                    return true;
        }
        return false;
    }

3. remove(Object o) 移除指定元素

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()) {
            	// 通过equals来判断，所以o这个对象所在的类，需要重写equals方法
                if (o.equals(it.next())) {
                    it.remove();
                    return true;
                }
            }
        }
        return false;
    }

注意，该方法只会移除迭代中遇到的第一个匹配的元素，对后续元素不处理。
4. containsAll(Collection<?> c) 判断集合是否包含指定集合中的所有元素

public boolean containsAll(Collection<?> c) {
    	// 循环调用contains方法，只有c集合中所有元素都在当前集合中找得到，才会返回true
        for (Object e : c)
            if (!contains(e))
                return false;
        return true;
    }

5. addAll(Collection<? extends E> c) 将指定集合追加到当前集合中

public boolean addAll(Collection<? extends E> c) {
        boolean modified = false;
        for (E e : c)
        	// 依赖于add方法，如果要使用该addAll方法，必须先重写add方法
            if (add(e))
                modified = true;
        return modified;
    }

6. retainAll(Collection<?> c) 保留共有的，删除指定集合中不共有的元素

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

7. clear() 清除整个集合

public void clear() {
        Iterator<E> it = iterator();
        while (it.hasNext()) {
            it.next();
            it.remove();
        }
    }

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

构造方法

/**
     * Sole constructor.  (For invocation by subclass constructors, typically
     * implicit.)
     */
    protected AbstractCollection() {
    }

注意，默认的构造方法是protected的，所以官方文档推荐子类自己实现一个无参的构造方法。