Java stream 流

中间操作

1、filter

作用：将流中的元素，基于自定义的比较器进行去重

方法定义

Stream<T> filter(Predicate<? super T> predicate);

说明：这个方法，传入一个Predicate的函数接口，关于Predicate函数接口定义，可以查看《JAVA8 Predicate接口》，这个接口传入一个泛型参数T，做完操作之后，返回一个boolean值；filter方法的作用，是对这个boolean做判断，过滤出返回值为true的对象。

2、map

作用：可以改变返回值类型，例如假定流中的元素为对象，可以将对象的的某一属性作为返回值，这时流中的元素就为该返回值了

方法定义：

<R> Stream<R> map(Function<? super T, ? extends R> mapper);

说明：这个方法传入一个Function的函数式接口，接口定义可以查看《JAVA8 Function接口》，这个接口，接收一个泛型T，返回泛型R，map函数的定义，返回的流，表示的泛型是R对象，这个表示，调用这个函数后，可以改变返回的类型，先看下面的案例

3、flatMap

没看懂 附上链接

4、distinct

作用：基于hashCode（）和equals（）方法进行去重；

方法定义

Stream<T> distinct();

说明：

5、sorted

作用：对流中是元素进行排序（首先可以使用filter过滤掉null值，避免空指针）

方法定义：

//排序
Stream<T> sorted();
//根据属性排序
Stream<T> sorted(Comparator<? super T> comparator);

说明：

​ 对于sorted()，使用时要保证流中的元素实现comparable接口，因为默认的排序方式是基于自然排序进行的，也可以使用sorted(Comparator.reverseOrder())对自然序进行逆序；

​ 对于sorted(Comparator<? super T> comparator)，可以使用sorted(Comparator.comparing(方法引用))来自定义比较器，同样进行逆序的方式为sorted(Comparator.comparing(方法引用).reversed()) 。

6、peek

作用：对流中的元素进行处理，无返回值，返回的元素还是之前流中的元素，变化的是元素中的某一属性；而map会改变返回值

方法定义：

Stream<T> peek(Consumer<? super T> action);

说明：peek接收一个没有返回值的λ表达式，可以做一些输出，外部处理等。map接收一个有返回值的λ表达式，之后Stream的泛型类型将转换为map参数λ表达式返回的类型

7、limit

作用：截取前n个元素

方法定义：

//截断--取先maxSize个对象
Stream<T> limit(long n);

说明：n不能为负数，可以超出流长度

8、skip

作用： skip(long n) 方法跳过前 n （非负）个元素，返回剩下的流，有可能为空流。

方法定义：

Stream<T> limit(long n);

说明：跳过前n个元素（第N个也不取，包括第n个）返回剩下的元素，n不能为负数，也可能返回空流；

终端操作

1、

void forEach(Consumer<? super T> action);

2、

void forEachOrdered(Consumer<? super T> action);


public final <A> A[] toArray(IntFunction<A[]> generator)


boolean anyMatch(Predicate<? super T> predicate);


boolean allMatch(Predicate<? super T> predicate);


boolean noneMatch(Predicate<? super T> predicate);


long count();


T reduce(T identity, BinaryOperator<T> accumulator);


Optional<T> reduce(BinaryOperator<T> accumulator);


<U> U reduce(U identity, BiFunction<U, ? super T, U> accumulator, BinaryOperator<U> combiner);


<R> R collect(Supplier<R> supplier,BiConsumer<R, ? super T> accumulator,BiConsumer<R, R> combiner);


  <R, A> R collect(Collector<? super T, A, R> collector);