Java集合框架之接口Collection源码分析

本文咱们主要学习Java集合框架的根接口Collection，经过本文咱们能够进一步了解Collection的属性及提供的方法。在介绍Collection接口以前咱们不得不先学习一下Iterable，由于Collection接口继承了它。

Collection接口类图

从类图中咱们看到Collection接口继承了Iterable接口

Iterable源码分析

由类图咱们能够发现，Iterable接口有三个方法，其中两个方法使用default修饰的，这是jdk1.8的新特性，容许接口中有默认实现方法，其实现类中能够有选择的重写这部分方法，下面咱们看一下每一个方法的做用是什么：

#返回元素类型为T的迭代器，有了这个迭代器就能够对集合中元素进行遍历
Iterator<T> iterator();

#遍历集合中的元素并对元素进行执行操做，直到遍历完成或抛出异常
default void forEach(Consumer<? super T> action) {
    Objects.requireNonNull(action);
    for (T t : this) {
         action.accept(t);
    }
}

#Spliterator（splitable iterator可分割迭代器），对集合进行并行遍历
default Spliterator<T> spliterator() {
        return Spliterators.spliteratorUnknownSize(iterator(), 0);
}

Iterable接口总结：

默认为全部集合类添加了两个方法，

一个是遍历并处理集合元素

一个是可分割迭代器，与方法iterator相比，一个是顺序遍历，一个是并行遍历

Collection接口源码分析

//查询操做，如下方法属于查询操做
    #返回集合中元素数量，若是元素数量大于Integer.MAX_VALUE将返回Integer.MAX_VALUE
    int size();

    #若是集合中没有元素，将返回true，不然返回false
    boolean isEmpty();

    #若是集合中包含指定的元素，则返回true，不然false
    boolean contains(Object o);

    #返回该集合中元素的迭代器。对于返回元素的顺序，没有任何保证。
    Iterator<E> iterator();

    #若是此集合对其迭代器返回的元素的顺序有任何保证，则该方法必须以相同的顺序返回元素。
    #这个方法必须分配一个新数组，即便这个集合是由数组组成的。
    #这个方法充当集合与数组之间转换的桥梁
    Object[] toArray();

    #返回一个包含集合中全部元素的数组
    #若是集合中的元素类型与指定数组类型相匹配则直接按照元素中数组类型返回
    #不然，将使用指定数组的运行时类型和该集合的大小分配新的数组。
    #若是此集合对其迭代器返回的元素的顺序有任何保证，则该方法必须以相同的顺序返回元素。
    #T:返回数组的类型
    #a:若是该数组足够大能够容纳集合中全部元素，则使用该数组存储，不然将根据集合大小和元素类型从新建立一个数组
    <T> T[] toArray(T[] a);

    // 修改操做，如下方法属于修改操做

    #向集合中添加元素，若是该元素在集合中已经存在则返回false，不然返回true
    #集合自己对添加的元素会有所限制，好比有些集合拒绝添加null
    boolean add(E e);

    #从集合中删除指定元素，若是指定的元素存在集合中并完成了删除操做，则返回true
    boolean remove(Object o);


    // 批量操做

     #若是集合中包含指定的全部元素，则返回true
    boolean containsAll(Collection<?> c);

    #将指定集合中的全部元素添加到此集合
    #若是在运行过程当中修改指定的集合，则该操做的行为是未定义的
    boolean addAll(Collection<? extends E> c);

    #从当前集合中移除指定集合中的全部元素
    boolean removeAll(Collection<?> c);

   
    # @since 1.8
    #删除该集合中知足给定谓词的全部元素
    #在迭代期间抛出的任何异常都会传递给调用者
    default boolean removeIf(Predicate<? super E> filter) {
        Objects.requireNonNull(filter);
        boolean removed = false;
        final Iterator<E> each = iterator();
        while (each.hasNext()) {
            if (filter.test(each.next())) {
                each.remove();
                removed = true;
            }
        }
        return removed;
    }

    #只保留集合中指定的元素
    boolean retainAll(Collection<?> c);

    #清空集合中全部元素
    void clear();


    // 比较和散列

    #比较指定对象与当前集合是否相等
    #@see Object#equals(Object)
    #@see Set#equals(Object)
    #@see List#equals(Object)
    boolean equals(Object o);

    #@see Object#hashCode()
    #@see Object#equals(Object)
    #返回当前对象的哈希值
    int hashCode();

    
    #@since 1.8
    #建立一个集合的并行迭代器
    @Override
    default Spliterator<E> spliterator() {
        return Spliterators.spliterator(this, 0);
    }

   
    #@since 1.8
    #将当前集合做为数据源，建立一个序列流
    default Stream<E> stream() {
        return StreamSupport.stream(spliterator(), false);
    }

    #@since 1.8
    #将当前集合做为数据源，建立一个可并行计算的序列流
    default Stream<E> parallelStream() {
        return StreamSupport.stream(spliterator(), true);
    }