一、java8的四类函数式接口
Consumer<T> 消费型
void accept(T t); 接收一个输入参数，无返回值。
Supplier<T> 供给型
T get(); 无参数，返回一个结果。
Function<T,R> 文档型
R apply(T t); 接收一个输入参数，返回一个结果。
Predicate<T> 断言型
boolean test(T t); 接收一个输入参数，返回一个布尔值结果。
二、Stream创建流的几种方式
空Stream(Empty Stream)
方法empty()被用于创建一个Empty Stream：
Stream<String> streamEmpty = Stream.empty();
上述代码段创建的Empty Stream通常被用于避免null对象或零元素对象的streams（streams
with no element）返回结果为null。
public Stream<String> streamOf(List<String> list){
return list == null || list.isEmpty() ? Stream.empty() : list.streams();
}
集合Steram(Stream of Collection)
可以创建任意Collection接口衍生类（Collection->List、Set、Queue）的Streams：
Collections<String> collection = Arrays.asList("a", "b", "c");
Stream<Stirng> streamOfCollection = collection.stream();
数组Stream(Stream of Array)
创建数组Stream：
Stream<String> streamOfArray = Stream.of("a", "b", "c");
可以选择Stream中包含的元素数量：
String[] arr = new String[]{"a", "b", "c"};
Stream<String> streamOfArrayFull = Arrays.stream(arr);
Stream<String> streamOfArrayPart = Arrays.stream(arr, 1, 3);
备注：截取的是(1,3] ----> 输出的是b和c
构建器(Stream.builder())
当builder被用于指定参数类型时，应被额外标识在声明右侧，否则方法build()将创建一个Stream(Object)实例：
Stream<String> streamBuilder = Stream.<String>builder()
.add("a").add("b").add("c")
.build();
生成器(Stream.generator())
方法generator()接受一个供应器Supplier<T>用于元素生成。由于生产流(resulting
stream)被定义之后属于无限流（即无止境地不断生产），开发者必须指定stream拥有流的目标大小，否则方法generator()将持续生产直到jvm内存到达顶值（memory limit）：
Stream<String> streamOfGenerated = Stream.generate( () -> "element").limit(10);
上述代码将创建十个内容为“element”的生成流。
迭代器(Stream.iterate())
另一种创建无限流的方法是通过调用方法iterate()，同样的它也需要使用方法limit()对目标流的元素大小进行限制：
Stream<Integer> streamItreated = Stream.iterate(40, n -> n + 2).limit(20);
迭代流即采用迭代的方法作为元素生产方式，类似于高中数学中的f(x)，f(f(x))，etc。上述例子中，生成流的第一个元素是迭代器iterate()中的第一个元素40，从第二个元素开始的每个新元素都与上个元素有关，在此例中，生成流中的元素为：40、42、44 ... 76、78。
基元流(Stream of Primitives)
Java8提供了创建三大基础数据类型（int、long、double）stream的方式。由于Stream<T>是一个类接口，我们无法采用泛型传参的方式声明基础数据类型的stream，因此三个特殊的接口就被创造出来了：IntStream、LongStream、DoubleStream。使用它们能够避免不必要的自动装箱，以提高生产效率。
①IntStream
IntStream intStream = IntStream.range(1, 3);
方法range(int startInclusive, int
endInclusive)创建了一个有序流（从startInclusive到endInclusive）。它使后面的值每个增加1，但却不包括最后一个参数，即[),最终结果是1,2。
②LongStream
LongStream longStream = LongStream.rangeClosed(5, 300);
方法rangeClosed(int startInclusive, int endInclusive)与range()大致相同，它包括最后一个参数，即()，最终结果是5,6,7.....299,300
③DoubleStream
Random random = new Random();
DoubleStream doubleStream = random.doubles(3);
Java8之后，类Random也提供了拓展方法用于生成基础数据类型的stream，上述代码创建了一个含有3个随机数的DoubleStream。
字符串流(Stream of String)
String类型也可以作为生成stream的源，这得益于方法chars()的帮助，此外由于JDK中没有CharStream接口，IntStream也被用来表示字符流（stream
of chars）
IntStream streamOfChars = "2a".chars();
下例中通过正则表达式将a,b,c截取为字符串流。
Stream<String> streamOfString = Pattern.compile(",").spitAsStream("a,b,c");
文件流(Stream of File)
Java NIO类文件允许通过方法lines()生成文本文件的Stream<String>,文本的每一行都会变成stream的一个元素：
Path path = Paths.get("C:\file.txt");
Stream<String> streamOfString = Files.lines(path);
Stream<String> streamWithCharset = Files.lines(path, Charset.forName("utf-8"));
在方法lines()中也可以通过Charset设置文件编码。
引用Stream(Referencing a Stream)
只要调用生成操作（中间操作）就会实例化一个stream并生成一个可获取的引用，但执行终端操作会使得stream无法访问。
以下代码如果不考虑冗长的话将是有效的：
Stream<String> stream = Stream.of("a", "b", "c")
.filter(t -> t.contains("b"));
Optional<String> anyElement = stream.findAny();
但是倘若我们在执行终端操作后重新使用相同的引用，则会不可避免的触发IllegalStateException。
Optional<String> firstElement = stream.findFirst();
IllegalStateException是一个运行时异常（RuntimeException），即编译器将不会提示此错误。因此必须记得JAVA8不允许重复使用stream。因为stream从设计上是用于操作数据源（集合、数组）所生成的元素序列，而不是存储元素。
所以想让上面的代码正常工作就得改为(List可以存储元素)：
List<String> elements = Stream.of("a", "b", "c")
.filter(t -> t.contains("b"))
.collect(Collectors.toList());
Optional<String> anyElement = elements.stream().findAny();
Optional<String> firstElement = elements.stream().findFirst();
三、中间操作
Filter（过滤）
过滤流中的某些元素
Stream<T> filter(Predicate<? super T> predicate);
案例
String[] dd = { "a", "b", "c" };
Stream<String> stream = Arrays.stream(dd);
stream.filter(str -> str.equals("a"))
.forEach(System.out::println);//返回字符串为a的值
Map（映射）
接收一个函数作为参数，该函数会被应用到每个元素上，并将其映射成一个新的元素。
<R> Stream<R> map(Function<? super T, ? extends R> mapper);
案例
//利用map把int转string
Integer[] dd = {1, 2, 3};
Stream<Integer> stream = Arrays.stream(dd);
stream.map(str -> Integer.toString(str))
.forEach(str -> {
System.out.println(str);//1,2,3
});
//利用map把对象里的name参数提取成一个List<String>
List<Emp> list = Arrays.asList(new Emp("a"), new Emp("b"));
List<String> list1 = list.stream()
.map(Emp::getName)
.collect(Collectors.toList());
flatMap
接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流连接成一个流。
<R> Stream<R> flatMap(Function<? super T, ? extends Stream<? extends R>> mapper);
案例
List<String> list = Arrays.asList("a,b,c", "1,2,3");
Stream<String> newStream = list.stream().flatMap(s -> {
String[] split = s.split(",");
return Arrays.stream(split);
});
newStream.forEach(System.out::print);//abc123
distinct，sorted，peek，limit，skip
//去重
Stream<T> distinct();
//排序
Stream<T> sorted();
//定制排序，自定义Comparator排序器
Stream<T> sorted(Comparator<? super T> comparator);
//如同于map，能得到流中的每一个元素。但map接收的是一个Function表达式，有返回值；而peek接收的是Consumer表达式，没有返回值。
Stream<T> peek(Consumer<? super T> action);
//获取maxSize个元素
Stream<T> limit(long maxSize);
//跳过n个元素
Stream<T> skip(long n);
案例
List<Emp> empList = new ArrayList<>();
empList.add(new Emp("张三", 45, 9000.0));
empList.add(new Emp("李四", 55, 10000.0));
empList.add(new Emp("王五", 20, 1500.0));
empList.add(new Emp("赵六", 25, 2500.0));
empList.add(new Emp("田七", 30, 4000.0));
//获取3个年龄>25岁的员工信息，根据工资排序
List<Emp> emps1 = empList.stream().filter(t -> t.getAge() > 25)
.sorted(Comparator.comparing(Emp::getSalary))
.distinct()
.limit(3)
.collect(Collectors.toList());
emps1.forEach(System.out::println);
//把年龄>30岁的员工工资 x 1.5倍
List<Emp> emps2 = empList.stream().filter(t -> t.getAge() > 30)
.peek(emp -> {
emp.setSalary(emp.getSalary() * 1.5);
})
.collect(Collectors.toList());
emps2.forEach(System.out::println);
//数字从1开始迭代，跳过前5个数再往后获取10个数
List<Integer> nums = Stream.iterate(1, i -> i + 1)
.skip(5)
.limit(10)
.collect(Collectors.toList());
nums.forEach(System.out::println);//输出6,7,8.....14,15
四、终端操作
forEachOrdered和forEach
forEachOrdered按指定的顺序处理流元素，而不管流是顺序的还是并行的。
forEach在并行流中不仅以非确定顺序执行，还可以在不同线程中针对不同元素同时执行。
void forEach(Consumer<? super T> action);
void forEachOrdered(Consumer<? super T> action);
案例
List<String> list = Arrays.asList("a", "b", "c");
//顺序流时都是按顺序操作
list.stream().forEachOrdered(System.out::print);//abc
list.stream().forEach(System.out::print);//abc
//并行流时forEachOrdered能按顺序操作，而forEach不能
list.parallelStream().forEachOrdered(System.out::print);//abc
list.parallelStream().forEach(System.out::print);//不确定
toArray
public final <A> A[] toArray(IntFunction<A[]> generator)
案例
List<String> strs = Arrays.asList("a", "b", "c");
String[] str1 = strs.stream().toArray(str -> new String[strs.size()]);
String[] str2 = strs.stream().toArray(String[]::new);
String[] str3 = strs.toArray(new String[strs.size()]);
Object[] obj1 = strs.stream().toArray();
Object[] obj2 = strs.toArray();
count，max，min
//返回流中元素的总个数
long count();
//返回流中元素最大值
Optional<T> max(Comparator<? super T> comparator);
//返回流中元素最小值
Optional<T> min(Comparator<? super T> comparator);
findFirst，findAny
//返回流中第一个元素
Optional<T> findFirst();
//返回流中的任意元素
Optional<T> findAny();
案例
List<String> list = Arrays.asList("a", "b", "c", "d");
String findFirst = list.stream().findFirst().get();
String findAny = list.stream().findAny().get();
anyMatch，allMatch，noneMatch
//只要流中有一个元素满足该断言则返回true
boolean anyMatch(Predicate<? super T> predicate);
//当流中每个元素都符合该断言时才返回true
boolean allMatch(Predicate<? super T> predicate);
//当流中每个元素都不符合该断言时才返回true
boolean noneMatch(Predicate<? super T> predicate);
案例
List<String> strs = Arrays.asList("a", "a", "a", "a", "b");
boolean aa = strs.stream()
.anyMatch(str -> str.equals("a"));//true
boolean bb = strs.stream()
.allMatch(str -> str.equals("a"));//false
boolean cc = strs.stream()
.noneMatch(str -> str.equals("a"));//false
reduce
reduce
是一种归约操作，将流归约成一个值的操作叫做归约操作，用函数式编程语言的术语来说，这种称为折叠（fold)
①第一次执行时，accumulator函数的第一个参数为流中的第一个元素，第二个参数为流中元素的第二个元素；第二次执行时，第一个参数为第一次函数执行的结果，第二个参数为流中的第三个元素；依次类推。
Optional<T> reduce(BinaryOperator<T> accumulator);
案例
List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
Integer sum = list.stream().reduce((x1, x2) -> x1 + x2).get();
等同于 list.stream().reduce(Integer::sum).get();
System.out.println(sum); // 55
②流程跟上面一样，只是第一次执行时，accumulator函数的第一个参数为identity，而第二个参数为流中的第一个元素。
T reduce(T identity, BinaryOperator<T> accumulator);
案例
List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
Integer sum = list.stream().reduce(10, (x1, x2) -> x1 + x2);
System.out.println(sum); //65
③在顺序流(stream)中，该方法跟第二个方法一样，即第三个参数combiner不会起作用。
在并行流(parallelStream)中,我们知道流被fork
join出多个线程进行执行，此时每个线程的执行流程就跟第二个方法reduce(identity,accumulator)一样，而第三个参数combiner函数，则是将每个线程的执行结果当成一个新的流，然后使用第一个方法reduce(accumulator)流程进行规约。
<U> U reduce(U identity, BiFunction<U, ? super T, U> accumulator, BinaryOperator<U> combiner);
顺序流案例：
List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
Integer i1 = list.stream().reduce(0,
(a1, a2) -> {
System.out.println("stream accumulator: a1:" + a1 + " a2:" + a2);
return a1 - a2;
},
(a1, a2) -> {
System.out.println("stream combiner: b1:" + a1 + " b2:" + a2);
return a1 * a2;
});//顺序流中，粉色部分不会执行
System.out.println(i1); //-55
并行流案例
List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
Integer i2 = list.parallelStream().reduce(0,
(a1, a2) -> {
System.out.println("parallelStream accumulator: a1:" + a1 + " a2:" + a2);
return a1 - a2;
},
(a1, a2) -> {
System.out.println("parallelStream combiner: b1:" + a1 + " b2:" + a2);
return a1 * a2;
});//并行流中，粉色部分会执行
System.out.println(i2); //3628800
collect
<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);
案例
List<Emp> list = new ArrayList<>();
list.add(new Emp("张三", 45, 9000.1));
list.add(new Emp("李四", 55, 10000.0));
list.add(new Emp("王五", 20, 1500.0));
list.add(new Emp("赵六", 25, 2550.0));
list.add(new Emp("田七", 30, 4100.0));
// 转list
List<String> names1 = list.stream().map(Emp::getName).collect(Collectors.toList());
// 转set
Set<String> names2 = list.stream().map(Emp::getName).collect(Collectors.toSet());
// 转map，需要指定key和value，Function.identity()表示当前的Emp对象本身
Map<String, Emp> map = list.stream().collect(Collectors.toMap(Emp::getName, Function.identity()));
// 计算元素中的个数
Long count = list.stream().collect(Collectors.counting());
Long count1 = (long) list.size();
// 数据求和 summingInt summingLong，summingDouble
Integer sumAges = list.stream().collect(Collectors.summingInt(Emp::getAge));
// 平均值 averagingInt,averagingLong,averagingDouble
Integer aveAge = list.stream().collect(Collectors.averagingInt(Emp::getAge)).intValue();
Double aveSalary = list.stream().collect(Collectors.averagingDouble(Emp::getSalary));
// 综合处理类（包含count,sum,min,max,average）
// summarizingInt，summarizingLong,summarizingDouble
IntSummaryStatistics intSummary = list.stream().collect(Collectors.summarizingInt(Emp::getAge));
// 连接字符串,可以使用重载的方法，加上一些前缀，后缀和中间分隔符
String strEmp1 = list.stream().map(Emp::getName).collect(Collectors.joining("，"));
//张三，李四，王五，赵六
String strEmp2 = list.stream().map(Emp::getName).collect(Collectors.joining("-中间的分隔符-", "最前缀*", "&最后缀"));
// maxBy 按照比较器中的比较结果刷选最大值
Optional<Integer> maxAge = list.stream().map(Emp::getAge)
.collect(Collectors.maxBy(Comparator.comparing(Function.identity())));
// 最小值
Optional<Integer> minAge = list.stream().map(Emp::getAge)
.collect(Collectors.minBy(Comparator.comparing(Function.identity())));
System.out.println("max:" + maxAge);
System.out.println("min:" + minAge);
// 归约操作
list.stream().map(Emp::getAge).collect(Collectors.reducing((x, y) -> x + y));
list.stream().map(Emp::getAge).collect(Collectors.reducing(0, (x, y) -> x + y));
// 分操作 groupingBy 根据地址，把原list进行分组
Map<Integer, List<Emp>> mapGroup = list.stream().collect(Collectors.groupingBy(Emp::getAge));
// partitioningBy 分区操作 需要根据类型指定判断分区
Map<Boolean, List<Integer>> partitioningMap = list.stream().map(emp -> emp.getAge())
.collect(Collectors.partitioningBy(emp -> emp > 20));
五、其他
Optional静态类
在java8中，很多的stream的终端操作，都返回了一个Optional<T>对象，这个对象，是用来解决空指针的问题，而产生的一个类。
private Optional() {
this.value = null;
}
private Optional(T value) {
this.value = Objects.requireNonNull(value);
}
public static <T> Optional<T> empty() {
@SuppressWarnings("unchecked")
Optional<T> t = (Optional<T>) EMPTY;
return t;
}
public static <T> Optional<T> of(T value) {
return new Optional<>(value);
}
public static <T> Optional<T> ofNullable(T value) {
return value == null ? empty() : of(value);
1.get()直接取，如果为null，就返回异常。
2.orElse(T
other)在取这个对象的时候，设置一个默认对象（默认值）；如果当前对象为null的时候，就返回默认对象。
3.orElseGet(Supplier<? extends T>
other)跟第二个是一样的，区别只是参数，传入了一个函数式参数。
4.orElseThrow(Supplier<? extends X>
exceptionSupplier)第四个，跟上面表达的是一样的，为null的时候，返回一个特定的异常。
5. isPresent()是对当前的value进行null判断。
案例
Emp emp = new Emp("张三", "上海", "22");
Optional<Emp> op = Optional.ofNullable(emp);
System.out.println(op.get().getAddress());//上海
Optional<Emp> op1 = Optional.ofNullable(null);
System.out.println(op1.orElse(emp).getAddress());//上海
//这里指定了一个默认对象emp，为先创建的一个emp对象，emp对象里的成员变量还没有赋值，所以输出为null
System.out.println(op1.orElseGet(Emp::new).getAddress());
// java.lang.RuntimeException
try {
System.out.println(op1.orElseThrow(RuntimeException::new));
} catch (Exception e) {
e.printStackTrace();
}