参考书籍：《Java 8函数式编程》
一. 四种最基本的函数式接口
使用Stream类进行流操作之前，先了解一下四种最基本的函数式接口（根据英文单词意思就可以理解其作用）：
-
Predicate<T>接口：一个T类型参数，返回boolean类型值。boolean test(T t);Lambda表达式基本写法：
Predicate<Integer> predicate = x -> x > 5; -
Function<T, R>功能接口：一个T类型参数，返回R类型值。R apply(T t);Lambda表达式基本写法：
Function<Integer, Integer> function = x -> x + 1; -
Supplier<T>接口：无参数，返回一个T类型值。T get();Lambda表达式基本写法：
Supplier<Integer> supplier = () -> 1; -
Consumer<T>接口：一个T类型参数，无返回值。void accept(T t);Lambda表达式基本写法：
Consumer<Integer> consumer = x -> System.out.println(x); Consumer<Integer> consumer = System.out::println;//方法引用的写法
“->”符号的左侧对应的是方法参数，无参数就空括号，一个参数可以省略括号，多参数不能省略，比如(x，y)；
“->”符号的右侧对应的是方法返回值，整体是一个代码块{...}，最终返回值对应方法即可。比如
Function<Integer, Integer> function = x -> {return x + 1};
当只有一个表达式时，{}、return均可省略。
以上函数式接口的抽象方法都是单个参数，多个参数有BiPredicate、BiFunction、BiConsumer等接口，用法类似。
Optional不是函数是类，这是个用来防止NullPointerException的辅助类型。T get()
二. 使用Stream类进行流操作
下面开始使用Stream类进行流操作，除了Stream类，还有IntStream、DoubleStream、LongStream，很显然这三种都是有针对性的流操作，分别针对int、double、long类型的数据，它们都继承BaseStream类，如下图所示：
一. 怎么创建Stream类？
四种方式：
1. Stream<T> stream = Stream.of(T... values);
2. Stream<Object> build = Stream.builder().add(1).add(2).build();
3. Stream<Integer> iterate= Stream.iterate(0, x -> x + 1).limit(3);
4. Stream<String> generate = Stream.generate(() -> "hello world").limit(3);
3和4两种方式一定要加limit()限制数量，不然就突破天际了~
常用的数组、集合数据操作都可以转换成流操作。
数组可以通过Arrays类中的stream(...)方法转换成Stream，集合可以通过Collection接口中的stream()方法转换成Stream。
IntStream stream = Arrays.stream(new int[]{1, 3, 4});
Stream<Integer> stream = new ArrayList<Integer>().stream();
二. 使用Stream类进行数据操作
-
allMatch(Predicate<? super T> predicate)：全部匹配
Stream.of("peter", "anna", "mike").allMatch(s -> s.startsWith("a"));
打印结果：false
其他两个方法：
- anyMatch：有一个匹配就返回true
- noneMatch：全部都不匹配才返回true
-
filter(Predicate<? super T> predicate)：过滤操作，返回Stream，可以进行链式调用
Stream.of("peter", "anna", "mike").filter(value -> value.startsWith("a"))
.collect(Collectors.toList()).forEach(System.out::println);
打印结果：anna
-
map：映射操作，返回Stream
Stream.of("peter", "anna", "mike").map(String::toUpperCase)
.collect(Collectors.toList()).forEach(System.out::println);
打印结果：PETER ANNA MIKE
-
flatMap：将最底层元素抽出来放到一起
Stream.of(Arrays.asList(1, 2, 3), Arrays.asList(2, 3, 6)).flatMap(lists -> lists.stream())
.collect(Collectors.toList()).forEach(System.out::print);
打印结果：123236
Stream<List<Integer>> listStream = Stream.of(Arrays.asList(1, 2, 3), Arrays.asList(2, 3, 6));
listStream.flatMap(lists -> lists.stream())
.collect(Collectors.toList()).forEach(System.out::print);
listStream经过flatMap操作，变成了Stream<Integer>类型。
-
concat：流连接操作
Stream.concat(Stream.of(1, 2), Stream.of(3)).forEach(System.out::print);
打印结果：123
-
peek：生成一个包含原Stream的所有元素的新Stream，新Stream每个元素被消费之前都会执行peek给定的消费函数
Stream.of(2, 4).peek(x -> System.out.print(x - 1)).forEach(System.out::print);
打印结果：1234
-
skip：跳过前N个元素后，剩下的元素重新组成一个Stream
Stream.of(1, 2, 3, 4).skip(2).forEach(System.out::print);
打印结果：34
-
max：最大值。求最小值：min
System.out.println(Stream.of(1, 2, 3, 4).max(Integer::compareTo).get());
打印结果：4
-
reduce：网上翻译为规约，用途比较广，可以作为累加器，累乘器，也可以用来实现map、filter操作。
Java8提供了三个方法：
1. Optional<T> reduce(BinaryOperator<T> accumulator);
2. T reduce(T identity, BinaryOperator<T> accumulator);
3. <U> U reduce(U identity, BiFunction<U, ? super T, U> accumulator, BinaryOperator<U> combiner);
第2个相对于第1个来说，除了返回值不同，就只是多了一个初始值。
System.out.println(Arrays.asList(1, 2, 3).stream().reduce((a, b) -> a + b).get());
System.out.println(Arrays.asList(1, 2, 3).stream().reduce(0, (a, b) -> a + b));
打印结果都是6。
第3个方法第3个参数是在使用并行流操作的时候，最后进行汇集操作，所以串行流使用前面两种方法即可。
Stream有串行和并行两种，调用stream()或sequential()就成为了串行流，调用parallelStream()或parallel()就成为了并行流，两者同时调用，只需看最后一次调用的方法即可。并行流在某些条件下可以提高性能，但这里只介绍一些API，性能问题暂时不讨论。
- 其他还有
distinct、count、sorted等方法，作用跟SQL语句一样。
