Java8 Lambda等新特性

落日映苍穹つ 2021-10-14 06:20 282阅读 0赞

Java8 是 Java 语言开发的一个主要版本。它新增了非常多的特性，这里主要认识常用的几个：

*  Lambda表达式
 *  函数式接口
 *  方法引用 
 *  接口中的默认方法
 *  新的日期 API
 *  Stream API
 *  Optional 类

### 一、Lambda 表达式 ###

Lambda 表达式的简单demo：

// 根据数组中元素的长度自然排序
 public static void main(String[] args) {
 String[] strs = new String[]{"as", "lambda", "s", "java", "ad"};
 
 //1、匿名内部类实现
 Arrays.sort(strs, new Comparator<String>() {
 @Override
 public int compare(String o1, String o2) {
 return Integer.compare(o1.length(), o2.length());
 }
 });
 System.out.println("匿名内部类实现:"+ Arrays.toString(strs));
 
 // 2、转化为Lambda 表达式1
 Arrays.sort(strs, (String o1, String o2) -> { return Integer.compare(o1.length(), o2.length()); });
 
 // 3、转化为Lambda 表达式2
 Arrays.sort(strs, (String o1, String o2) -> Integer.compare(o1.length(), o2.length()));
 
 // 4、转化为Lambda 表达式3
 Arrays.sort(strs, (o1, o2) -> Integer.compare(o1.length(), o2.length()));
 
 // 5、转化为Lambda 表达式4
 Arrays.sort(strs, Comparator.comparingInt(String::length));
 System.out.println(Arrays.toString(strs));
 }

Lambda：λ（波长单位）允许把函数作为一个方法的参数（函数作为参数传递进方法中）。

Lambda表达式：也可称为闭包，把带有参数变量的表达式称为Lambda表达式。

使用 Lambda 表达式可以使代码变的更加简洁紧凑。注意：使用 Lambda 表达式的前提：接口中有且只有一个必须需要被实现的抽象方法（后面的函数式接口）。

**1、Lambda表达式的基本语法**

Lambda表达式的基本语法：参数列表 -> 表达式；

> 语法形式为 () -> \{\}   其中 () 用来描述参数列表，\{\} 用来描述方法体，-> 为 Lambda运算符 ，读作(goes to)。

** 1）参数列表**

（1）如果没有参数，直接使用 () 括号来表示，() 不能省略。

（2）如果有一个参数，有两种写法：

如果参数写了参数类型，则必须要使用 () 括号表示，

如果参数不写参数类型，则 () 括号可以省略。

（3）如果有两个以上参数，不管参数是否写参数类型，都必须使用 () 括号表示，不能省略。

（4）如果参数要加修饰符或者标签，参数一定要加上完整类型，即：(修饰符 参数类型 参数, ... )

**2）表达式：  **demo 有体现，这里不再举例

（1）如果表达式代码块只有一行代码，\{\} 可以省略

若方法有返回值，\{\}省略时，不能使用return关键字返回，会编译报错；\{\} 不省略时，\{\}代码块中必须使用 return返回。

（2）如果表达式代码块有多行，\{\} 不能省略

若方法有返回值，\{\}代码块中必须使用 return返回一个返回值。

**3、Lambda表达式中的变量和变量作用域**

Lambda表达式中的变量有三种：

- **参数**：参数列表中的参数

- **局部变量**：表达式代码块中的定义的局部变量

- **自由变量：**不是参数也不是局部变量的外部变量

**结论：**

1）操作参数和局部变量的使用方式和普通的变量使用方式相同

2）自由变量在 Lambda表达式中使用时，不能被修改（隐式 final修饰），操作自由变量的代码块称为闭包

3）变量作用域：Lambda表达式只能引用标记了 final 的外层局部变量（即自由变量）

Lambda表达式中的自由变量会被保存（Lambda会使用一种技术保存），无论什么时候执行 Lambda表达式，都可以直接使用。

4）Lambda表达式中的 this是指：**创建 Lambda表达式的方法中的 this，指方法的该类对象**。

public class Demo {
 public static void main(String[] args) {
 User user = new User();
 user.printByCount("abc",5);
 }
 }
 
 public class User {
 public void printByCount(String str, int count) {
 /*Runnable runnable = new Runnable() {
 @Override
 public void run() {
 for (int i = 0; i < count; i++) {
 System.out.println(i + str);
 }
 }
 };*/
 Runnable runnable = () -> {
 //User tt = this; // // cn.jq.java8.User@5abfe45d
 for (int i = 0; i < count; i++) {
 //str = "aaa"; // 编译会报错：Variable used in lambda expression should be final or effectively final
 System.out.println(i + str); // cn.jq.java8.User@5abfe45d
 System.out.println(this);
 }
 };
 new Thread(runnable).start(); // 线程结束，可能for循环还没结束，Lambda表达式可访问
 }
 }

**4、方法引用：**demo 有体现，下面有说明。

方法引用通过方法的名字来指向一个方法。使用一对冒号 :: 。

**5、构造器/构造方法引用**

对于一个现有构造函数，可以利用它的名称和关键字new来创建它的一个引用ClassName::new

基本语法：类名::new

** **    构造器引用对应的函数式接口的方法格式一定是：返回一个对象并且方法没有参数。

public class Demo {
 
 public static void main(String[] args) throws UnsupportedEncodingException {
 
 //List<Integer> list2 = Utils.asList(()->{ return new LinkedList<>(); }, 1, 5, 4, 2, 4);
 // 构造方法引用
 List<Integer> list2 = Utils.asList(LinkedList::new, 1, 5, 4, 2, 4);
 System.out.println(list2.toString()); 
 
 list2 = Utils.asList(ArrayList::new, 1, 5, 4, 2, 4);
 System.out.println(list2.toString()); 
 }
 }
 
 // 根据传入的不同list对象，返回List
 public class Utils {
 public static <T> List<T> asList(MyCreator<List<T>> creator,T... a) {
 List<T> list = creator.create(); // 得到传入的对象
 System.out.println(list.getClass());
 for (T t : a) list.add(t);
 return list; // 把元素放到list并返回
 }
 }
 
 @FunctionalInterface
 public interface MyCreator<T extends List<?>> { // extends 传进来的T必须是List的子类
 T create(); //返回一个对象并且方法没有参数
 }

![20190826112032592.png][]

**6、使用** **forEach(...)****遍历集合元素**

public class Demo {
 
 public static void main(String[] args) throws UnsupportedEncodingException {
 List<Integer> list = new ArrayList<>();
 list.add(5);
 list.add(4);
 list.add(6);
 list.forEach(new Consumer<Integer>() {
 @Override
 public void accept(Integer integer) {
 System.out.println(integer);
 }
 });
 list.forEach(x -> System.out.println(x)); 
 list.forEach(System.out::println); // System.out 等价于 PrintStream对象
 
 Map<String, Object> map1 = new HashMap<>();
 Map<String, Object> map2 = new HashMap<>();
 Map<String, Object> map3 = new HashMap<>();
 map1.put("key1", "v1");
 map2.put("key2", "v2");
 map3.put("key3", "v3");
 List<Map<String, Object>> list1 = new ArrayList<>();
 list1.add(map1);
 list1.add(map2);
 list1.add(map3);
 list1.forEach(new Consumer<Map<String, Object>>() {
 @Override
 public void accept(Map<String, Object> stringObjectMap) {
 stringObjectMap.forEach(new BiConsumer<String, Object>() {
 @Override
 public void accept(String key, Object value) {
 System.out.println(key + "：" + value);
 }
 });
 }
 });
 list1.forEach(map -> {
 map.forEach((key, value) -> {
 System.out.println(key + "：" + value);
 });
 });
 
 list1.forEach(Demo::accept);
 }
 
 private static void accept(Map<String, Object> map) {
 map.forEach((key, value) -> {
 System.out.println(key + "：" + value);
 });
 }
 }

最后，使用Lambda 表达式来创建线程启动：

public static void main(String[] args) {
 new Thread(new Runnable() {
 @Override
 public void run() {
 for (int i = 0; i < 5; i++) {
 System.out.println(i);
 }
 }
 }).start();
 
 new Thread(() -> {
 for (int i = 5; i < 10; i++) {
 System.out.println(i);
 }
 }).start();
 }

### 二、函数式接口(Functional Interface) ###

**1、  函数式接口介绍 **

**      在 Java中，把有且仅有一个抽象方法的接口称为函数式接口，但是可以有多个非抽象方法的接口。**

函数式接口是Java支持函数式编程的基础，也是使用 Lambda 表达式调用的前提。

定义了一个函数式接口如下：

@FunctionalInterface
    public interface Runnable {
    
        public abstract void run();
    }

**1. 推论：**

*       1）我们能够写 Lambda表达式的地方?
 *             需要传递的参数是一个接口，并且该接口里面有且仅有一个抽象方法需要实现，即函数式接口。JAVA 8 之前一般是用匿名类实现的。
 *       2）可以在函数式接口上添加 @FunctionInreface标签（好处：检查和javadoc文档），表明这是一个函数式接口。
 *       3）无论是否标示@FunctionalInterface，只要满足函数式接口的接口，Java都会直接识别为函数式接口，
 *       4）简化函数式接口的使用是 Java中提供 Lambda表达式唯一的作用。
 *       5）可是使用接口来引用一个 Lambda表达式（反推：不知道“我是谁”）。
 *       6）函数式接口里面可以写 Object对象中的方法（理解有且仅有一个抽象方法）。

**2. 函数式接口可以对现有的函数友好地支持 Lambda表达式**

JDK 1.8 之前已有的函数式接口:

*  java.lang.Runnable
 *  java.util.concurrent.Callable
 *  java.security.PrivilegedAction
 *  java.util.Comparator
 *  java.io.FileFilter
 *  java.nio.file.PathMatcher
 *  java.lang.reflect.InvocationHandler
 *  java.beans.PropertyChangeListener
 *  java.awt.event.ActionListener
 *  javax.swing.event.ChangeListener

JDK 1.8 新增加的函数接口：java.util.function 包，专门用来支持 Java的 函数式编程，该包中的函数式接口有：

<table> 
 <tbody> 
 <tr> 
 <th>序号</th> 
 <th>接口 &amp; 描述</th> 
 </tr> 
 <tr> 
 <td>1</td> 
 <td>BiConsumer&lt;T,U&gt; 代表了一个接受两个输入参数的操作，并且不返回任何结果 </td> 
 </tr> 
 <tr> 
 <td>2</td> 
 <td>BiFunction&lt;T,U,R&gt; 代表了一个接受两个输入参数的方法，并且返回一个结果 </td> 
 </tr> 
 <tr> 
 <td>3</td> 
 <td>BinaryOperator&lt;T&gt; 代表了一个作用于于两个同类型操作符的操作，并且返回了操作符同类型的结果 </td> 
 </tr> 
 <tr> 
 <td>4</td> 
 <td>BiPredicate&lt;T,U&gt; 代表了一个两个参数的boolean值方法 </td> 
 </tr> 
 <tr> 
 <td>5</td> 
 <td>BooleanSupplier 代表了boolean值结果的提供方 </td> 
 </tr> 
 <tr> 
 <td>6</td> 
 <td>Consumer&lt;T&gt; 代表了接受一个输入参数并且无返回的操作 </td> 
 </tr> 
 <tr> 
 <td>7</td> 
 <td>DoubleBinaryOperator 代表了作用于两个double值操作符的操作，并且返回了一个double值的结果。 </td> 
 </tr> 
 <tr> 
 <td>8</td> 
 <td>DoubleConsumer 代表一个接受double值参数的操作，并且不返回结果。 </td> 
 </tr> 
 <tr> 
 <td>9</td> 
 <td>DoubleFunction&lt;R&gt; 代表接受一个double值参数的方法，并且返回结果 </td> 
 </tr> 
 <tr> 
 <td>10</td> 
 <td>DoublePredicate 代表一个拥有double值参数的boolean值方法 </td> 
 </tr> 
 <tr> 
 <td>11</td> 
 <td>DoubleSupplier 代表一个double值结构的提供方 </td> 
 </tr> 
 <tr> 
 <td>12</td> 
 <td>DoubleToIntFunction 接受一个double类型输入，返回一个int类型结果。 </td> 
 </tr> 
 <tr> 
 <td>13</td> 
 <td>DoubleToLongFunction 接受一个double类型输入，返回一个long类型结果 </td> 
 </tr> 
 <tr> 
 <td>14</td> 
 <td>DoubleUnaryOperator 接受一个参数同为类型double,返回值类型也为double 。 </td> 
 </tr> 
 <tr> 
 <td>15</td> 
 <td>Function&lt;T,R&gt; 接受一个输入参数，返回一个结果。 </td> 
 </tr> 
 <tr> 
 <td>16</td> 
 <td>IntBinaryOperator 接受两个参数同为类型int,返回值类型也为int 。 </td> 
 </tr> 
 <tr> 
 <td>17</td> 
 <td>IntConsumer 接受一个int类型的输入参数，无返回值 。 </td> 
 </tr> 
 <tr> 
 <td>18</td> 
 <td>IntFunction&lt;R&gt; 接受一个int类型输入参数，返回一个结果 。 </td> 
 </tr> 
 <tr> 
 <td>19</td> 
 <td>IntPredicate ：接受一个int输入参数，返回一个布尔值的结果。 </td> 
 </tr> 
 <tr> 
 <td>20</td> 
 <td>IntSupplier 无参数，返回一个int类型结果。 </td> 
 </tr> 
 <tr> 
 <td>21</td> 
 <td>IntToDoubleFunction 接受一个int类型输入，返回一个double类型结果 。 </td> 
 </tr> 
 <tr> 
 <td>22</td> 
 <td>IntToLongFunction 接受一个int类型输入，返回一个long类型结果。 </td> 
 </tr> 
 <tr> 
 <td>23</td> 
 <td>IntUnaryOperator 接受一个参数同为类型int,返回值类型也为int 。 </td> 
 </tr> 
 <tr> 
 <td>24</td> 
 <td>LongBinaryOperator 接受两个参数同为类型long,返回值类型也为long。 </td> 
 </tr> 
 <tr> 
 <td>25</td> 
 <td>LongConsumer 接受一个long类型的输入参数，无返回值。 </td> 
 </tr> 
 <tr> 
 <td>26</td> 
 <td>LongFunction&lt;R&gt; 接受一个long类型输入参数，返回一个结果。 </td> 
 </tr> 
 <tr> 
 <td>27</td> 
 <td>LongPredicate R接受一个long输入参数，返回一个布尔值类型结果。 </td> 
 </tr> 
 <tr> 
 <td>28</td> 
 <td>LongSupplier 无参数，返回一个结果long类型的值。 </td> 
 </tr> 
 <tr> 
 <td>29</td> 
 <td>LongToDoubleFunction 接受一个long类型输入，返回一个double类型结果。 </td> 
 </tr> 
 <tr> 
 <td>30</td> 
 <td>LongToIntFunction 接受一个long类型输入，返回一个int类型结果。 </td> 
 </tr> 
 <tr> 
 <td>31</td> 
 <td>LongUnaryOperator 接受一个参数同为类型long,返回值类型也为long。 </td> 
 </tr> 
 <tr> 
 <td>32</td> 
 <td>ObjDoubleConsumer&lt;T&gt; 接受一个object类型和一个double类型的输入参数，无返回值。 </td> 
 </tr> 
 <tr> 
 <td>33</td> 
 <td>ObjIntConsumer&lt;T&gt; 接受一个object类型和一个int类型的输入参数，无返回值。 </td> 
 </tr> 
 <tr> 
 <td>34</td> 
 <td>ObjLongConsumer&lt;T&gt; 接受一个object类型和一个long类型的输入参数，无返回值。 </td> 
 </tr> 
 <tr> 
 <td>35</td> 
 <td>Predicate&lt;T&gt; 接受一个输入参数，返回一个布尔值结果。 </td> 
 </tr> 
 <tr> 
 <td>36</td> 
 <td>Supplier&lt;T&gt; 无参数，返回一个结果。 </td> 
 </tr> 
 <tr> 
 <td>37</td> 
 <td>ToDoubleBiFunction&lt;T,U&gt; 接受两个输入参数，返回一个double类型结果 </td> 
 </tr> 
 <tr> 
 <td>38</td> 
 <td>ToDoubleFunction&lt;T&gt; 接受一个输入参数，返回一个double类型结果 </td> 
 </tr> 
 <tr> 
 <td>39</td> 
 <td>ToIntBiFunction&lt;T,U&gt; 接受两个输入参数，返回一个int类型结果。 </td> 
 </tr> 
 <tr> 
 <td>40</td> 
 <td>ToIntFunction&lt;T&gt; 接受一个输入参数，返回一个int类型结果。 </td> 
 </tr> 
 <tr> 
 <td>41</td> 
 <td>ToLongBiFunction&lt;T,U&gt; 接受两个输入参数，返回一个long类型结果。 </td> 
 </tr> 
 <tr> 
 <td>42</td> 
 <td>ToLongFunction&lt;T&gt; 接受一个输入参数，返回一个long类型结果。 </td> 
 </tr> 
 <tr> 
 <td>43</td> 
 <td>UnaryOperator&lt;T&gt; 接受一个参数为类型T,返回值类型也为T。 </td> 
 </tr> 
 </tbody> 
</table>

**2、对上面几个函数式接口的简单使用，明白其中一个思想，其他的雷同。**

**1. Predicate接口**

Predicate <T> 接口：它接受一个输入参数 T，返回一个布尔值结果。

该接口包含多种默认方法来将Predicate组合成其他复杂的逻辑（比如：与，或，非）。

test(T t)  在给定的参数上计算这个谓词。

public class LambdaDemo {
 public static void main(String[] args) {
 List<Integer> list = new ArrayList();
 list.add(1);
 list.add(2);
 list.add(3);
 list.add(4);
 // LambdaDemo.findEven(list, new Predicate<Integer>() {
 // @Override
 // public boolean test(Integer num) {
 // return num % 2 != 0;
 // }
 // });
 // Lambda表达式
 LambdaDemo.findEven(list, (num) -> {
 return num % 2 != 0;
 });
 System.out.println(list); //
 }
 
 // 定义一个方法，获取集合的偶数等
 public static void findEven(List<Integer> list, Predicate<Integer> predicate) {
 Iterator<Integer> it = list.iterator();
 while (it.hasNext()) {
 Integer integer = it.next();
 if (predicate.test(integer)) {
 it.remove();
 }
 }
 }
 }

**2. Function接口**

Function<T,R>接口，表示接受一个参数并产生结果的函数。

*  T -功能的输入类型 
 *  R -函数的结果类型

* * <table> 
 <tbody> 
 <tr> 
 <td><code>default &lt;V&gt;&nbsp;<a rel="nofollow">Function</a>&lt;<a rel="nofollow">T</a>,V&gt;</code></td> 
 <td><code><a rel="nofollow">andThen</a>(<a rel="nofollow">Function</a>&lt;? super <a rel="nofollow">R</a>,? extends V&gt;&nbsp;after)</code> 返回一个由功能首次采用该函数的输入，然后将 <code>after</code>函数的结果。 </td> 
 </tr> 
 <tr> 
 <td><code><a rel="nofollow">R</a></code></td> 
 <td><code><a rel="nofollow">apply</a>(<a rel="nofollow">T</a>&nbsp;t)</code> 将此函数应用于给定的参数。 </td> 
 </tr> 
 <tr> 
 <td><code>default &lt;V&gt;&nbsp;<a rel="nofollow">Function</a>&lt;V,<a rel="nofollow">R</a>&gt;</code></td> 
 <td><code><a rel="nofollow">compose</a>(<a rel="nofollow">Function</a>&lt;? super V,? extends <a rel="nofollow">T</a>&gt;&nbsp;before)</code> 返回一个由功能，首先应用 <code>before</code>函数的输入，然后将该函数的结果。 </td> 
 </tr> 
 <tr> 
 <td><code>static &lt;T&gt;&nbsp;<a rel="nofollow">Function</a>&lt;T,T&gt;</code></td> 
 <td><code><a rel="nofollow">identity</a>()</code> 返回一个函数，它总是返回它的输入参数。 </td> 
 </tr> 
 </tbody> 
 </table>

compose与andThen及indentity三个方法在其他函数式接口中也有，作用是一样的。

public static void main(String[] args) {
 // 定义两个Function的计算函数
 Function<Integer, Integer> f = s -> s+1;
 Function<Integer, Integer> g = s -> s * 2;
 
 /**
 * 表示执行F时，先执行G，并且执行F时使用G的输出当作输入。
 * 相当于以下代码：
 * Integer a = g.apply(1);
 * System.out.println(f.apply(a));
 */
 System.out.println(f.compose(g).apply(1)); // 3
 
 /**
 * 表示执行F的Apply后使用其返回的值当作输入再执行G的Apply；
 * 相当于以下代码
 * Integer a = f.apply(1);
 * System.out.println(g.apply(a));
 */
 System.out.println(f.andThen(g).apply(1)); // 4
 
 /**
 * identity方法会返回一个不进行任何处理的Function，即输出与输入值相等；
 */
 System.out.println(Function.identity().apply("123")); // 123
 }

**3. BiFunction接口**

BiFunction<T,U,R>接口，表示接受两个参数并产生结果的函数。

*  T -函数的第一个参数的类型 
 *  U -函数的第二个参数的类型 
 *  R -函数的结果类型

BiFunction中有一个andThen默认方法和apply(T t, U u) 抽象方法

public static void main(String[] args) {
 System.out.println(LambdaDemo.compute1(2, 3, (a, b) -> a * b)); // 6
 System.out.println(LambdaDemo.compute2(2, 3, (a, b) -> a * b, r -> r + 4)); // 10
 }
 
 // 定义一个计算两个数的方法，返回结果。计算方式自己实现
 public static int compute1(int a, int b, BiFunction<Integer, Integer, Integer> biFunction) {
 return biFunction.apply(a, b);
 }
 public static int compute2(int a, int b, BiFunction<Integer, Integer, Integer> biFunction, Function<Integer, Integer> function) {
 return biFunction.andThen(function).apply(a, b);
 }

**4. Supplier接口**

Supplier<T>接口，表示结果的供应商/供给者。只出不入，可以理解为，用来存储数据的容器，可提供其他方法使用。

*  T -结果由该供应商的类型

* * <table> 
 <tbody> 
 <tr> 
 <td><code><a rel="nofollow">T</a></code></td> 
 <td><code><a rel="nofollow">get</a>()</code> 得到一个结果。 </td> 
 </tr> 
 </tbody> 
 </table>

public static void main(String[] args) {
            Supplier supplier = new Supplier() {
                @Override
                public Object get() {
                    return new Random().nextInt();
                }
            };
            System.out.println(supplier.get());
    
            supplier = () -> new Random().nextInt();
            System.out.println(supplier.get());
        }

**5. Consumer接口**

Consumer<T>接口，表示接受一个输入参数，并返回没有结果的操作。只有输入无输出。

*  T -操作的输入类型

抽象accept方法，还有一个andThen默认方法。

public static void main(String[] args) {
            Consumer f = n -> System.out.println(n + "来了老弟");
            Consumer f2 = n -> System.out.println(n + "来了老妹");
    
            f.andThen(f2).accept("admin");
        }

**6. Comparator接口**

Consumer<T>接口，表示接受一个输入参数，并返回没有结果的操作。只有输入无输出。

*  T -操作的输入类型

public static void main(String[] args) {
 List<Integer> list = new ArrayList<>();
 list.add(1);
 list.add(4);
 list.add(3);
 list.add(2);
 
 // list.sort(new Comparator<Integer>() {
 // @Override
 // public int compare(Integer o1, Integer o2) {
 // return o1 - o2;
 // }
 // });
 
 list.sort((o1, o2) -> o1 - o2);
 System.out.println(list);
 }

**3、自定义一个函数式接口**

需求：返回输入字符串的大写

//业务应用类
    public class Demo {
        public static void main(String[] args) { 
            User user = new User();
    
            /*String upperCaseStr = user.printUpperCase("adCdefG", new InterfaceDemo() {
                @Override
                public String doUpperCase(String str) {
                    return str.toUpperCase();
                }
            });*/
    
            //String upperCaseStr = user.printUpperCase("adCdefG",(str) -> { return str.toUpperCase(); });
    
            //String upperCaseStr = user.printUpperCase("adCdefG",(str) -> str.toUpperCase());
    
            String upperCaseStr = user.printUpperCase("adCdefG",String::toUpperCase);
            System.out.println(upperCaseStr);
           // 输出结果：printUpperCase:adCdefG
           // ADCDEFG
    
        }
    
    // 操作工具类
    public class User  {
        public String printUpperCase(String str,InterfaceDemo interfaceDemo) {
            System.out.println("printUpperCase:" + str);
            return interfaceDemo.doUpperCase(str);
        }
    }
    
    // 函数式接口
    @FunctionalInterface
    public interface InterfaceDemo {
        String doUpperCase(String str);
    
        boolean equals(Object obj);  // Object类中的方法
    }

### 三、方法引用 ###

方法引用提供了非常有用的语法，可以直接引用已有Java类或对象（实例）的方法或构造器。

方法引用与Lambda 表达式一起使用，可以是代码更紧凑简洁，减少冗余。

java8里引入的一个方法引用符 ::，使用一对冒号 。 表示当Lambda 表达式创建函数式接口的实现类对象，正好Lambda 要写的抽象体是引用其他类的方法时，就可以使用。

Arrays.sort(strs, Comparator.comparingInt(String::length));

**1、静态方法引用**

> 格式：类名::方法名

注意事项：

*  被引用的方法参数列表和函数式接口中抽象方法的参数列表要一致。
 *  接口的抽象方法没有返回值，引用的方法可以有返回值也可以没有。
 *  接口的抽象方法有返回值，引用的方法必须有相同类型的返回值。

**2、对象方法引用**

> 格式：对象名::非静态方法名

注意事项与静态方法引用完全一致。

**3、构造方法引用**

> 格式：类名::new

注意事项：

*  被引用的类必须存在一个构造方法与函数式接口的抽象方法参数列表一致。

**4、数组构造方法引用**

> 格式：数据类型\[ \]::new

**5、特定类型的方法引用**

> 格式：类名::非静态方法

比如：在Comparator函数式接口的抽象方法中传入的参数有两个，可是compareToIgnoreCase()方法参数只有一个，第一个传入的参数作调用对象。这就满足了特定类型的方法引用，所以可以简化成类名::非静态方法的形式。

public static void main(String[] args) {
 ArrayList<String> list = new ArrayList<>();
 Collections.addAll(list, "sasdfa", "ASDsda", "aa", "Aa");
 
 // Collections.sort(list, String::compareToIgnoreCase);
 list.sort(String::compareToIgnoreCase);
 System.out.println(list);
 }

**6、类中方法调用父类或本类方法引用**

> 格式：
> 
>     this::方法名
> 
>     super::方法名

注意：

*  在有继承关系的类中，若方法想调用本类或父类的成员方法，在函数式接口抽象方法与成员方法参数列表相同，且返回值类型相同的情况下，也可以使用this和super的方法引用来简写原本的lambda代码。

### 四、接口中的默认方法 ###

默认方法就是一个在接口里面有了一个实现的方法。这些方法不需要接口的实现类去强制实现。只需在方法名前面加个 default 关键字即可实现默认方法。

**1、为什么要有这个特性？**

首先，之前的接口是个双刃剑，好处是面向抽象而不是面向具体编程，缺陷是，当需要修改接口时候，需要修改全部实现该接口的类，目前的 java 8 之前的集合框架没有 foreach 方法，通常能想到的解决办法是在JDK里给相关的接口添加新的方法及实现。然而，对于已经发布的版本，是没法在给接口添加新方法的同时不影响已有的实现。所以引进的默认方法。他们的目的是为了解决接口的修改与现有的实现不兼容的问题。

**2、为了解决这一问题Java 8引入了一种新的机制。**

Java 8允许在接口内声明静态方法，也可以在在接口内声明默认方法，通过默认方法可以指定接口方法的默认实现。

有了默认方法后，实现接口的类如果不显式地提供该方法的具体实现，就会自动继承默认的实现。

这种机制可以平滑地进行接口的优化和演进。同时，常见的一些设计模式被改变了，比如：工具类，适配器模式等。

**3、解决冲突方法**

Java 使用的是单继承、多实现的机制，为的是避免多继承带来的调用歧义的问题。

当接口的子类同时拥有具有相同签名的方法时，比如：多个有默认方法的接口被一个类实现的时候，默认方法的多继承问题。就需要考虑解决冲突的方案。

1.  如果两个接口中，有两个方法签名有相同的默认方法，子类必须实现冲突的默认方法，并指定使用哪个接口中的默认方法。接口名.super.默认方法();的方式手动调用需要的接口默认方法。
2.  如果父类里面有一个方法和接口中的一个默认方法有相同的方法签名，那么使用父类里面的方法。
3.  永远不要期望通过接口中的默认方法来改变 Object对象中的方法。

public class Forg extends BigMouth implements IWaterAnimal,ILandAnimal{
        @Override
        public void run() {
            System.out.println("对不起，我只会跳");
        }
    
        @Override
        public void swim() {
            System.out.println("对不起，我只会蛙泳");
        }
    
        @Override
        public void breath() {
            //IWaterAnimal.super.breath();
            ILandAnimal.super.breath();
        }
    
        public static void main(String[] args) {
            Forg forg = new Forg();
            forg.swim();
            forg.run();
            forg.breathInWater();
            forg.breathInAir();
            forg.breath();
            forg.openMouth();
            IWaterAnimal.staticMethod();
        }
    }
    
    public interface IWaterAnimal {
        void swim();
        // 默认方法
        default void breathInWater(){
            System.out.println("IWaterAnimal->breathInWater");
        }
        default void breath(){
            System.out.println("IWaterAnimal->breath");
        }
        default void openMouth(){
            System.out.println("IWaterAnimal->openMouth");
        }
    
        // 静态方法
        static void staticMethod(){
            System.out.println("IWaterAnimal->静态方法");
        }
    }
    
    public interface ILandAnimal {
        void run();
    
        default void breathInAir(){
            System.out.println("ILandAnimal->breathInAir");
        }
        default void breath(){
            System.out.println("ILandAnimal->breath");
        }
    }
    
    public class BigMouth {
        public void openMouth(){
            System.out.println("大嘴巴嘴巴大");
        }
    }

![20190820233644901.png][]

### 五、新的Date-Time API：[Java8中的时间和日期（下）][Java8] ###

Java 8通过发布新的Date-Time API (JSR 310)来进一步加强对日期与时间的处理。

在旧版的 Java 中，日期时间 API 存在诸多问题，其中有：

*  **非线程安全** − java.util.Date 是非线程安全的，所有的日期类都是可变的，这是Java日期类最大的问题之一。
 *  **设计很差** − Java的日期/时间类的定义并不一致，在java.util和java.sql的包中都有日期类，此外用于格式化和解析的类在java.text包中定义。java.util.Date同时包含日期和时间，而java.sql.Date仅包含日期，将其纳入java.sql包并不合理。另外这两个类都有相同的名字，这本身就是一个非常糟糕的设计。
 *  **时区处理麻烦** − 日期类并不提供国际化，没有时区支持，因此Java引入了java.util.Calendar和java.util.TimeZone类，但他们同样存在上述所有的问题。

Java 8 在 **java.time** 包下提供了很多新的 API。以下为两个比较重要的 API：

*  **Local(本地)** − 简化了日期时间的处理，没有时区的问题。
 *  **Zoned(时区)** − 通过制定的时区处理日期时间。

新的java.time包涵盖了所有处理日期，时间，日期/时间，时区，时刻（instants），过程（during）与时钟（clock）的操作。

### 六、Stream流API操作：[Java8 Stream API详细操作][Java8 Stream API]    ###

### 七、Optional<T> 类  ###

Java 8 引入的 Optional类。主要用来解决空指针异常（NullPointerException），空指针异常是导致Java应用程序失败的最常见原因。

Optional类可以理解为一个容器：它既可以保存类型T的对象，也可以保存null。

Optional类提供了很多有用的方法，并实现了检查空值的功能，程序员就不用显式地写空值检测的代码，再结合函数式编程，使得代码更加干净，简洁。

**1、创建一个Optional对象**

<table> 
 <tbody> 
 <tr> 
 <td><code>static &lt;T&gt;&nbsp;<a rel="nofollow">Optional</a>&lt;T&gt;</code></td> 
 <td><code><a rel="nofollow">of</a>(T&nbsp;value)</code> 返回与指定非空值的 <code>Optional</code>目前。 </td> 
 </tr> 
 <tr> 
 <td><code>static &lt;T&gt;&nbsp;<a rel="nofollow">Optional</a>&lt;T&gt;</code></td> 
 <td><code><a rel="nofollow">ofNullable</a>(T&nbsp;value)</code> 返回一个 <code>Optional</code>描述指定的值，如果非零，则返回一个空 <code>Optional</code>。 </td> 
 </tr> 
 <tr> 
 <td><code>static &lt;T&gt;&nbsp;<a rel="nofollow">Optional</a>&lt;T&gt;</code></td> 
 <td><code><a rel="nofollow">empty</a>()</code> 返回一个空 <code>Optional</code>实例。 </td> 
 </tr> 
 </tbody> 
</table>

public static void main(String[] args) {
 Optional<Integer> integer = Optional.of(10);
 Optional<String> s = Optional.ofNullable("10");
 Optional<Object> n = Optional.ofNullable(null);
 System.out.println(n); // Optional.empty
 // 如果保存的是null值，不能直接使用get方法获取，会NPE
 if (n.isPresent()) {
 System.out.println(n.get()); // 无输出
 }
 }

注意：Optional.empty() 所有保存null包装成的Optional对象，而且是单例模式的。与泛型无关。

Object o1 = Optional.<Integer>empty();
 Object o2 = Optional.<String>empty();
 System.out.println(o1 == o2);// true

**2、Optional类的常用方法**

<table> 
 <tbody> 
 <tr> 
 <td><code><a rel="nofollow">Optional</a>&lt;<a rel="nofollow">T</a>&gt;</code></td> 
 <td><code><a rel="nofollow">filter</a>(<a rel="nofollow">Predicate</a>&lt;? super <a rel="nofollow">T</a>&gt;&nbsp;predicate)</code> 如果一个值是存在的，而价值匹配给定谓词，返回一个 <code>Optional</code>描述值，否则返回一个空 <code>Optional</code>。 </td> 
 </tr> 
 <tr> 
 <td><code>&lt;U&gt;&nbsp;<a rel="nofollow">Optional</a>&lt;U&gt;</code></td> 
 <td><code><a rel="nofollow">flatMap</a>(<a rel="nofollow">Function</a>&lt;? super <a rel="nofollow">T</a>,<a rel="nofollow">Optional</a>&lt;U&gt;&gt;&nbsp;mapper)</code> 如果一个值是存在的，将提供 <code>Optional</code>-bearing映射函数，返回结果，否则返回一个空 <code>Optional</code>。 </td> 
 </tr> 
 <tr> 
 <td><code><a rel="nofollow">T</a></code></td> 
 <td><code><a rel="nofollow">get</a>()</code> 如果一个值是在这 <code>Optional</code>，返回值，否则将 <code>NoSuchElementException</code>。 </td> 
 </tr> 
 <tr> 
 <td><code>int</code></td> 
 <td><code><a rel="nofollow">hashCode</a>()</code> 返回当前值的哈希代码值，如果有的话，或0（0），如果没有价值。 </td> 
 </tr> 
 <tr> 
 <td><code>void</code></td> 
 <td><code><a rel="nofollow">ifPresent</a>(<a rel="nofollow">Consumer</a>&lt;? super <a rel="nofollow">T</a>&gt;&nbsp;consumer)</code> 如果一个值存在，调用指定的值的指定的用户，否则什么都不做。 </td> 
 </tr> 
 <tr> 
 <td><code>boolean</code></td> 
 <td><code><a rel="nofollow">isPresent</a>()</code> 返回 <code>true</code>如果有存在价值，否则 <code>false</code>。 </td> 
 </tr> 
 <tr> 
 <td><code>&lt;U&gt;&nbsp;<a rel="nofollow">Optional</a>&lt;U&gt;</code></td> 
 <td><code><a rel="nofollow">map</a>(<a rel="nofollow">Function</a>&lt;? super <a rel="nofollow">T</a>,? extends U&gt;&nbsp;mapper)</code> 如果一个值是存在的，申请提供的映射函数，如果结果不为空，返回一个 <code>Optional</code>描述结果。 </td> 
 </tr> 
 <tr> 
 <td><code><a rel="nofollow">T</a></code></td> 
 <td><code><a rel="nofollow">orElse</a>(<a rel="nofollow">T</a>&nbsp;other)</code> 如果保存的值不是null，则返回原来的值，否则返回 <code>other</code>。 </td> 
 </tr> 
 <tr> 
 <td><code><a rel="nofollow">T</a></code></td> 
 <td><code><a rel="nofollow">orElseGet</a>(<a rel="nofollow">Supplier</a>&lt;? extends <a rel="nofollow">T</a>&gt;&nbsp;other)</code> 如果保存的值不是null，则返回原来的值，否则调用 生产者函数&nbsp;并返回调用结果的。 </td> 
 </tr> 
 <tr> 
 <td><code>&lt;X extends <a rel="nofollow">Throwable</a>&gt; <a rel="nofollow">T</a></code></td> 
 <td><code><a rel="nofollow">orElseThrow</a>(<a rel="nofollow">Supplier</a>&lt;? extends X&gt;&nbsp;exceptionSupplier)</code> 如果保存的值不是null，则返回原来的值，否则抛出一个由提供的供应商创建的异常。 </td> 
 </tr> 
 </tbody> 
</table>

public static void main(String[] args) {
            Object orElse1 = Optional.ofNullable(null).orElse(getValue("orElse1"));
            String s = Optional.ofNullable("fill").orElse(getValue("orElse2"));
            System.out.println(orElse1);
            System.out.println(s);
    
            System.out.println("============");
            Object o1 = Optional.ofNullable(null).orElseGet(() -> getValue("orElseGet1"));
            String o2 = Optional.ofNullable("fill").orElseGet(() -> getValue("orElseGet2"));
            System.out.println(o1);
            System.out.println(o2);
    
            Optional.ofNullable("fill").orElseThrow(RuntimeException::new);
            Optional.ofNullable(null).orElseThrow(RuntimeException::new);
        }
        private static String getValue(String s) {
            System.out.println(s + "：我执行了");
            return s + new Random().nextInt(100);
        }

注意：orElse和orElseGet区：

*  如果Optional保存的是null值时，两者调用方法的效果一样的。
 *  如果Optional保存的不是null值时，那么orElse方法里面的代码会执行，而orElseGet方法里面的代码不会执行。
 *  另外orElse还可以放任何类型 T的值，而orElseGet必须是 Supplier函数。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNDAyODU0_size_16_color_FFFFFF_t_70][]

熟悉函数式接口的作用，使用Optional就很容易，上面使用三个方法。

**也可以参考文章：[理解、学习与使用 Java 中的 Optional ][Java _ Optional]**

### 八、Base64 : [Base64加密和解密JDK8][Base64_JDK8]          ###

在 Java8中 Base64编码已经成为Java类库的标准，且内置了Base64编码的编码器和解码器。

新的Base64API也支持URL和MINE的编码解码。

站在前辈的肩膀上，每天进步一点点

ends~

[20190826112032592.png]: /images/20211013/a8f5bc1fdb83490ca0650347b5e41580.png
[20190820233644901.png]: /images/20211013/3318e5966a8540d68b28e8b690937c52.png
[Java8]: https://blog.csdn.net/qq_42402854/article/details/81146232
[Java8 Stream API]: https://blog.csdn.net/qq_42402854/article/details/108318610
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNDAyODU0_size_16_color_FFFFFF_t_70]: /images/20211013/08868f3146004bf6a6b5a742103a0f41.png
[Java _ Optional]: https://www.cnblogs.com/zhangboyu/p/7580262.html
[Base64_JDK8]: https://blog.csdn.net/qq_42402854/article/details/99849284