Java Lambda表达式与Stream API小结

约定不等于承诺〃 2022-03-10 10:50 223阅读 0赞

# 1 Lambda 表达式(Lambda Expressions) #

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

// 匿名内部类
    Runnable r = new Runnable(){
        @Override
        public void run(){
            System.out.println("Hello World!");
        }
    }
    
    // Lambda表达式
    Runnable r = () -> System.out.println("Hello World!");

看着是不是有点牛皮~？再来一个：

//原来使用匿名内部类作为参数传递
 TreeSet<String> ts = new TreeSet<>(new Comparator<String>(){
 @Override
 public int compare(String o1,String o2){
 return Integer.compare(o1.length(),o2.length());
 }
 });
 // Lambda 表达式
 TreeSet<String> ts = new TreeSet<>(
 (o1,o2) -> Integer.compare(o1.length(),o2.length());
 );

### 1.1 Lambda表达式语法 ###

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

**左侧：**指定了 Lambda 表达式需要的参数列表

**右侧：**指定了 Lambda 体，是抽象方法的实现逻辑，也即 Lambda 表达式要执行的功能。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjM2Mzk5Nw_size_16_color_FFFFFF_t_70][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjM2Mzk5Nw_size_16_color_FFFFFF_t_70 1][]

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

![20190310211546562.png][]

# 2 函数式(Functional)接口 #

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

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

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

在java.util.function包下定义了java 8 的丰富的函数式接口。如下代码便是Runnable接口的代码，有**@****FunctionalInterface注解**

@FunctionalInterface
 public interface Runnable {
 /**
 * When an object implementing interface <code>Runnable</code> is used
 * to create a thread, starting the thread causes the object's
 * <code>run</code> method to be called in that separately executing
 * thread.
 * 
 * The general contract of the method <code>run</code> is that it may
 * take any action whatsoever.
 *
 * @see java.lang.Thread#run()
 */
 public abstract void run();
 }

Java从诞生日起就是一直倡导“一切皆对象”，在java里面面向对象(OOP)编程是一切。但是随着python、scala等语言的兴起和新技术的挑战，java不得不做出调整以便支持更加广泛的技术要求，也即**java不但可以支持OOP还可以支持OOF（面向函数编程）**

在函数式编程语言当中，函数被当做一等公民对待。在将函数作为一等公民的编程语言中，Lambda表达式的类型是函数。但是在Java8中，有所不同。在Java8中，**Lambda****表达式是对象，而不是函数**，**它们必须依附于一类特别的对象类型****——函数式接口**。

简单的说，**在****Java8中，Lambda****表达式就是一个函数式接口的实例**。这就是**Lambda****表达式和函数式接口**的关系。也就是说，**只要一个对象是函数式接口的实例，那么该对象就可以用****Lambda****表达式来表示**。

所以**以前用匿名内部类表示的现在都可以用****Lambda****表达式来写**。

@FunctionalInterface
 public interface MyInterface1{
 
 public int get();
 }
 
 @FunctionalInterface
 public interface MyInterface2<T>{
 
 public T get(T t);
 }

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

<table> 
 <tbody> 
 <tr> 
 <td style="border-color:#ffffff;text-align:center;vertical-align:middle;width:172pt;"> 函数式接口 </td> 
 <td style="border-color:#ffffff;text-align:center;vertical-align:middle;width:172pt;"> 参数类型 </td> 
 <td style="border-color:#ffffff;text-align:center;vertical-align:middle;width:172pt;"> 返回类型 </td> 
 <td style="border-color:#ffffff;text-align:center;vertical-align:middle;width:172pt;"> 用途 </td> 
 </tr> 
 <tr> 
 <td style="border-color:#ffffff;text-align:center;vertical-align:middle;width:172pt;"> Consumer&lt;T&gt; 消费型接口 </td> 
 <td style="border-color:#ffffff;text-align:center;vertical-align:middle;width:172pt;"> T </td> 
 <td style="border-color:#ffffff;text-align:center;vertical-align:middle;width:172pt;"> void </td> 
 <td style="border-color:#ffffff;vertical-align:middle;width:172pt;"> 对类型为T的对象应用操作，包含方法： void accept(T t) </td> 
 </tr> 
 <tr> 
 <td style="border-color:#ffffff;text-align:center;vertical-align:middle;width:172pt;"> Supplier&lt;T&gt; 供给型接口 </td> 
 <td style="border-color:#ffffff;text-align:center;vertical-align:middle;width:172pt;"> 无 </td> 
 <td style="border-color:#ffffff;text-align:center;vertical-align:middle;width:172pt;"> T </td> 
 <td style="border-color:#ffffff;vertical-align:middle;width:172pt;"> 返回类型为T的对象，包含方法：T get() </td> 
 </tr> 
 <tr> 
 <td style="border-color:#ffffff;text-align:center;vertical-align:middle;width:172pt;"> Function&lt;T, R&gt; 函数型接口 </td> 
 <td style="border-color:#ffffff;text-align:center;vertical-align:middle;width:172pt;"> T </td> 
 <td style="border-color:#ffffff;text-align:center;vertical-align:middle;width:172pt;"> R </td> 
 <td style="border-color:#ffffff;vertical-align:middle;width:172pt;"> 对类型为T的对象应用操作，并返回结果。结果是R类型的对象。包含方法：R apply(T t) </td> 
 </tr> 
 <tr> 
 <td style="border-color:#ffffff;text-align:center;vertical-align:middle;width:172pt;"> Predicate&lt;T&gt; 断定型接口 </td> 
 <td style="border-color:#ffffff;text-align:center;vertical-align:middle;width:172pt;"> T </td> 
 <td style="border-color:#ffffff;text-align:center;vertical-align:middle;width:172pt;"> boolean </td> 
 <td style="border-color:#ffffff;vertical-align:middle;width:172pt;"> 确定类型为T的对象是否满足某约束，并返回 boolean 值。包含方法 boolean test(T t) </td> 
 </tr> 
 </tbody> 
</table>

**其他****接口**

<table> 
 <tbody> 
 <tr> 
 <td style="border-color:#ffffff;text-align:center;vertical-align:middle;width:176pt;"> 函数式接口 </td> 
 <td style="border-color:#ffffff;text-align:center;vertical-align:middle;width:113pt;"> 参数类型 </td> 
 <td style="border-color:#ffffff;text-align:center;vertical-align:middle;width:102pt;"> 返回类型 </td> 
 <td style="border-color:#ffffff;text-align:center;vertical-align:middle;width:295pt;"> 用途 </td> 
 </tr> 
 <tr> 
 <td style="border-color:#ffffff;text-align:justify;vertical-align:middle;width:176pt;"> BiFunction&lt;T, U, R&gt; </td> 
 <td style="border-color:#ffffff;text-align:center;vertical-align:middle;width:113pt;"> T, U </td> 
 <td style="border-color:#ffffff;text-align:center;vertical-align:middle;width:102pt;"> R </td> 
 <td style="border-color:#ffffff;text-align:justify;vertical-align:middle;width:295pt;"> 对类型为 T, U 参数应用操作，返回 R 类型的结果。包含方法为&nbsp; R apply(T t, U u); </td> 
 </tr> 
 <tr> 
 <td style="border-color:#ffffff;text-align:justify;vertical-align:middle;width:176pt;"> UnaryOperator&lt;T&gt; (Function子接口) </td> 
 <td style="border-color:#ffffff;text-align:center;vertical-align:middle;width:113pt;"> T </td> 
 <td style="border-color:#ffffff;text-align:center;vertical-align:middle;width:102pt;"> T </td> 
 <td style="border-color:#ffffff;text-align:justify;vertical-align:middle;width:295pt;"> 对类型为T的对象进行一元运算，并返回T类型的结果。包含方法为 T apply(T t); </td> 
 </tr> 
 <tr> 
 <td style="border-color:#ffffff;text-align:justify;vertical-align:middle;width:176pt;"> BinaryOperator&lt;T&gt; (BiFunction 子接口) </td> 
 <td style="border-color:#ffffff;text-align:center;vertical-align:middle;width:113pt;"> T, T </td> 
 <td style="border-color:#ffffff;text-align:center;vertical-align:middle;width:102pt;"> T </td> 
 <td style="border-color:#ffffff;text-align:justify;vertical-align:middle;width:295pt;"> 对类型为T的对象进行二元运算，并返回T类型的结果。包含方法为&nbsp; T apply(T t1, T t2); </td> 
 </tr> 
 <tr> 
 <td style="border-color:#ffffff;text-align:justify;vertical-align:middle;width:176pt;"> BiConsumer&lt;T, U&gt; </td> 
 <td style="border-color:#ffffff;text-align:center;vertical-align:middle;width:113pt;"> T, U </td> 
 <td style="border-color:#ffffff;text-align:center;vertical-align:middle;width:102pt;"> void </td> 
 <td style="border-color:#ffffff;text-align:justify;vertical-align:middle;width:295pt;"> 对类型为T, U 参数应用操作。包含方法为&nbsp; void accept(T t, U u) </td> 
 </tr> 
 <tr> 
 <td style="border-color:#ffffff;text-align:justify;vertical-align:middle;width:176pt;"> BiPredicate&lt;T,U&gt; </td> 
 <td style="border-color:#ffffff;text-align:center;vertical-align:middle;width:113pt;"> T,U </td> 
 <td style="border-color:#ffffff;text-align:center;vertical-align:middle;width:102pt;"> boolean </td> 
 <td style="border-color:#ffffff;text-align:justify;vertical-align:middle;width:295pt;"> 包含方法为&nbsp; boolean test(T t,U u) </td> 
 </tr> 
 <tr> 
 <td style="border-color:#ffffff;text-align:justify;vertical-align:middle;width:176pt;"> ToIntFunction&lt;T&gt; ToLongFunction&lt;T&gt; ToDoubleFunction&lt;T&gt; </td> 
 <td style="border-color:#ffffff;text-align:center;vertical-align:middle;width:113pt;"> T </td> 
 <td style="border-color:#ffffff;text-align:center;vertical-align:middle;width:102pt;"> int long double </td> 
 <td style="border-color:#ffffff;text-align:justify;vertical-align:middle;width:295pt;"> 分别计算int、long、double、值的函数 </td> 
 </tr> 
 <tr> 
 <td style="border-color:#ffffff;text-align:justify;vertical-align:middle;width:176pt;"> IntFunction&lt;R&gt; LongFunction&lt;R&gt; DoubleFunction&lt;R&gt; </td> 
 <td style="border-color:#ffffff;text-align:center;vertical-align:middle;width:113pt;"> int long double </td> 
 <td style="border-color:#ffffff;text-align:center;vertical-align:middle;width:102pt;"> R </td> 
 <td style="border-color:#ffffff;text-align:justify;vertical-align:middle;width:295pt;"> 参数分别为int、long、double 类型的函数 </td> 
 </tr> 
 </tbody> 
</table>

# 3 方法引用与构造器引用 #

### 3.1 方法引用(Method References) ###

当要传递给Lambda体的操作，已经有实现的方法了，可以使用方法引用！

方法引用就是Lambda表达式，就是函数式接口的一个实例，通过方法的名字来指向一个方法，可以认为是Lambda表达式的一个语法糖。

要求：实现抽象方法的参数列表和返回值类型，必须与方法引用的方法的参数列表和返回值类型保持一致！

方法引用：使用操作符 “**::**” 将类(或对象) 与 方法名分隔开来。

如下三种主要使用情况：

**对象****::****实例****方法名**

**类****::****静态****方法名**

**类****::****实例****方法名**

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjM2Mzk5Nw_size_16_color_FFFFFF_t_70 2][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjM2Mzk5Nw_size_16_color_FFFFFF_t_70 3][]

**注意：****当****函数****式接口方法的****第一****个****参数****是****需要****引用方法****的调用****者****，****并且第二个参数是需要引用方法****的参数****(****或无参数****)****时****：****ClassName****::****methodName。**

### **3.2 构造器****引用** ###

**格式：  ** **ClassName****::****new**

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

可以把构造器引用赋值给定义的方法，要求构造器参数列表要与接口中抽象方法的参数列表一致！且方法的返回值即为构造器对应类的对象。

![20190311093334872.png][]

### **3.3 数组引用** ###

**格式：** **type\[\] ::** **new**

![20190311093447210.png][]

# 4 Stream API #

Stream API ( java.util.stream) 把真正的函数式编程风格引入到Java中。这是目前为止对Java类库最好的补充，因为Stream API可以极大提供Java程序员的生产力，让程序员写出高效率、干净、简洁的代码。

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

Stream是数据渠道，用于操作数据源（集合、数组等）所生成的元素序列。**“集合讲的是数据****，Stream讲的是计算！****”。其特点如下：**

1）Stream 不是集合，自己不会存储元素。

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

3）Stream 操作是延迟执行的。必须搞清楚有哪些数据才能往下执行，这意味着他们会等到需要结果的时候才执行。

4）Stream只能“消费”一次，如果想继续做其他操作，需要重新获取stream对象

5）更像一个高级的iterator，单向，不可往复，数据只能遍历一次，遍历过一次后即用尽了，但是**可以并行化数据！**

### 4.1 Stream 的操作三个步骤 ###

**1-** **创建** **Stream**

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

**2-** **中间操作**

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

**3-** **终止操作****(****终端操作****)**

一旦执行终止操作，就执行中间操作链，并产生结果。之后，不会再被使用

![20190311093939699.png][]

![20190311093955933.png][]

### 4.2 创建Stream 的方式 ###

1） **通过集合**

Java8 中的 Collection 接口被扩展，提供了两个获取流的方法：

**default Stream<E> stream() :** **返回一个顺序流**

**default Stream<E>** **parallelStream****() :** **返回一个并行流**

**2） ****通过****数组**

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

**static <T> Stream<T> stream(T\[\] array):** **返回一个流**

**重载形式，能够处理对应基本类型的数组：**

public static IntStream stream(int\[\] array)

public static LongStream stream(long\[\] array)

public static DoubleStream stream(double\[\] array)

3）**通过****Stream****的****of()**

可以调用Stream类静态方法 of(), 通过显示值创建一个流。它可以接收任意数量的参数。

**public** **static<T> Stream<T> of(T... values****) :** **返回一个流**

**4）****创建无限****流**

可以使用静态方法 Stream.iterate() 和 Stream.generate(), 创建无限流。

**迭代**

**public** **static<T> Stream<T> iterate(final T seed, final** **UnaryOperator****<T> f****)**

**生成**

**public** **static<T> Stream<T> generate(Supplier<T> s****)**

### 4.3 Stream 的中间操作 ###

多个**中间操作**可以连接起来形成一个**流水线**，除非流水线上触发终止操作，否则**中间操作不会执行任何的****处理**！而在**终止操作时一次性全部****处理，称为“惰性求值”**。

**1-****筛选与切片**

<table> 
 <tbody> 
 <tr> 
 <td style="border-color:#ffffff;text-align:center;vertical-align:middle;width:164pt;"> 方&nbsp; 法 </td> 
 <td style="border-color:#ffffff;text-align:center;vertical-align:middle;width:493pt;"> 描&nbsp; 述 </td> 
 </tr> 
 <tr> 
 <td style="border-color:#ffffff;vertical-align:middle;width:164pt;"> filter(Predicate p) </td> 
 <td style="border-color:#ffffff;vertical-align:middle;width:493pt;"> 接收 Lambda ， 从流中排除某些元素 </td> 
 </tr> 
 <tr> 
 <td style="border-color:#ffffff;vertical-align:middle;width:164pt;"> distinct() </td> 
 <td style="border-color:#ffffff;vertical-align:middle;width:493pt;"> 筛选，通过流所生成元素的 hashCode() 和 equals() 去除重复元素 </td> 
 </tr> 
 <tr> 
 <td style="border-color:#ffffff;vertical-align:middle;width:164pt;"> limit(long maxSize) </td> 
 <td style="border-color:#ffffff;vertical-align:middle;width:493pt;"> 截断流，使其元素不超过给定数量 </td> 
 </tr> 
 <tr> 
 <td style="border-color:#ffffff;vertical-align:middle;width:164pt;"> skip(long n) </td> 
 <td style="border-color:#ffffff;vertical-align:middle;width:493pt;"> 跳过元素，返回一个扔掉了前 n 个元素的流。若流中元素不足 n 个，则返回一个空流。与 limit(n) 互补 </td> 
 </tr> 
 </tbody> 
</table>

filter(Predicate p)——接收 Lambda ， 从流中排除某些元素。

limit(n)——截断流，使其元素不超过给定数量。

skip(n) —— 跳过元素，返回一个扔掉了前 n 个元素的流。若流中元素不足 n 个，则返回一个空流。与 limit(n) 互补

distinct()——筛选，通过流所生成元素的 hashCode() 和 equals() 去除重复元素

**2-****映 射**

<table> 
 <tbody> 
 <tr> 
 <td style="border-color:#ffffff;text-align:center;vertical-align:middle;width:272pt;"> 方法 </td> 
 <td style="border-color:#ffffff;text-align:center;vertical-align:middle;width:357pt;"> 描述 </td> 
 </tr> 
 <tr> 
 <td style="border-color:#ffffff;vertical-align:middle;width:272pt;"> map(Function f) </td> 
 <td style="border-color:#ffffff;vertical-align:middle;width:357pt;"> 接收一个函数作为参数，该函数会被应用到每个元素上，并将其映射成一个新的元素。 </td> 
 </tr> 
 <tr> 
 <td style="border-color:#ffffff;vertical-align:middle;width:272pt;"> mapToDouble(ToDoubleFunction f) </td> 
 <td style="border-color:#ffffff;vertical-align:middle;width:357pt;"> 接收一个函数作为参数，该函数会被应用到每个元素上，产生一个新的 DoubleStream。 </td> 
 </tr> 
 <tr> 
 <td style="border-color:#ffffff;vertical-align:middle;width:272pt;"> mapToInt(ToIntFunction f) </td> 
 <td style="border-color:#ffffff;vertical-align:middle;width:357pt;"> 接收一个函数作为参数，该函数会被应用到每个元素上，产生一个新的 IntStream。 </td> 
 </tr> 
 <tr> 
 <td style="border-color:#ffffff;vertical-align:middle;width:272pt;"> mapToLong(ToLongFunction f) </td> 
 <td style="border-color:#ffffff;vertical-align:middle;width:357pt;"> 接收一个函数作为参数，该函数会被应用到每个元素上，产生一个新的 LongStream。 </td> 
 </tr> 
 <tr> 
 <td style="border-color:#ffffff;vertical-align:middle;width:272pt;"> flatMap(Function f) </td> 
 <td style="border-color:#ffffff;vertical-align:middle;width:357pt;"> 接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流连接成一个流 </td> 
 </tr> 
 </tbody> 
</table>

map(Function f)——接收一个函数作为参数，将元素转换成其他形式或提取信息，该函数会被应用到每个元素上，并将其映射成一个新的元素。

flatMap(Function f)——接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流连接成一个流。

**3-****排序**

<table> 
 <tbody> 
 <tr> 
 <td style="border-color:#ffffff;text-align:center;vertical-align:middle;width:289pt;"> 方法 </td> 
 <td style="border-color:#ffffff;text-align:center;vertical-align:middle;width:380pt;"> 描述 </td> 
 </tr> 
 <tr> 
 <td style="border-color:#ffffff;vertical-align:middle;width:289pt;"> sorted() </td> 
 <td style="border-color:#ffffff;vertical-align:middle;width:380pt;"> 产生一个新流，其中按自然顺序排序 </td> 
 </tr> 
 <tr> 
 <td style="border-color:#ffffff;vertical-align:middle;width:289pt;"> sorted(Comparator com) </td> 
 <td style="border-color:#ffffff;vertical-align:middle;width:380pt;"> 产生一个新流，其中按比较器顺序排序 </td> 
 </tr> 
 </tbody> 
</table>

sorted()——自然排序

sorted(Comparator com)——定制排序

### 4.4 **Stream** **的终止操作** ###

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

•流进行了终止操作后，不能再次使用。

**1-****匹配与查找**

<table> 
 <tbody> 
 <tr> 
 <td style="border-color:#ffffff;text-align:center;vertical-align:middle;width:335pt;"> 方法 </td> 
 <td style="border-color:#ffffff;text-align:center;vertical-align:middle;width:335pt;"> 描述 </td> 
 </tr> 
 <tr> 
 <td style="border-color:#ffffff;vertical-align:middle;width:335pt;"> allMatch(Predicate p) </td> 
 <td style="border-color:#ffffff;vertical-align:middle;width:335pt;"> 检查是否匹配所有元素 </td> 
 </tr> 
 <tr> 
 <td style="border-color:#ffffff;vertical-align:middle;width:335pt;"> anyMatch(Predicate p) </td> 
 <td style="border-color:#ffffff;vertical-align:middle;width:335pt;"> 检查是否至少匹配一个元素 </td> 
 </tr> 
 <tr> 
 <td style="border-color:#ffffff;vertical-align:middle;width:335pt;"> noneMatch(Predicate &nbsp;p) </td> 
 <td style="border-color:#ffffff;vertical-align:middle;width:335pt;"> 检查是否没有匹配所有元素 </td> 
 </tr> 
 <tr> 
 <td style="border-color:#ffffff;vertical-align:middle;width:335pt;"> findFirst() </td> 
 <td style="border-color:#ffffff;vertical-align:middle;width:335pt;"> 返回第一个元素 </td> 
 </tr> 
 <tr> 
 <td style="border-color:#ffffff;vertical-align:middle;width:335pt;"> findAny() </td> 
 <td style="border-color:#ffffff;vertical-align:middle;width:335pt;"> 返回当前流中的任意元素 </td> 
 </tr> 
 </tbody> 
</table>

allMatch(Predicate p)——检查是否匹配所有元素

anyMatch(Predicate p)——检查是否至少匹配一个元素

noneMatch(Predicate p)——检查是否没有匹配的元素

findFirst——返回第一个元素

findAny——返回当前流中的任意元素

count——返回流中元素的总个数

max(Comparator c)——返回流中最大值

min(Comparator c)——返回流中最小值

forEach(Consumer c)——内部迭代

<table> 
 <tbody> 
 <tr> 
 <td style="border-color:#ffffff;text-align:center;vertical-align:middle;width:333pt;"> 方法 </td> 
 <td style="border-color:#ffffff;text-align:center;vertical-align:middle;width:333pt;"> 描述 </td> 
 </tr> 
 <tr> 
 <td style="border-color:#ffffff;vertical-align:middle;width:333pt;"> count() </td> 
 <td style="border-color:#ffffff;vertical-align:middle;width:333pt;"> 返回流中元素总数 </td> 
 </tr> 
 <tr> 
 <td style="border-color:#ffffff;vertical-align:middle;width:333pt;"> max(Comparator c) </td> 
 <td style="border-color:#ffffff;vertical-align:middle;width:333pt;"> 返回流中最大值 </td> 
 </tr> 
 <tr> 
 <td style="border-color:#ffffff;vertical-align:middle;width:333pt;"> min(Comparator c) </td> 
 <td style="border-color:#ffffff;vertical-align:middle;width:333pt;"> 返回流中最小值 </td> 
 </tr> 
 <tr> 
 <td style="border-color:#ffffff;vertical-align:middle;width:333pt;"> forEach(Consumer c) </td> 
 <td style="border-color:#ffffff;vertical-align:middle;width:333pt;"> 内部迭代(使用 Collection 接口需要用户去做迭代，称为外部迭代。相反，Stream API 使用内部迭代——它帮你把迭代做了) </td> 
 </tr> 
 </tbody> 
</table>

**2-****归约**

<table> 
 <tbody> 
 <tr> 
 <td style="border-color:#ffffff;text-align:center;vertical-align:middle;width:289pt;"> 方法 </td> 
 <td style="border-color:#ffffff;text-align:center;vertical-align:middle;width:289pt;"> 描述 </td> 
 </tr> 
 <tr> 
 <td style="border-color:#ffffff;vertical-align:middle;width:289pt;"> reduce(T iden, BinaryOperator b) </td> 
 <td style="border-color:#ffffff;vertical-align:middle;width:289pt;"> 可以将流中元素反复结合起来，得到一个值。返回 T </td> 
 </tr> 
 <tr> 
 <td style="border-color:#ffffff;vertical-align:middle;width:289pt;"> reduce(BinaryOperator b) </td> 
 <td style="border-color:#ffffff;vertical-align:middle;width:289pt;"> 可以将流中元素反复结合起来，得到一个值。返回 Optional&lt;T&gt; </td> 
 </tr> 
 </tbody> 
</table>

reduce(T identity, BinaryOperator)——可以将流中元素反复结合起来，得到一个值。返回 T

reduce(BinaryOperator) ——可以将流中元素反复结合起来，得到一个值。返回 Optional<T>

**3-****收集**

<table> 
 <tbody> 
 <tr> 
 <td style="border-color:#ffffff;text-align:center;vertical-align:middle;width:332pt;"> 方&nbsp; 法 </td> 
 <td style="border-color:#ffffff;text-align:center;vertical-align:middle;width:332pt;"> 描&nbsp; 述 </td> 
 </tr> 
 <tr> 
 <td style="border-color:#ffffff;vertical-align:middle;width:332pt;"> collect(Collector c) </td> 
 <td style="border-color:#ffffff;vertical-align:middle;width:332pt;"> 将流转换为其他形式。接收一个 Collector接口的实现，用于给Stream中元素做汇总的方法 </td> 
 </tr> 
 </tbody> 
</table>

collect(Collector c)——将流转换为其他形式。接收一个 Collector接口的实现，用于给Stream中元素做汇总的方法

<table> 
 <tbody> 
 <tr> 
 <td style="border-color:#ffffff;text-align:justify;vertical-align:middle;width:234pt;"> 方法 </td> 
 <td style="border-color:#ffffff;text-align:justify;vertical-align:middle;width:234pt;"> 返回类型 </td> 
 <td style="border-color:#ffffff;text-align:justify;vertical-align:middle;width:234pt;"> 作用 </td> 
 </tr> 
 <tr> 
 <td style="border-color:#ffffff;text-align:justify;vertical-align:middle;width:234pt;"> toList </td> 
 <td style="border-color:#ffffff;text-align:justify;vertical-align:middle;width:234pt;"> List&lt;T&gt; </td> 
 <td style="border-color:#ffffff;text-align:justify;vertical-align:middle;width:234pt;"> 把流中元素收集到List </td> 
 </tr> 
 <tr> 
 <td colspan="3" style="border-color:#ffffff;text-align:justify;vertical-align:middle;"> List&lt;Employee&gt; emps= list.stream().collect(Collectors.toList()); </td> 
 </tr> 
 <tr> 
 <td style="border-color:#ffffff;text-align:justify;vertical-align:middle;width:234pt;"> toSet </td> 
 <td style="border-color:#ffffff;text-align:justify;vertical-align:middle;width:234pt;"> Set&lt;T&gt; </td> 
 <td style="border-color:#ffffff;text-align:justify;vertical-align:middle;width:234pt;"> 把流中元素收集到Set </td> 
 </tr> 
 <tr> 
 <td colspan="3" style="border-color:#ffffff;text-align:justify;vertical-align:middle;"> Set&lt;Employee&gt; emps= list.stream().collect(Collectors.toSet()); </td> 
 </tr> 
 <tr> 
 <td style="border-color:#ffffff;text-align:justify;vertical-align:middle;width:234pt;"> toCollection </td> 
 <td style="border-color:#ffffff;text-align:justify;vertical-align:middle;width:234pt;"> Collection&lt;T&gt; </td> 
 <td style="border-color:#ffffff;text-align:justify;vertical-align:middle;width:234pt;"> 把流中元素收集到创建的集合 </td> 
 </tr> 
 <tr> 
 <td colspan="3" style="border-color:#ffffff;text-align:justify;vertical-align:middle;"> Collection&lt;Employee&gt; emps =list.stream().collect(Collectors.toCollection(ArrayList::new)); </td> 
 </tr> 
 <tr> 
 <td style="border-color:#ffffff;text-align:justify;vertical-align:middle;width:234pt;"> counting </td> 
 <td style="border-color:#ffffff;text-align:justify;vertical-align:middle;width:234pt;"> Long </td> 
 <td style="border-color:#ffffff;text-align:justify;vertical-align:middle;width:234pt;"> 计算流中元素的个数 </td> 
 </tr> 
 <tr> 
 <td colspan="3" style="border-color:#ffffff;text-align:justify;vertical-align:middle;"> long count = list.stream().collect(Collectors.counting()); </td> 
 </tr> 
 <tr> 
 <td style="border-color:#ffffff;text-align:justify;vertical-align:middle;width:234pt;"> summingInt </td> 
 <td style="border-color:#ffffff;text-align:justify;vertical-align:middle;width:234pt;"> Integer </td> 
 <td style="border-color:#ffffff;text-align:justify;vertical-align:middle;width:234pt;"> 对流中元素的整数属性求和 </td> 
 </tr> 
 <tr> 
 <td colspan="3" style="border-color:#ffffff;text-align:justify;vertical-align:middle;"> int total=list.stream().collect(Collectors.summingInt(Employee::getSalary)); </td> 
 </tr> 
 <tr> 
 <td style="border-color:#ffffff;text-align:justify;vertical-align:middle;width:234pt;"> averagingInt </td> 
 <td style="border-color:#ffffff;text-align:justify;vertical-align:middle;width:234pt;"> Double </td> 
 <td style="border-color:#ffffff;text-align:justify;vertical-align:middle;width:234pt;"> 计算流中元素Integer属性的平均值 </td> 
 </tr> 
 <tr> 
 <td colspan="3" style="border-color:#ffffff;text-align:justify;vertical-align:middle;"> double avg = list.stream().collect(Collectors.averagingInt(Employee::getSalary)); </td> 
 </tr> 
 <tr> 
 <td style="border-color:#ffffff;text-align:justify;vertical-align:middle;width:234pt;"> summarizingInt </td> 
 <td style="border-color:#ffffff;text-align:justify;vertical-align:middle;width:234pt;"> IntSummaryStatistics </td> 
 <td style="border-color:#ffffff;text-align:justify;vertical-align:middle;width:234pt;"> 收集流中Integer属性的统计值。如：平均值 </td> 
 </tr> 
 <tr> 
 <td colspan="3" style="border-color:#ffffff;text-align:justify;vertical-align:middle;"> int SummaryStatisticsiss= list.stream().collect(Collectors.summarizingInt(Employee::getSalary)); </td> 
 </tr> 
 </tbody> 
</table>

<table> 
 <tbody> 
 <tr> 
 <td style="border-color:#ffffff;vertical-align:middle;width:233pt;"> joining </td> 
 <td style="border-color:#ffffff;vertical-align:middle;width:233pt;"> String </td> 
 <td style="border-color:#ffffff;vertical-align:middle;width:233pt;"> 连接流中每个字符串 </td> 
 </tr> 
 <tr> 
 <td colspan="3" style="border-color:#ffffff;vertical-align:middle;"> String str= list.stream().map(Employee::getName).collect(Collectors.joining()); </td> 
 </tr> 
 <tr> 
 <td style="border-color:#ffffff;vertical-align:middle;width:233pt;"> maxBy </td> 
 <td style="border-color:#ffffff;vertical-align:middle;width:233pt;"> Optional&lt;T&gt; </td> 
 <td style="border-color:#ffffff;vertical-align:middle;width:233pt;"> 根据比较器选择最大值 </td> 
 </tr> 
 <tr> 
 <td colspan="3" style="border-color:#ffffff;vertical-align:middle;"> Optional&lt;Emp&gt;max= list.stream().collect(Collectors.maxBy(comparingInt(Employee::getSalary))); </td> 
 </tr> 
 <tr> 
 <td style="border-color:#ffffff;vertical-align:middle;width:233pt;"> minBy </td> 
 <td style="border-color:#ffffff;vertical-align:middle;width:233pt;"> Optional&lt;T&gt; </td> 
 <td style="border-color:#ffffff;vertical-align:middle;width:233pt;"> 根据比较器选择最小值 </td> 
 </tr> 
 <tr> 
 <td colspan="3" style="border-color:#ffffff;vertical-align:middle;"> Optional&lt;Emp&gt; min = list.stream().collect(Collectors.minBy(comparingInt(Employee::getSalary))); </td> 
 </tr> 
 <tr> 
 <td style="border-color:#ffffff;vertical-align:middle;width:233pt;"> reducing </td> 
 <td style="border-color:#ffffff;vertical-align:middle;width:233pt;"> 归约产生的类型 </td> 
 <td style="border-color:#ffffff;vertical-align:middle;width:233pt;"> 从一个作为累加器的初始值开始，利用BinaryOperator与流中元素逐个结合，从而归约成单个值 </td> 
 </tr> 
 <tr> 
 <td colspan="3" style="border-color:#ffffff;vertical-align:middle;"> int total=list.stream().collect(Collectors.reducing(0, Employee::getSalar, Integer::sum)); </td> 
 </tr> 
 <tr> 
 <td style="border-color:#ffffff;vertical-align:middle;width:233pt;"> collectingAndThen </td> 
 <td style="border-color:#ffffff;vertical-align:middle;width:233pt;"> 转换函数返回的类型 </td> 
 <td style="border-color:#ffffff;vertical-align:middle;width:233pt;"> 包裹另一个收集器，对其结果转换函数 </td> 
 </tr> 
 <tr> 
 <td colspan="3" style="border-color:#ffffff;vertical-align:middle;"> int how= list.stream().collect(Collectors.collectingAndThen(Collectors.toList(), List::size)); </td> 
 </tr> 
 <tr> 
 <td style="border-color:#ffffff;vertical-align:middle;width:233pt;"> groupingBy </td> 
 <td style="border-color:#ffffff;vertical-align:middle;width:233pt;"> Map&lt;K, List&lt;T&gt;&gt; </td> 
 <td style="border-color:#ffffff;vertical-align:middle;width:233pt;"> 根据某属性值对流分组，属性为K，结果为V </td> 
 </tr> 
 <tr> 
 <td colspan="3" style="border-color:#ffffff;vertical-align:middle;"> Map&lt;Emp.Status, List&lt;Emp&gt;&gt; map= list.stream().collect(Collectors.groupingBy(Employee::getStatus)); </td> 
 </tr> 
 <tr> 
 <td style="border-color:#ffffff;vertical-align:middle;width:233pt;"> partitioningBy </td> 
 <td style="border-color:#ffffff;vertical-align:middle;width:233pt;"> Map&lt;Boolean, List&lt;T&gt;&gt; </td> 
 <td style="border-color:#ffffff;vertical-align:middle;width:233pt;"> 根据true或false进行分区 </td> 
 </tr> 
 <tr> 
 <td colspan="3" style="border-color:#ffffff;vertical-align:middle;"> Map&lt;Boolean,List&lt;Emp&gt;&gt; vd = list.stream().collect(Collectors.partitioningBy(Employee::getManage)); </td> 
 </tr> 
 </tbody> 
</table>

**并行****流与****串行****流**

**并行流**就是把一个内容分成多个数据块，并用不同的线程分别处理每个数据块的流。

Java 8 中将并行进行了优化，我们可以很容易的对数据进行并行操作。Stream API 可以声明性地通过 parallel() 与 sequential() 在并行流与顺序流之间进行切换。

# 5 **Optional** **类** #

到目前为止，臭名昭著的空指针异常是导致Java应用程序失败的最常见原因。以前，为了解决空指针异常，Google公司著名的Guava项目引入了Optional类，Guava通过使用检查空值的方式来防止代码污染，它鼓励程序员写更干净的代码。受到Google Guava的启发，Optional类已经成为Java 8类库的一部分。

Optional实际上是个容器：它可以保存类型T的值，或者仅仅保存null。Optional提供很多有用的方法，这样我们就不用显式进行空值检测。

Optional类的Javadoc描述如下：这是一个可以为null的容器对象。如果值存在则isPresent()方法会返回true，调用get()方法会返回该对象。

Optional<T> 类(java.util.Optional) 是一个容器类，代表一个值存在或不存在，原来用 null 表示一个值不存在，现在 Optional 可以更好的表达这个概念。并且可以避免空指针异常。

**常用方法：**

Optional.empty() : 创建一个空的 Optional 实例

Optional.of(T t) : 创建一个 Optional 实例

**Optional.ofNullable****(T** **t****):****若** **t** **不为** **null****,****创建** **Optional** **实例****,****否则****创建****空实例**

isPresent() : 判断是否包含值

T get(): 如果调用对象包含值，返回该值，否则抛异常

**orElse****(T** **t****) : ** **如果调用对象包含值，返回该值，否则返回****t**

orElseGet(Supplier s) :如果调用对象包含值，返回该值，否则返回 s 获取的值

map(Function f): 如果有值对其处理，并返回处理后的Optional，否则返回 Optional.empty()

flatMap(Function mapper):与 map 类似，要求返回值必须是Optional

Optional<Employee> op = Optional.of(new Employee(101, "张三", 18, 9999.99));
 
 Optional<String> op2 = op.map(Employee::getName);
 
 System.out.println(op2.get());
 
 Optional<String> op3 = op.flatMap((e) -> Optional.of(e.getName()));
 
 System.out.println(op3.get());

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjM2Mzk5Nw_size_16_color_FFFFFF_t_70]: /images/20220310/032d56dbbb5a4c5a9c92c5a0453321f8.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjM2Mzk5Nw_size_16_color_FFFFFF_t_70 1]: /images/20220310/bc4b5e2891f64c7aba3714912182bdb1.png
[20190310211546562.png]: /images/20220310/c1219ecf7a824685805f61a3f54f39c5.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjM2Mzk5Nw_size_16_color_FFFFFF_t_70 2]: /images/20220310/9c35034e4c054f7fb1704fd6b03a5571.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjM2Mzk5Nw_size_16_color_FFFFFF_t_70 3]: /images/20220310/9325a9e3a094490da8b759af8e95bf0d.png
[20190311093334872.png]: /images/20220310/a1d763563e4646de9a7c07c6d00c0eeb.png
[20190311093447210.png]: /images/20220310/719454ccc20440e8b7089138060bb833.png
[20190311093939699.png]: /images/20220310/05ce0a5aad5c4266a1b448c1b0e0fa4c.png
[20190311093955933.png]: /images/20220310/dd7cfacc330b4f4b94e25b20240ec71e.png