JDK8新特性

​ Java 是第一大编程语言和开发平台。它有助于企业降低成本、缩短开发周期、推动创新以及改善应用服务。如今全球有数百万开发人员运行着超过 51 亿个 Java 虚拟机，Java 仍是企业和开发人员的首选开发平台

课程内容的介绍

1. 了解Java发展史
2. Lambda表达式
3. 接口的增强
4. 函数式接口
5. 方法引用
6. Stream API
7. Optional
8. 新时间日期API
9. 其他新特性

一、Java发展历史

1. Java的发展历史

​ Sun公司在1991年成立了一个称为绿色计划( Green Project )的项目，由James Gosling(高斯林)博土领导，绿色计划

的目的是开发一种能够在各种消费性电子产品(机顶盒、冰箱、收音机等)上运行的程序架构。这个项目的产品就是

Java语言的前身: Oak(橡树)。Oak当时在消费品市场上并不算成功，但随着1995年互联网潮流的兴起，Oak迅速找到

了最适合自己发展的市场定位。

• JDK Beta - 1995
• JDK 1.0 - 1996年1月 (真正第一个稳定的版本JDK 1.0.2，被称作 Java 1 )
• JDK 1.1 - 1997年2月
• J2SE 1.2 - 1998年12月
• J2ME（Java 2 Micro Edition，Java 2平台的微型版），应用于移动、无线及有限资源的环境。
• J2SE（Java 2 Standard Edition，Java 2平台的标准版），应用于桌面环境。
• J2EE（Java 2 Enterprise Edition，Java 2平台的企业版），应用于基于Java的应用服务器。
• J2SE 1.3 - 2000年5月
• J2SE 1.4 - 2002年2月
• J2SE 5.0 - 2004年9月
• Java SE 6 - 2006年12月
• Java SE 7 - 2011年7月
• Java SE 8（LTS） - 2014年3月
• Java SE 9 - 2017年9月
• Java SE 10（18.3） - 2018年3月
• **Java SE 11（18.9 LTS） **- 2018年9月
• Java SE 12（19.3） - 2019年3月
• Java SE 13（19.9) - 2019年9月
• Java SE 14（20.3) - 2020年3月
• Java SE 15（20.9) - 2020年9月

​ 我们可以看到Java SE的主要版本大约每两年发布一次，直到Java SE 6到Java SE 7开始花了五年时间，之后又花了三

年时间到达Java SE 8。

2.OpenJDK和OracleJDK

2.1 Open JDK来源

​ Java 由 Sun 公司发明，Open JDK是Sun在2006年末把Java开源而形成的项目。也就是说Open JDK是Java SE平台版

的开源和免费实现，它由 SUN 和 Java 社区提供支持，2009年 Oracle 收购了 Sun 公司，自此 Java 的维护方之一的

SUN 也变成了 Oracle。

2.2 Open JDK 和 Oracle JDK的关系

​ 大多数 JDK 都是在 Open JDK 的基础上进一步编写实现的，比如 IBM J9, Oracle JDK 和 Azul Zulu, Azul Zing。

Oracle JDK完全由 Oracle 公司开发，Oracle JDK是基于Open JDK源代码的商业版本。此外，它包含闭源组件。

Oracle JDK根据二进制代码许可协议获得许可，在没有商业许可的情况下，在2019年1月之后发布的Oracle Java SE 8

的公开更新将无法用于商业或生产用途。但是 Open JDK是完全开源的，可以自由使用。

2.3 Open JDK 官网介绍

Open JDK 官网： http://openjdk.java.net/ 。

JDK Enhancement Proposals(JDK增强建议)。通俗的讲JEP就是JDK的新特性

小结

Oracle JDK是基于Open JDK源代码的商业版本。我们要学习Java新技术可以去Open JDK 官网学习。

二、Lambda表达式

1. 需求分析

​ 创建一个新的线程，指定线程要执行的任务

    public static void main(String[] args) {// 开启一个新的线程new Thread(new Runnable() {@Overridepublic void run() {System.out.println("新线程中执行的代码 : "+Thread.currentThread().getName());}}).start();System.out.println("主线程中的代码：" + Thread.currentThread().getName());}

代码分析：

1. Thread类需要一个Runnable接口作为参数，其中的抽象方法run方法是用来指定线程任务内容的核心
2. 为了指定run方法体，不得不需要Runnable的实现类
3. 为了省去定义一个Runnable 的实现类，不得不使用匿名内部类
4. 必须覆盖重写抽象的run方法，所有的方法名称，方法参数，方法返回值不得不都重写一遍，而且不能出错，
5. 而实际上，我们只在乎方法体中的代码

2.Lambda表达式初体验

Lambda表达式是一个匿名函数，可以理解为一段可以传递的代码

new Thread(() -> { System.out.println("新线程Lambda表达式..." +Thread.currentThread().getName()); }).start();

Lambda表达式的优点：简化了匿名内部类的使用，语法更加简单。

匿名内部类语法冗余，体验了Lambda表达式后，发现Lambda表达式是简化匿名内部类的一种方式。

3. Lambda的语法规则

Lambda省去了面向对象的条条框框，Lambda的标准格式由3个部分组成：

(参数类型 参数名称) -> {代码体;
}

格式说明：

• (参数类型 参数名称):参数列表
• {代码体;} :方法体
• -> : 箭头，分割参数列表和方法体

3.1 Lambda练习1

​ 练习无参无返回值的Lambda

定义一个接口

public interface UserService {void show();
}

然后创建主方法使用

public class Demo03Lambda {public static void main(String[] args) {goShow(new UserService() {@Overridepublic void show() {System.out.println("show 方法执行了...");}});System.out.println("----------");goShow(() -> { System.out.println("Lambda show 方法执行了..."); });}public static void goShow(UserService userService){userService.show();}
}

输出：

show 方法执行了...
----------
Lambda show 方法执行了...

3.2 Lambda练习2

​ 完成一个有参且有返回值得Lambda表达式案例

创建一个Person对象

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Person {private String name;private Integer age;private Integer height;}

然后我们在List集合中保存多个Person对象，然后对这些对象做根据age排序操作

    public static void main(String[] args) {List list = new ArrayList<>();list.add(new Person("周杰伦",33,175));list.add(new Person("刘德华",43,185));list.add(new Person("周星驰",38,177));list.add(new Person("郭富城",23,170));Collections.sort(list, new Comparator() {@Overridepublic int compare(Person o1, Person o2) {return o1.getAge()-o2.getAge();}});for (Person person : list) {System.out.println(person);}}

我们发现在sort方法的第二个参数是一个Comparator接口的匿名内部类，且执行的方法有参数和返回值，那么我们可以改写为Lambda表达式

    public static void main(String[] args) {List list = new ArrayList<>();list.add(new Person("周杰伦",33,175));list.add(new Person("刘德华",43,185));list.add(new Person("周星驰",38,177));list.add(new Person("郭富城",23,170));/*Collections.sort(list, new Comparator() {@Overridepublic int compare(Person o1, Person o2) {return o1.getAge()-o2.getAge();}});for (Person person : list) {System.out.println(person);}*/System.out.println("------");Collections.sort(list,(Person o1,Person o2) -> {return o1.getAge() - o2.getAge();});for (Person person : list) {System.out.println(person);}}

输出结果

Person(name=郭富城, age=23, height=170)
Person(name=周杰伦, age=33, height=175)
Person(name=周星驰, age=38, height=177)
Person(name=刘德华, age=43, height=185)

4. @FunctionalInterface注解

/*** @FunctionalInterface*    这是一个标志注解，被该注解修饰的接口只能声明一个抽象方法*/
@FunctionalInterface
public interface UserService {void show();}

5. Lambda表达式的原理

匿名内部类的本质是在编译时生成一个Class 文件。XXXXX$1.class

public class Demo01Lambda {public static void main(String[] args) {// 开启一个新的线程new Thread(new Runnable() {@Overridepublic void run() {System.out.println("新线程中执行的代码 : "+Thread.currentThread().getName());}}).start();System.out.println("主线程中的代码：" + Thread.currentThread().getName());System.out.println("---------------");/*new Thread(() -> { System.out.println("新线程Lambda表达式..." +Thread.currentThread().getName()); }).start();*/}
}

还可以通过反编译工具来查看生成的代码 XJad 工具来查看

static class Demo01Lambda$1implements Runnable
{public void run(){System.out.println((new StringBuilder()).append("新线程中执行的代码 : " ).append(Thread.currentThread().getName()).toString());}Demo01Lambda$1(){}
}

那么Lambda表达式的原理是什么呢？我们也通过反编译工具来查看

写的有Lambda表达式的class文件，我们通过XJad查看报错。这时我们可以通过JDK自带的一个工具：javap 对字节码进行反汇编操作。

javap -c -p 文件名.class-c:表示对代码进行反汇编
-p:显示所有的类和成员

反汇编的结果：

E:\workspace\OpenClassWorkSpace\JDK8Demo\target\classes\com\bobo\jdk\lambda>javap -c -p Demo03Lambda.class
Compiled from "Demo03Lambda.java"
public class com.bobo.jdk.lambda.Demo03Lambda {public com.bobo.jdk.lambda.Demo03Lambda();Code:0: aload_01: invokespecial #1                  // Method java/lang/Object."":()V4: returnpublic static void main(java.lang.String[]);Code:0: invokedynamic #2,  0              // InvokeDynamic #0:show:()Lcom/bobo/jdk/lambda/service/UserService;5: invokestatic  #3                  // Method goShow:(Lcom/bobo/jdk/lambda/service/UserService;)V8: returnpublic static void goShow(com.bobo.jdk.lambda.service.UserService);Code:0: aload_01: invokeinterface #4,  1            // InterfaceMethod com/bobo/jdk/lambda/service/UserService.show:()V6: returnprivate static void lambda$main$0();Code:0: getstatic     #5                  // Field java/lang/System.out:Ljava/io/PrintStream;3: ldc           #6                  // String Lambda show 方法执行了...5: invokevirtual #7                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V8: return
}

在这个反编译的源码中我们看到了一个静态方法 lambda$main$0()，这个方法里面做了什么事情呢？我们通过debug的方式来查看下：

上面的效果可以理解为如下：

public class Demo03Lambda {public static void main(String[] args) {....}private static void lambda$main$0();System.out.println("Lambda show 方法执行了...");}
}

为了更加直观的理解这个内容，我们可以在运行的时候添加 -Djdk.internal.lambda.dumpProxyClasses, 加上这个参数会将内部class码输出到一个文件中

java -Djdk.internal.lambda.dumpProxyClasses 要运行的包名.类名

命令执行

E:\workspace\OpenClassWorkSpace\JDK8Demo\target\classes>java -Djdk.internal.lambda.dumpProxyClasses com.bobo.jdk.lambda.Demo03Lambda
Lambda show 方法执行了...

反编译后的内容：

可以看到这个匿名的内部类实现了UserService接口，并重写了show()方法。在show方法中调用了Demo03Lambda.lambda$main$0(),也就是调用了Lambda中的内容。

public class Demo03Lambda {public static void main(String[] args) {goShow(new UserService() {@Overridepublic void show() {Demo03Lambda.lambda$main$0();}});System.out.println("----------");}public static void goShow(UserService userService){userService.show();}private static void lambda$main$0();System.out.println("Lambda show 方法执行了...");}
}

小结：

匿名内部类在编译的时候会产生一个class文件。

Lambda表达式在程序运行的时候会形成一个类。

1. 在类中新增了一个方法，这个方法的方法体就是Lambda表达式中的代码
2. 还会形成一个匿名内部类，实现接口，重写抽象方法
3. 在接口中重写方法会调用新生成的方法

6.Lambda表达式的省略写法

在lambda表达式的标准写法基础上，可以使用省略写法的规则为：

1. 小括号内的参数类型可以省略
2. 如果小括号内有且仅有一个参数，则小括号可以省略
3. 如果大括号内有且仅有一个语句，可以同时省略大括号，return 关键字及语句分号。

public class Demo05Lambda {public static void main(String[] args) {goStudent((String name,Integer age)->{return name+age+" 6666 ...";});// 省略写法goStudent((name,age)-> name+age+" 6666 ...");System.out.println("------");goOrder((String name)->{System.out.println("--->" + name);return 666;});// 省略写法goOrder(name -> {System.out.println("--->" + name);return 666;});goOrder(name ->  666);}public static void goStudent(StudentService studentService){studentService.show("张三",22);}public static void goOrder(OrderService orderService){orderService.show("李四");}}

7.Lambda表达式的使用前提

Lambda表达式的语法是非常简洁的，但是Lambda表达式不是随便使用的，使用时有几个条件要特别注意

1. 方法的参数或局部变量类型必须为接口才能使用Lambda
2. 接口中有且仅有一个抽象方法(@FunctionalInterface)

8.Lambda和匿名内部类的对比

Lambda和匿名内部类的对比

1. 所需类型不一样

   • 匿名内部类的类型可以是 类，抽象类，接口
   • Lambda表达式需要的类型必须是接口

2. 抽象方法的数量不一样

   • 匿名内部类所需的接口中的抽象方法的数量是随意的
   • Lambda表达式所需的接口中只能有一个抽象方法

3. 实现原理不一样

   • 匿名内部类是在编译后形成一个class
   • Lambda表达式是在程序运行的时候动态生成class

三、接口中新增的方法

1. JDK8中接口的新增

在JDK8中针对接口有做增强，在JDK8之前

interface 接口名{静态常量;抽象方法;
}

JDK8之后对接口做了增加，接口中可以有默认方法和静态方法

interface 接口名{静态常量;抽象方法;默认方法;静态方法;
}

2.默认方法

2.1 为什么要增加默认方法

在JDK8以前接口中只能有抽象方法和静态常量，会存在以下的问题：

如果接口中新增抽象方法，那么实现类都必须要抽象这个抽象方法，非常不利于接口的扩展的

package com.bobo.jdk.inter;public class Demo01Interface {public static void main(String[] args) {A a = new B();A c = new C();}
}interface A{void test1();// 接口中新增抽象方法，所有实现类都需要重写这个方法，不利于接口的扩展void test2();
}class B implements  A{@Overridepublic void test1() {}@Overridepublic void test2() {}
}class C implements A{@Overridepublic void test1() {}@Overridepublic void test2() {}
}

2.2 接口默认方法的格式

​ 接口中默认方法的语法格式是

interface 接口名{修饰符 default 返回值类型 方法名{方法体;}
}

package com.bobo.jdk.inter;public class Demo01Interface {public static void main(String[] args) {A a = new B();a.test3();A c = new C();c.test3();}
}interface A{void test1();// 接口中新增抽象方法，所有实现类都需要重写这个方法，不利于接口的扩展void test2();/*** 接口中定义的默认方法* @return*/public default String  test3(){System.out.println("接口中的默认方法执行了...");return "hello";}
}class B implements  A{@Overridepublic void test1() {}@Overridepublic void test2() {}@Overridepublic String test3() {System.out.println("B 实现类中重写了默认方法...");return "ok ...";}
}class C implements A{@Overridepublic void test1() {}@Overridepublic void test2() {}
}

2.3 接口中默认方法的使用

接口中的默认方法有两种使用方式

1. 实现类直接调用接口的默认方法
2. 实现类重写接口的默认方法

3. 静态方法

JDK8中为接口新增了静态方法，作用也是为了接口的扩展

3.1 语法规则

interface 接口名{修饰符 static 返回值类型 方法名{方法体;}
}

package com.bobo.jdk.inter;public class Demo01Interface {public static void main(String[] args) {A a = new B();a.test3();A c = new C();c.test3();A.test4();}
}interface A{void test1();// 接口中新增抽象方法，所有实现类都需要重写这个方法，不利于接口的扩展void test2();/*** 接口中定义的默认方法* @return*/public default String  test3(){System.out.println("接口中的默认方法执行了...");return "hello";}/*** 接口中的静态方法* @return*/public static String test4(){System.out.println("接口中的静态方法....");return "Hello";}
}class B implements  A{@Overridepublic void test1() {}@Overridepublic void test2() {}@Overridepublic String test3() {System.out.println("B 实现类中重写了默认方法...");return "ok ...";}}class C implements A{@Overridepublic void test1() {}@Overridepublic void test2() {}
}

3.2 静态方法的使用

接口中的静态方法在实现类中是不能被重写的，调用的话只能通过接口类型来实现: 接口名.静态方法名();

4. 两者的区别介绍

1. 默认方法通过实例调用，静态方法通过接口名调用
2. 默认方法可以被继承，实现类可以直接调用接口默认方法，也可以重写接口默认方法
3. 静态方法不能被继承，实现类不能重写接口的静态方法，只能使用接口名调用

四、函数式接口

1. 函数式接口的由来

​ 我们知道使用Lambda表达式的前提是需要有函数式接口，而Lambda表达式使用时不关心接口名，抽象方法名。只关心抽象方法的参数列表和返回值类型。因此为了让我们使用Lambda表达式更加的方法，在JDK中提供了大量常用的函数式接口

package com.bobo.jdk.fun;public class Demo01Fun {public static void main(String[] args) {fun1((arr)->{int sum = 0 ;for (int i : arr) {sum += i;}return sum;});}public static void fun1(Operator operator){int[] arr = {1,2,3,4};int sum = operator.getSum(arr);System.out.println("sum = " + sum);}
}/*** 函数式接口*/
@FunctionalInterface
interface Operator{int getSum(int[] arr);
}

2. 函数式接口介绍

在JDK中帮我们提供的有函数式接口，主要是在 java.util.function 包中。

2.1 Supplier

​ 无参有返回值的接口，对于的Lambda表达式需要提供一个返回数据的类型。

@FunctionalInterface
public interface Supplier {/*** Gets a result.** @return a result*/T get();
}

使用：

/*** Supplier 函数式接口的使用*/
public class SupplierTest {public static void main(String[] args) {fun1(()->{int arr[] = {22,33,55,66,44,99,10};// 计算出数组中的最大值Arrays.sort(arr);return arr[arr.length-1];});}private static void fun1(Supplier supplier){// get() 是一个无参的有返回值的 抽象方法Integer max = supplier.get();System.out.println("max = " + max);}
}

2.2 Consumer

​ 有参无返回值得接口,前面介绍的Supplier接口是用来生产数据的，而Consumer接口是用来消费数据的，使用的时候需要指定一个泛型来定义参数类型

@FunctionalInterface
public interface Consumer {/*** Performs this operation on the given argument.** @param t the input argument*/void accept(T t);
}

使用：将输入的数据统一转换为小写输出

public class ConsumerTest {public static void main(String[] args) {test(msg -> {System.out.println(msg + "-> 转换为小写：" + msg.toLowerCase());});}public static void test(Consumer consumer){consumer.accept("Hello World");}
}

默认方法:andThen

​ 如果一个方法的参数和返回值全部是Consumer类型，那么就可以实现效果，消费一个数据的时候，首先做一个操作，然后再做一个操作，实现组合，而这个方法就是Consumer接口中的default方法 andThen方法

    default Consumer andThen(Consumer after) {Objects.requireNonNull(after);return (T t) -> { accept(t); after.accept(t); };}

具体的操作

public class ConsumerAndThenTest {public static void main(String[] args) {test2(msg1->{System.out.println(msg1 + "-> 转换为小写：" + msg1.toLowerCase());},msg2->{System.out.println(msg2 + "-> 转换为大写：" + msg2.toUpperCase());});}public static void test2(Consumer c1,Consumer c2){String str = "Hello World";//c1.accept(str); // 转小写//c2.accept(str); // 转大写//c1.andThen(c2).accept(str);c2.andThen(c1).accept(str);}
}

2.3 Function

​ 有参有返回值的接口，Function接口是根据一个类型的数据得到另一个类型的数据，前者称为前置条件，后者称为后置条件。有参数有返回值。

@FunctionalInterface
public interface Function {/*** Applies this function to the given argument.** @param t the function argument* @return the function result*/R apply(T t);
}

使用：传递进入一个字符串返回一个数字

public class FunctionTest {public static void main(String[] args) {test(msg ->{return Integer.parseInt(msg);});}public static void test(Function function){Integer apply = function.apply("666");System.out.println("apply = " + apply);}
}

默认方法：andThen，也是用来进行组合操作，

    default  Function andThen(Function after) {Objects.requireNonNull(after);return (T t) -> after.apply(apply(t));}

public class FunctionAndThenTest {public static void main(String[] args) {test(msg ->{return Integer.parseInt(msg);},msg2->{return msg2 * 10;});}public static void test(Function f1,Function f2){/*Integer i1 = f1.apply("666");Integer i2 = f2.apply(i1);*/Integer i2 = f1.andThen(f2).apply("666");System.out.println("i2:" + i2);}
}

默认的compose方法的作用顺序和andThen方法刚好相反

而静态方法identity则是，输入什么参数就返回什么参数

2.4 Predicate

有参且返回值为Boolean的接口

@FunctionalInterface
public interface Predicate {/*** Evaluates this predicate on the given argument.** @param t the input argument* @return {@code true} if the input argument matches the predicate,* otherwise {@code false}*/boolean test(T t);
}

使用：

public class PredicateTest {public static void main(String[] args) {test(msg -> {return msg.length() > 3;},"HelloWorld");}private static void test(Predicate predicate,String msg){boolean b = predicate.test(msg);System.out.println("b:" + b);}
}

在Predicate中的默认方法提供了逻辑关系操作 and or negate isEquals方法

package com.bobo.jdk.fun;import java.util.function.Predicate;public class PredicateDefaultTest {public static void main(String[] args) {test(msg1 -> {return msg1.contains("H");},msg2 -> {return msg2.contains("W");});}private static void test(Predicate p1,Predicate p2){/*boolean b1 = predicate.test(msg);boolean b2 = predicate.test("Hello");*/// b1 包含H b2 包含W// p1 包含H 同时 p2 包含Wboolean bb1 = p1.and(p2).test("Hello");// p1 包含H 或者 p2 包含Wboolean bb2 = p1.or(p2).test("Hello");// p1 不包含Hboolean bb3 = p1.negate().test("Hello");System.out.println(bb1); // FALSESystem.out.println(bb2); // TRUESystem.out.println(bb3); // FALSE}
}

五、方法引用

1. 为什么要用方法引用

1.1 lambda表达式冗余

在使用Lambda表达式的时候，也会出现代码冗余的情况，比如：用Lambda表达式求一个数组的和

package com.bobo.jdk.funref;import java.util.function.Consumer;public class FunctionRefTest01 {public static void main(String[] args) {printMax(a->{// Lambda表达式中的代码和 getTotal中的代码冗余了int sum = 0;for (int i : a) {sum += i;}System.out.println("数组之和：" + sum);});}/*** 求数组中的所有元素的和* @param a*/public void getTotal(int a[]){int sum = 0;for (int i : a) {sum += i;}System.out.println("数组之和：" + sum);}private static void printMax(Consumer consumer){int[] a= {10,20,30,40,50,60};consumer.accept(a);}
}

1.2 解决方案

​ 因为在Lambda表达式中要执行的代码和我们另一个方法中的代码是一样的，这时就没有必要重写一份逻辑了，这时我们就可以“引用”重复代码

package com.bobo.jdk.funref;import java.util.function.Consumer;public class FunctionRefTest02 {public static void main(String[] args) {// :: 方法引用 也是JDK8中的新的语法printMax(FunctionRefTest02::getTotal);}/*** 求数组中的所有元素的和* @param a*/public static void getTotal(int a[]){int sum = 0;for (int i : a) {sum += i;}System.out.println("数组之和：" + sum);}private static void printMax(Consumer consumer){int[] a= {10,20,30,40,50,60};consumer.accept(a);}
}

:: 方法引用 也是JDK8中的新的语法

2. 方法引用的格式

符号表示：::

符号说明：双冒号为方法引用运算符，而它所在的表达式被称为方法引用

应用场景：如果Lambda表达式所要实现的方案，已经有其他方法存在相同的方案，那么则可以使用方法引用。

常见的引用方式：

方法引用在JDK8中使用是相当灵活的，有以下几种形式：

1. instanceName::methodName 对象::方法名

2. ClassName::staticMethodName 类名::静态方法

3. ClassName::methodName 类名::普通方法

4. ClassName::new 类名::new 调用的构造器

5. TypeName[]::new String[]::new 调用数组的构造器

2.1 对象名::方法名

这是最常见的一种用法。如果一个类中的已经存在了一个成员方法，则可以通过对象名引用成员方法

    public static void main(String[] args) {Date now = new Date();Supplier supplier = ()->{return now.getTime();};System.out.println(supplier.get());// 然后我们通过 方法引用 的方式来处理Supplier supplier1 = now::getTime;System.out.println(supplier1.get());}

方法引用的注意事项：

1. 被引用的方法，参数要和接口中的抽象方法的参数一样
2. 当接口抽象方法有返回值时，被引用的方法也必须有返回值

2.2 类名::静态方法名

也是比较常用的方式：

public class FunctionRefTest04 {public static void main(String[] args) {Supplier supplier1 = ()->{return System.currentTimeMillis();};System.out.println(supplier1.get());// 通过 方法引用 来实现Supplier supplier2 = System::currentTimeMillis;System.out.println(supplier2.get());}
}

2.3 类名::引用实例方法

​ Java面向对象中，类名只能调用静态方法，类名引用实例方法是用前提的，实际上是拿第一个参数作为方法的调用者

package com.bobo.jdk.funref;import java.util.Date;
import java.util.function.BiFunction;
import java.util.function.Function;
import java.util.function.Supplier;public class FunctionRefTest05 {public static void main(String[] args) {Function function = (s)->{return s.length();};System.out.println(function.apply("hello"));// 通过方法引用来实现Function function1 = String::length;System.out.println(function1.apply("hahahaha"));BiFunction function2 = String::substring;String msg = function2.apply("HelloWorld", 3);System.out.println(msg);}
}

2.4 类名::构造器

​ 由于构造器的名称和类名完全一致，所以构造器引用使用::new的格式使用，

public class FunctionRefTest06 {public static void main(String[] args) {Supplier sup = ()->{return new Person();};System.out.println(sup.get());// 然后通过 方法引用来实现Supplier sup1 = Person::new;System.out.println(sup1.get());BiFunction function = Person::new;System.out.println(function.apply("张三",22));}
}

2.5 数组::构造器

​ 数组是怎么构造出来的呢？

    public static void main(String[] args) {Function fun1 = (len)->{return new String[len];};String[] a1 = fun1.apply(3);System.out.println("数组的长度是：" + a1.length);// 方法引用 的方式来调用数组的构造器Function fun2 = String[]::new;String[] a2 = fun2.apply(5);System.out.println("数组的长度是：" + a2.length);}

小结：方法引用是对Lambda表达式符合特定情况下的一种缩写方式，它使得我们的Lambda表达式更加的精简，也可以理解为lambda表达式的缩写形式，不过要注意的是方法引用只能引用已经存在的方法。

六、Stream API

1.集合处理数据的弊端

​ 当我们在需要对集合中的元素进行操作的时候，除了必需的添加，删除，获取外，最典型的操作就是集合遍历，

package com.bobo.jdk.stream;import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;public class StreamTest01 {public static void main(String[] args) {// 定义一个List集合List list = Arrays.asList("张三","张三丰","成龙","周星驰");// 1.获取所有 姓张的信息List list1 = new ArrayList<>();for (String s : list) {if(s.startsWith("张")){list1.add(s);}}// 2.获取名称长度为3的用户List list2 = new ArrayList<>();for (String s : list1) {if(s.length() == 3){list2.add(s);}}// 3. 输出所有的用户信息for (String s : list2) {System.out.println(s);}}
}

上面的代码针对与我们不同的需求总是一次次的循环循环循环.这时我们希望有更加高效的处理方式，这时我们就可以通过JDK8中提供的Stream API来解决这个问题了。

Stream更加优雅的解决方案：

package com.bobo.jdk.stream;import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;public class StreamTest02 {public static void main(String[] args) {// 定义一个List集合List list = Arrays.asList("张三","张三丰","成龙","周星驰");// 1.获取所有 姓张的信息// 2.获取名称长度为3的用户// 3. 输出所有的用户信息list.stream().filter(s->s.startsWith("张")).filter(s->s.length() == 3).forEach(s->{System.out.println(s);});System.out.println("----------");list.stream().filter(s->s.startsWith("张")).filter(s->s.length() == 3).forEach(System.out::println);}
}

上面的SteamAPI代码的含义：获取流，过滤张，过滤长度，逐一打印。代码相比于上面的案例更加的简洁直观

2. Steam流式思想概述

注意：Stream和IO流(InputStream/OutputStream)没有任何关系，请暂时忘记对传统IO流的固有印象！
Stream流式思想类似于工厂车间的“生产流水线”，Stream流不是一种数据结构，不保存数据，而是对数据进行加工
处理。Stream可以看作是流水线上的一个工序。在流水线上，通过多个工序让一个原材料加工成一个商品。

Stream API能让我们快速完成许多复杂的操作，如筛选、切片、映射、查找、去除重复，统计，匹配和归约。

3. Stream流的获取方式

3.1 根据Collection获取

​ 首先，java.util.Collection 接口中加入了default方法 stream，也就是说Collection接口下的所有的实现都可以通过steam方法来获取Stream流。

    public static void main(String[] args) {List list = new ArrayList<>();list.stream();Set set = new HashSet<>();set.stream();Vector vector = new Vector();vector.stream();}

​ 但是Map接口别没有实现Collection接口，那这时怎么办呢？这时我们可以根据Map获取对应的key value的集合。

    public static void main(String[] args) {Map map = new HashMap<>();Stream stream = map.keySet().stream(); // keyStream