【Stream API 详解】

java中Stream API的使用

Lambda表达式

Lambda表达式介绍

Lambda 是一个匿名函数，我们可以把 Lambda 表达式理解为是一段可以传递的代码（将代码像数据一样进行传递）。可以写出更简洁、更灵活的代码。作为一种更紧凑的代码风格，使java的语言表达能力得到了提升。

Lambda表达式是基于函数式接口来使用的，函数式接口就是只包含一个抽象方法的接口，我们可以在任意函数式接口上使用 @FunctionalInterface 注解，这样做可以检查它是否是一个函数式接口。

Lambda 表达式语法

Lambda 表达式在java 语言中引入了一个新的语法元素和操作符。这个操作符称为 “ -> ” ， 该操作符被称为 Lambda 操作符或箭头操作符。它将 Lambda 分为两个部分：

左侧 ：指定了 Lambda 表达式需要的所有参数

右侧：指定了 Lambda 体，即 Lambda 表达式要执行的功能

// 语法格式一：无参，无返回值，Lambda 体只有一条语句
Runnable r = () -> System.out.println("hello world");

//语法格式二：Lambda 需要一个参数，Lambda 体只有一条语句
Consumer con = (x) -> System.out.println(x);

//语法格式三：Lambda 需要一个参数，Lambda 体只有一条语句，此时参数的小括号可以省略
Consumer con = x -> System.out.println(x);

//语法格式四：Lambda 需要二个或多个参数，Lambda 体只有一条语句，参数小括号不可省略
Comparator<Integer> com = (o1, o2) -> o1.compareTo(o2);

//语法格式五：Lambda 需要二个或多个参数，Lambda 体有多条语句，此时需要大括号
Comparator<Integer> com = (o1, o2) -> {
            int compare = o1.compareTo(o2);
            return compare;
        };

//语法格式六：Lambda 体只有一条语句时，大括号和return可以省略
Comparator<Integer> com = (o1, o2) -> o1.compareTo(o2);

//语法格式六：Lambda 参数类型可以都写，也可以省略，java编译器可以根据上下文进行数据类型推断
Comparator<Integer> com = (Integer o1, Integer o2) -> o1.compareTo(o2);
Comparator<Integer> com = (o1, o2) -> o1.compareTo(o2);

类型推断

上述 Lambda 表达式中的参数类型都是由编译器推断得出的。Lambda 表达式中无需指定参数类型，程序依然可以编译，这是因为 javac 根据程序的上下文，在后台推断出了参数的类型。Lambda 表达式的类型依赖于上下文环境，是由编译器推断出来的。这就是所谓的“类型推断”

函数式接口

1）只包含一个抽象方法的接口，称为函数式接口。

2）你可以通过 Lambda 表达式来创建该接口的对象。（若 Lambda 表达式抛出一 个受检异常，那么该异常需要在目标接口的抽象方法上进行声明）。

3）我们可以在任意函数式接口上使用 @FunctionalInterface 注解，这样做可以检查它是否是一个函数式接口，同时 javadoc 也会包含一条声明，说明这个接口是一个函数式接口。

自定义函数式接口

@FunctionalInterface
public interface MyFunction<T, R> {
    
    R func(T t);
}

作为参数传递 Lambda 表达式

//函数式接口作为参数传递
public String strHandler(String str, MyFunction<String, String> fun) {
        return fun.func(str);
    }

//实际使用时使用Lambda表达式来具体的实现
@Test
public void test04() {
String handler = strHandler("abcdef", (s) -> s.toUpperCase());
System.out.println(handler);
}

//作为参数传递 Lambda 表达式：为了将 Lambda 表达式作为参数传递，接收Lambda 表达式的参数类型必须是与该 //Lambda 表达式兼容的函数式接口的类型。

Java 内置四大核心函数式接口

其他接口

方法引用与构造器引用

方法引用

当要传递给Lambda体的操作，已经有实现的方法了，可以使用方法引用！（实现函数接口抽象方法的参数列表，必须与方法引用方法的参数列表保持一致！）

方法引用：使用操作符 “::” 将方法名和对象或类的名字分隔开来。

如下三种主要使用情况：

1）对象 :: 实例方法
2）类名 :: 静态方法
3）类名 :: 实例方法

//对象调用实例方法，方法参数列表与函数式接口里抽象方法参数列表一致
Consumer<String> com = (s) -> System.out.println(s);
com.accept("ye");

//==================================================

Consumer<String> con = System.out::println;
con.accept("ren");

//类名调用静态方法，方法参数列表与函数式接口里抽象方法参数列表一致
Comparator<Integer> com = (x, y) -> Integer.compare(x, y);
int compare1 = com.compare(20, 30);

//==================================================
Comparator<Integer> com2 = Integer::compare;
int compare2 = com2.compare(30, 25);

//类名调用实例方法，函数式接口里抽象方法参数第一个为Lambda方法调用对象，第二个参数为调用方法的参数
BiPredicate<String, String> pre = (x, y) -> x.equals(y);
boolean test1 = pre.test("abc", "abc");

//==================================================

BiPredicate<String, String> pre2 = String::equals;
boolean test2 = pre2.test("abc", "cdf");

构造器引用

格式： ClassName::new

与函数式接口相结合，自动与函数式接口中方法兼容。

可以把构造器引用赋值给定义的方法，构造器参数列表要与接口中抽象方法的参数列表一致！

//函数式接口里抽象方法参数列表为构造器的参数列表
Function<String, String> fun = String::new;
String str = fun.apply("vip");
System.out.println(str);

数组引用

格式： type[] :: new

//函数式接口参数为数组参数
Function<Integer, String[]> fun = String[]::new;
String[] apply = fun.apply(10);
System.out.println(apply.length);

强大的Stream API

Stream介绍

Java8中有两大最为重要的改变。第一个是 Lambda 表达式；另外一个则是 Stream API(java.util.stream.*)。

Stream 是 Java8 中处理集合的关键抽象概念，它可以指定你希望对集合进行的操作，可以执行非常复杂的查找、过滤和映射数据等操作。 使用Stream API 对集合数据进行操作，就类似于使用 SQL 执行的数据库查询。也可以使用 Stream API 来并行执行操作。简而言之，Stream API 提供了一种高效且易于使用的处理数据的方式。

什么是 Stream

流是数据渠道，用于操作数据源（集合、数组等）所生成的元素序列。“集合讲的是数据，流讲的是计算！”

注意：

① Stream 自己不会存储元素

② Stream 不会改变源对象。相反，他们会返回一个持有结果的新Stream

③ Stream 操作是延迟执行的。这意味着他们会等到需要结果的时候才执行

Stream 的操作三个步骤

1）创建 Stream

​ 从一个数据源（如：集合、数组），获取一个流

2）中间操作

​ 一个中间操作链，对数据源的数据进行处理

3）终止操作(终端操作)

​ 一个终止操作，执行中间操作链，并产生结果

创建Stream

1）集合创建流：Java8 中的 Collection 接口被扩展，提供了两个获取流的方法

​ （1）default Stream stream() 返回一个顺序流

​ （2）default Stream parallelStream() 返回一个并行流

2）数组创建流：Java8 中的 Arrays 的静态方法 stream() 可以获取数组流

​ （1）static Stream stream(T[] array) 返回一个流

​ （2）重载形式，能够处理对应基本类型的数组：

​ public static IntStream stream(int[] array)

​ public static LongStream stream(long[] array)

​ public static DoubleStream stream(double[] array)

3）值创建流：可以使用静态方法 Stream.of() ， 通过显示值创建一个流。它可以接收任意数量的参数

​ （1）public static Stream of(T… values) 返回一个流

4）函数创建无限流：可以使用静态方法 Stream.iterate() 和 Stream.generate(), 创建无限流

​ （1）迭代 ：public static Stream iterate(final T seed, final UnaryOperator f)

​ （2）生成 ：public static Stream generate(Supplier s) :

Stream 的中间操作

多个中间操作可以连接起来形成一个流水线，除非流水线上触发终止操作，否则中间操作不会执行任何的处理！

而在终止操作时一次性全部处理，称为“惰性求值”。

1）筛选与切片

2）映射

3）排序

Stream的终止操作

终端操作会从流的一系列操作生成结果。其结果可以是任何不是流的值，例如：List、Integer，甚至是 void 。

1）查找与匹配

2）归约

3）收集

Collector 接口中方法的实现决定了如何对流执行收集操作(如收集到 List、Set、Map)。但是 Collectors 实用类提

供了很多静态方法，可以方便地创建常见收集器实例，具体方法与实例如下表：

并行流与串行流

并行流就是把一个内容分成多个数据块，并用不同的线程分别处理每个数据块的流。Java 8 中将并行进行了优化，我们可以很容易的对数据进行并行操作。Stream API 可以声明性地通过 parallel() 与 sequential() 在并行流与顺序流之间进行切换。