Collection

个人学习，有好多不懂的，见谅 

---

一、Collection

  Collection为集合类。个人理解为数据结构，如何对数据进行存储、增删改查、遍历等操作。

二、解析

public interface Collection<E> extends Iterable<E> {
    // Query Operations

    /**
     * 返回集合大小，最大值为Integer.MAX_VALUE
     */
    int size();

    /**
     * 返回集合是否为空
     */
    boolean isEmpty();

    /**
     * 判断o是否属于此集合
     */
    boolean contains(Object o);

    /**
     * 返回集合元素迭代器，无法保证元素的返回顺序
     *（除非此集合是某个提供保证的类的实例）
     */
    Iterator<E> iterator();

    /**
     * 转换为Object类型组数并返回
     */
    Object[] toArray();

    /**
     * 转换为T类型组数并返回
     */
    <T> T[] toArray(T[] a);

    // Modification Operations

    /**
     * 添加一个元素
     */
    boolean add(E e);

    /**
     * 删除一个元素
     */
    boolean remove(Object o);


    // Bulk Operations

    /**
     * 判断此集合是否包含集合c
     */
    boolean containsAll(Collection<?> c);

    /**
     * 添加集合c
     */
    boolean addAll(Collection<? extends E> c);

    /**
     * 删除集合c
     */
    boolean removeAll(Collection<?> c);

    /**
     * 该方传递参数为函数式,传递内容是一个接口类型
     * 定义为一个filter函数,该函数用于传递给Objects.requireNonNull判断,然后调用
     * 迭代器,将满足该定义的filter的本实例中的元素移除
     * 
     * @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;
    }

    /**
     * 求当前集合与c的共有的元素，返回给当前集合
     */
    boolean retainAll(Collection<?> c);

    /**
     * 清空集合
     */
    void clear();


    // Comparison and hashing

    /**
     * 判断元素是否相同
     */
    boolean equals(Object o);

    /**
     * 获取hashCode
     */
    int hashCode();

    /**
     * 将迭代器拆分,重写自Iterable接口,从已知元素数量的本例中返回拆分后的迭代器
     * 此方法返回的为本类本身
     * 子类可能重写迭代器拆分,将一个集合的迭代拆分为多个集合的迭代交由多个线程
     *
     * @since 1.8
     */
    @Override
    default Spliterator<E> spliterator() {
        return Spliterators.spliterator(this, 0);
    }

    /**
     * 将默认的迭代器拆分后的结果,聚合为流,该流并非io中的流,
     * 是一种类似于数据排序操作流
     *
     * @since 1.8
     */
    default Stream<E> stream() {
        return StreamSupport.stream(spliterator(), false);
    }

    /**
     * 同上,但是具体其他的实现中,因为可并行,所以可能是线程不安全的
     *
     * @since 1.8
     */
    default Stream<E> parallelStream() {
        return StreamSupport.stream(spliterator(), true);
    }
}