13java源码解析-AbstractCollection

其他 源码解析 https://blog.csdn.net/qq_32726809/article/category/8035214  

类的声明

public abstract class AbstractCollection<E> implements Collection<E>

• implements Collection

• 集合的根接口
• Set List Map SortedSet SortedMap HashSet TreeSet ArrayList LinkedList Vector Collections Arrays AbstractCollection

• 是一个抽象类，对集合的基本操作有了实现

2方法

2.1 iterator

 public abstract Iterator<E> iterator();

抽象方法，用来返回一个迭代器

2.2 isEmpty

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

判断是否为空

2.3contains

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

• 集合中是否有某个元素

• 这个是可以判断是否有空的
• 是利用迭代器来判断的

2.4

返回本集合中包含所有对象的数组,其实就是迭代一下，把所有的元素放在数组里

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/*----------1*/
            r[i] = it.next();
        }
        return it.hasNext() ? finishToArray(r, it) : r;/*----------2*/
    }

• 1处的意思是 如果集合中的元素比预想中的要少，则用 null来补位

• copyOf 会开辟新的空间，少的元素用 null 来补

• 2处的意思是

• 1 如果超出范围了，则先分配控件，不够的用 null代替，把多的元素加进去，再把 null减掉
• 2代码如下

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;/*扩大1.5倍空间*/
                // 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);/*除去多于的null*/
    }

remove

通过迭代，移除指定元素

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

containsAll

看某个集合是否在现有集合内，就是for循环某个集合，然后调用 contains方法。

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

addAll

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

与上面的函数处理方法相似

removeAll

移除所有，先判断是否为空(1处)，再循环一下，把每个都移除

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

clear

清除

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