collection

1、继承关系

iterable中方法

/**
从java8开始有的，用于给本集合的每一个元素执行特定的动作(action)，自己实现action方法。其中该集合必须实现Consumer接口，并且是T类的父类，即下限是T类。   
 Consumer仅仅是一个接口，里面包含两个方法
    #accept()方法，抽象方法，用于实现具体动作
    #forEach方法
        */
    default void forEach(Consumer<? super T> action) {
        Objects.requireNonNull(action);
        for (T t : this) {
            action.accept(t);
        }
    }

consumer

@FunctionalInterface
public interface Consumer<T> {

    /**
     执行某一个具体动作
     */
    void accept(T t);

    /**
    这是java新增的用于组合两个函数的函数式编程方法，这个方法的简单意思就是先执行调用者，再执行参数，return后面 Lambda 表达式是一个另一篇文章会详细介绍
     */
    default Consumer<T> andThen(Consumer<? super T> after) {
        Objects.requireNonNull(after);
        return (T t) -> { accept(t); after.accept(t); };
    }
}

@FunctionalInteferface注解

作用于接口上，表明这个接口是一个特殊的接口：函数式接口，一般的接口有任意的抽象方法，但函数式接口却规定了该接口只能有一个抽象 的方法。

例如java中和多线程有关的函数式接口Runnable

@FunctionalInterface
public interface Runnable {
    public abstract void run();
}

当我们写成

new Thread(
    ()->{
          System.out.println(Thread.currentThread().getName());
         }
  ).start();

编译器对这个语法将其解析成：

new Thread(
  			new Runnable() {
  				@Override
  				public void run() {
  					System.out.println(Thread.currentThread().getName());
  				}
  			}
  	).start();

（）->{}代表对run()方法的重写，如果runnable接口有多个抽象方法那么()->{}这种写法，编译器就不知道这是重写的哪个方法了。

collection所有方法：

    int size(); //返回集合大小
    boolean isEmpty(); //判断集合是否为空
    boolean contains(Object o); //判断集合是否含有某一个元素，不同的类判定标准不同，看具体实现
    Iterator<E> iterator(); //返回集合的一个Iterator，并不会保证顺序性
    Object[] toArray(); //返回集合相对应的Object数组，如果集合有序的，则返回的数组一定也是有相应顺序的。
    /**拥有上一个toArray所有规则，并且传入参数a，如果a足够大，则把转化后的数组放入a中且从第一个开始，到Collection的最后一个，一次装入数组a中，对于a中后面的则不变，否则返回一个新的a**/
    <T> T[] toArray(T[] a);
    boolean add(E e); //往集合里面增加一个元素
    boolean remove(Object o);  //往集合里面删除一个特定元素
    boolean containsAll(Collection<?> c); //判断一个集合是否包含某个元素集合的所有
    boolean addAll(Collection<? extends E> c);  //将集合c加入本集合中
    boolean removeAll(Collection<?> c);  //将既在本集合又在c集合中元素全部清除，返回不含有公共元素的本集合

    /**
     * 从java8开始，删除所有符合预测(Predicate)的集合元素，关于Predicate具体细节可以自己实现。
     * Predicate是一个方法接口
        使用lambda方式移除元素
     */
    default boolean removeIf(Predicate<? super E> filter) {
        Objects.requireNonNull(filter);//检验lambda是否为空
        boolean removed = false;
        final Iterator<E> each = iterator();//获取迭代器
        while (each.hasNext()) {
            //如果该方法执行返回true则移除该元素
            if (filter.test(each.next())) {
                each.remove();
                removed = true;
            }
        }
        return removed;
    }
    boolean retainAll(Collection<?> c); //保留本集合和c集合相同的元素，即保留并集
    void clear();  //清空集合
    /**
    *注意有个规则，当利用hash表来实现的集合时，
    *hash不相同，equals一定false
    *equals为false时，hash可能为true也可能为false，也就是比较equals时，一定会先比较hash值
    **/
    boolean equals(Object o);//比较
    int hashCode(); //去hash值

    /**
     * 从java8开始
     * 返回一个可分割的迭代器，用于并发流式处理的时候调用
     */
    @Override
    default Spliterator<E> spliterator() {
        return Spliterators.spliterator(this, 0);
    }

    /**
     *返回当前集合的流，如果当前集合无法返回spliterator，则需要重写此方法
     * @since 1.8
     */
    default Stream<E> stream() {
        return StreamSupport.stream(spliterator(), false);
    }

    /**
     * 返回一个可并行流
     * @since 1.8
     */
    default Stream<E> parallelStream() {
        return StreamSupport.stream(spliterator(), true);
    }