Java Collection 学习笔记

Collection

先上一张图

其中：

• 实线箭头表示继承关系，绿色实线箭头表示一个接口继承另一个接口。蓝色实线箭头表示一个类继承另外一个类。
• 绿色虚线箭头表示实现一个接口。

Collection 接口定义

再来一张图：

查看源码：

public interface Collection<E> extends Iterable<E> {
// 省略....
}

可以看到他是一个泛型接口，E代表要存储的对象类型。它继承了Iterable接口，用于支持以迭代器Iterator的方法访问所持有的对象。iterator()方法就是Iterable接口所定义的，用于返回Iterator对象。而Iterator接口有hasNext()和next()方法，前者用于判断还有对象没，后者用于获取对象，并移动到下一位。

Collection接口定义了一些公用的方法， 比如获取容器大小，判断是否为空，判断是否包含给定的对象，转换成数组，添加一个对象，删除给定的对象，判断是否包含一个给定的Collection 对象，将给定的Collection对象所包含的全部实例添加到容器中，删除给定的Collection对象所包含的全部实例。清空容器等操作。
当然，少不了 equals(Object) 和 hashCode() 方法，他们是Object类的方法。而java中默认所有的类都继承Object类。
同时还有stream()和parallelStream()方法。

List, Set, Queue 是 Collection 类的子接口。AbstractCollection 实现了Collection 接口。

AbstractCollection

AbstractCollection是一个抽象类。抽象类就是说它实现了部分方法。可以看到，List,Set,Queue的添加方法是不一样的，所以它不会实现这个方法：

add(E e)

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

但是因为有iterator()方法，它会返回一个Iterator对象，它抽象了访问对象的方式，可以通过hasNext() 方法和 next() 方法的联合使用完成对Collection持有对象的遍历，那不管是List,Set，还是Queue, 他们判断一个给定对象是否被包含的算法就是一样的。

contains(Object object) 方法

 public boolean contains(Object var1) {
    Iterator var2 = this.iterator();
    if (var1 == null) {
        while(var2.hasNext()) {
            if (var2.next() == null) {
                return true;
            }
        }
    } else {
        while(var2.hasNext()) {
            if (var1.equals(var2.next())) {
                return true;
            }
        }
    }

    return false;
}

toArray()

既然能够遍历，那转换成数组的算法也是一样的。

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

toArray(T[] a)

@SuppressWarnings("unchecked")
    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) {
                    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();
        }
        // more elements than expected
        return it.hasNext() ? finishToArray(r, it) : r;
    }

既然能够遍历，那就可以删除给定对象

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()) {
                if (o.equals(it.next())) {
                    it.remove();
                    return true;
                }
            }
        }
        return false;
    }

containsAll(Collection<?> c)

还可以判断是否包含给定Collection集合的所有对象。

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

addAll(Collection<? extends E> c)

还可以把给定的Collection集合的所有对象添加到自己当中，只不过是一个for循环而以，每次循环调用具体的添加方法。

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

removeAll(Collection<?> c)

可以删除给定Collection集合的所有对象。

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

retainAll(Collection<?> c)

retainAll 就是 removeAll的判断条件取反而已。

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

clear()

清空集合就是遍历，把找到的对象先移动到下一个对象 it.next()，然后在删除 it.remove()。

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

toString()

借助迭代遍历实现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(' ');
        }
    }

AbstractList, AbstractQueue, AbstractSet

他们都会继承AbstractCollection,同时实现自己对应的接口。比如：

public abstract class AbstractList<E> extends AbstractCollection<E> implements List<E> {}

public abstract class AbstractSet<E> extends AbstractCollection<E> implements List<E> {}

public abstract class AbstractQueue<E> extends AbstractCollection<E> implements Queue<E> {}

AbstractList

要知道AbstarctList接口实现了什么方法，就要看List和Collection相比，它多提供了些什么方法。List和Set 和 Queue相比，它有Index这个概念。所以提供了两个方法，如果给定一个对象，可以从前往后找，返回找到的第一个Index。indexOf(Object object), 也可以从后往前找，返回遇到的一个对象的索引 lastIndexOf(Object). 当然，正是因为有index这个特性，List的literator 需要多那么一点东西：返回下一个index ， 返回上一个index, 判断是否有前继，获取前继。源码如下：

public interface ListIterator<E> extends Iterator<E> {
    boolean hasNext();

    E next();

    boolean hasPrevious();

    E previous();

    int nextIndex();

    int previousIndex();

    void remove();

    void set(E var1);

    void add(E var1);
}

太晚了，下次继续。。。。