JDK1.8新特性——Stream API
摘要：本文主要学习了JDK1.8的新特性中有关Stream API的使用。
部分内容来自以下博客：
https://blog.csdn.net/icarusliu/article/details/79495534
概述
是什么
Stream API（java.util.stream）把真正的函数式编程风格引入到Java中。这是目前为止对Java类库最好的补充，因为Stream API可以极大提供Java程序员的生产力，让程序员写出高效率、干净、简洁的代码。
Stream是JDK1.8中处理集合的关键抽象概念，它可以指定对集合进行的操作，可以执行非常复杂的查找、过滤和映射数据等操作。使用Stream API对集合数据进行操作，就类似于使用SQL执行的数据库查询。也可以使用Stream API来并行执行操作。简言之，Stream API提供了一种高效且易于使用的处理数据的方式。
操作方式
JDK1.8通过内部迭代来实现对流的处理，一个流式处理可以分为三个部分：转换成流、中间操作、终止操作。
转换成流：将原始数据转换成一个流对象，以便进行后续操作。
中间操作：将原始的Stream转换成另外一个Stream，如filter返回的是过滤后的Stream。
终止操作：产生的是一个结果或者其它的复合操作，如count或者forEach操作。
转换成流
创建空的Stream对象
Stream stream = Stream.empty();
通过集合类中的stream()方法或者parallelStream()方法创建
List<String> list = Arrays.asList("a", "b", "c", "d");
Stream stream = list.stream();// 获取串行的Stream对象
Stream parallelStream = list.parallelStream();// 获取并行的Stream对象
通过数组工具类Arrays的stream()方法创建
String[] arr = {"a", "b", "c", "d"};
Stream<String> stream = Arrays.stream(arr);
通过Stream中的of()方法创建
Stream stream = Stream.of("test");
Stream stream = Stream.of("a", "b", "c");
通过Stream中的iterate()方法创建有序的Stream
public static<T> Stream<T> iterate(final T seed, final UnaryOperator<T> f);
通过Stream中的generate()方法创建无序的Stream
public static<T> Stream<T> generate(Supplier<T> s);
中间操作
多个中间操作可以连接起来形成一个流水线，除非流水线上触发终止操作，否则中间操作不会执行任何得处理，而终止操作时一次性全部处理，称为“惰性求值”。
过滤：filter
定义如下：
对Stream对象按指定的Predicate进行过滤，返回的Stream对象中仅包含未被过滤的元素。
Stream<T> filter(Predicate<? super T> predicate);
代码如下：
public static void main(String[] args) {
Stream<Integer> stream = Stream.of(1, 9, 5, 3, 7);
// 同一个流不能用两遍。
Stream<Integer> streamFilter = stream.filter(new Predicate<Integer>() {
// 使用了匿名类，重写了test()方法。
@Override
public boolean test(Integer i) {
if (i > 5) {
return true;
}
return false;
}
});
// 为了看到过滤后的效果，使用了终止操作forEach()进行打印。
streamFilter.forEach(e -> System.out.println(e));
}
运行结果如下：
9
7
截取：limit
定义如下：
获取指定的前几个元素，组成新的Stream对象返回。
Stream<T> limit(long maxSize);
代码如下：
public static void main(String[] args) {
Stream<Integer> stream = Stream.of(1, 9, 5, 3, 7).limit(2);
// 为了看到过滤后的效果，使用了终止操作forEach()进行打印。
stream.forEach(e -> System.out.println(e));
}
运行结果如下：
1
9
跳过：skip
定义如下：
跳过指定的前几个元素，使用剩下的元素组成新的Stream返回。
Stream<T> skip(long n);
代码如下：
public static void main(String[] args) {
Stream<Integer> stream = Stream.of(1, 9, 5, 3, 7).skip(2);
// 为了看到过滤后的效果，使用了终止操作forEach()进行打印。
stream.forEach(e -> System.out.println(e));
}
运行结果如下：
5
3
7
去重：distinct
定义如下：
调用元素的equals()方法比较，返回一个去重后的Stream对象。
Stream<T> distinct();
代码如下：
public static void main(String[] args) {
Stream<Integer> stream = Stream.of(1, 9, 5, 3, 7, 9, 3).distinct();
stream.forEach(e -> System.out.println(e));
}
运行结果如下：
1
9
5
3
7
排序：sorted
定义如下：
传入一个比较器，返回排序后的Stream对象。
Stream<T> sorted(Comparator<? super T> comparator);
代码如下：
public static void main(String[] args) {
Stream<Integer> stream = Stream.of(1, 9, 5, 3, 7).sorted((m, n) -> m - n);
stream.forEach(e -> System.out.println(e));
}
运行结果如下：
1
3
5
7
9
映射（一对一）：map
定义如下：
将元素转换成其他形式或者提取信息。接收一个函数作为参数，该函数会被应用到每个元素上，并将其映射成一个新的元素。
<R> Stream<R> map(Function<? super T, ? extends R> mapper);
代码如下：
public static void main(String[] args) {
Stream<String> streamStr = Stream.of("aa", "aaa", "a", "aaaaa", "aaaa");
Stream<Integer> streamInt = streamStr.map(e -> e.length());
streamInt.forEach(e -> System.out.println(e));
}
运行结果如下：
2
3
1
5
4
散射（一对多）：flatMap
定义如下：
对原Stream中的所有元素进行操作，每个元素会有一个或者多个结果，然后将返回的所有元素组合成一个统一的Stream并返回。
<R> Stream<R> flatMap(Function<? super T, ? extends Stream<? extends R>> mapper);
代码如下：
public static void main(String[] args) {
List<String> list = Arrays.asList("aa", "bb");
list.stream().flatMap((e) -> Demo.filterCharacter(e)).forEach(e -> System.out.println(e));
}
public static Stream<Character> filterCharacter(String str){
List<Character> list = new ArrayList<>();
for (Character ch : str.toCharArray()) {
list.add(ch);
}
return list.stream();
}
运行结果如下：
a
a
b
b
终止操作
终端操作会从流的流水线生成结果。其结果可以是任何不是流的值，例如：List，Integer，甚至是void。
检查是否匹配所有元素：allMatch
定义如下：
如果所有元素都满足条件，那么返回true，否则返回false。
boolean allMatch(Predicate<? super T> predicate);
代码如下：
public static void main(String[] args) {
boolean match = Stream.of("aa11", "bb11", "cc11").allMatch(e -> e.contains("11"));
System.out.println(match);// true
}
检查是否至少匹配一个元素：anyMatch
定义如下：
如果至少有一个元素满足条件，就返回true，否则返回false。
boolean anyMatch(Predicate<? super T> predicate);
代码如下：
public static void main(String[] args) {
boolean match = Stream.of("aa11", "bb11", "cc11").anyMatch(e -> e.contains("aa"));
System.out.println(match);// true
}
检查是否没有匹配的元素：noneMatch
如果所有元素都不满足条件，返回true，否则返回false。
定义如下：
boolean noneMatch(Predicate<? super T> predicate);
代码如下：
public static void main(String[] args) {
boolean match = Stream.of("aa11", "bb11", "cc11").noneMatch(e -> e.contains("dd"));
System.out.println(match);// true
}
返回第一个元素：findFirst
定义如下：
返回遇到的第一个元素。
Optional<T> findFirst();
代码如下：
public static void main(String[] args) {
Optional<String> find = Stream.of("aa11", "bb11", "cc11").findFirst();
System.out.println(find);// Optional[aa11]
}
返回任意一个元素：findAny
定义如下：
返回处理最快的那个元素。
Optional<T> findAny();
代码如下：
public static void main(String[] args) {
Optional<String> find = Stream.of("aa11", "bb11", "cc11").findAny();
System.out.println(find);// Optional[aa11]
}
返回元素个数：count
定义如下：
long count();
代码如下：
public static void main(String[] args) {
long count = Stream.of("aa11", "bb11", "cc11").count();
System.out.println(count);//
}
返回元素最大值：max
定义如下：
Optional<T> max(Comparator<? super T> comparator);
代码如下：
public static void main(String[] args) {
Optional<String> max = Stream.of("aa11", "bb11", "cc11").max((m, n) -> m.hashCode() - n.hashCode());
System.out.println(max);// Optional[cc11]
}
返回元素最小值：min
定义如下：
Optional<T> min(Comparator<? super T> comparator);
代码如下：
public static void main(String[] args) {
Optional<String> max = Stream.of("aa11", "bb11", "cc11").min((m, n) -> m.hashCode() - n.hashCode());
System.out.println(max);// Optional[aa11]
}
规约元素：reduce
定义如下：
可以将流中元素反复结合起来，得到一个值，包含T类型的identity，返回T类型的值。
T reduce(T identity, BinaryOperator<T> accumulator);
可以将流中元素反复结合起来，得到一个值，返回Optional类型的值。
Optional<T> reduce(BinaryOperator<T> accumulator);
代码如下：
public static void main(String[] args) {
List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
Integer sumWith0 = list.stream().reduce(0, (x, y) -> x + y);
System.out.println(sumWith0);//
Integer sumWith5 = list.stream().reduce(5, (x, y) -> x + y);
System.out.println(sumWith5);//
Optional<Integer> sum = list.stream().reduce((x, y) -> x + y);
System.out.println(sum);// Optional[15]
}
收集元素：collect
定义如下：
将流转换为其他形式，接收一个Collector接口的实现，用于给Stream中元素做汇总的方法。
Collector接口中方法的实现决定了如何对流执行收集操作（如收集到List、Set、Map）。但是Collectors实用类提供了很多静态方法，可以方便地创建常见收集器实例。
<R, A> R collect(Collector<? super T, A, R> collector);
代码如下：
public static void main(String[] args) {
List<Integer> list = Arrays.asList("aaa", "aa", "aaaaa", "a", "aaaaaa").stream().map(String::length).collect(Collectors.toList());
list.forEach(System.out::println);
}