JDK源码之AbstractCollection

本文是基于jdk1.8下

---

AbstractCollection是继承于Collection，类中许多方法都是通过迭代器实现的。

AbstractCollection的构造器通过父类构造器实现，所以自己只有无方法体的构造器。以下两个方法也都是继承于Collection

protected AbstractCollection() {    }    //继承Collection的迭代器    public abstract Iterator<E> iterator();    //继承Collection的size方法，返回集合中元素个数    public abstract int size();    //检查是否为空，为空返回true，否则返回false    public boolean isEmpty() {        return size() == 0;    }

检测集合是否包含元素o，首先需要判断元素o是否为null，然后通过迭代器实现

    public boolean contains(Object o) {        Iterator<E> it = iterator();        if (o==null) {            //如果元素o为null，且集合中元素有null，则为真。            while (it.hasNext())                if (it.next()==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()) // 元素少于预计值，调用Arrays.copeOf截取到i位置                return Arrays.copyOf(r, i);            r[i] = it.next();        }        return it.hasNext() ? finishToArray(r, it) : r;//如果还有元素，调用finishToArray方法，否则则返回数组。    }

与上一种方法相似，但是必须转换成与数组a相同的类型。

@SuppressWarnings("unchecked")    public <T> T[] toArray(T[] a) {        int size = size();        //a数组能容纳该集合元素，则返回包含该集合元素的数组，否则，将创建一个能包含此集合元素同种类型的数组        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()) {//没有元素                 if (a == r) {                    r[i] = null;                 } 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;    }

设定限定值，以便下面方法使用

private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;//虚拟机会保存一下头文件在数组中，所以需要减8

迭代器元素多于数组的个数的情况，转换成数组的方法

@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;//扩充为原来2倍+1                                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) // 调整的容量溢出，则抛出异常            throw new OutOfMemoryError                ("Required array size too large");        return (minCapacity > MAX_ARRAY_SIZE) ?            Integer.MAX_VALUE :            MAX_ARRAY_SIZE;//大于限定值，设为Integer.MAX_VALUE,小于或等于时，设为限定值    }

添加元素方法，但是未实现

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

移除元素方法

public boolean remove(Object o) {        Iterator<E> it = iterator();        if (o==null) {//判断是否为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;    }

判断是否包含集合c中元素，只要有一个不包含则返回false

public boolean containsAll(Collection<?> c) {        for (Object e : c)            if (!contains(e))                return false;        return true;    }

添加集合c中所有元素，但因add()方法未实现，所有此方法也未实现

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

移除与集合c相同的元素，

public boolean removeAll(Collection<?> c) {        Objects.requireNonNull(c);//检查集合c中是否含有null        boolean modified = false;        Iterator<?> it = iterator();        while (it.hasNext()) {            if (c.contains(it.next())) {//检查集合c中是否包含了迭代器中元素，只要有一个存在，就返回true                it.remove();                modified = true;            }        }        return modified;    }

保留集合c中的元素

    public boolean retainAll(Collection<?> c) {        Objects.requireNonNull(c);        boolean modified = false;        Iterator<E> it = iterator();        while (it.hasNext()) {            if (!c.contains(it.next())) {//集合c中不包含迭代器中元素，则将迭代器中元素删除                it.remove();                modified = true;            }        }        return modified;    }

清除集合

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

通过迭代器打印，格式为[a,b]，集合元素之间有‘，’集合元素通过String.vauleOf()转换成String

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