这篇笔记详细介绍了Java 8的重要新特性，包括Lambda表达式、接口中的默认方法和静态方法、函数式接口、方法引用、Stream API的使用、Optional类以及新的日期时间API。Lambda简化了匿名内部类的使用，接口中的默认方法和静态方法增强了接口功能，Stream API提供了高效处理数据的手段，Optional避免了空指针异常，新日期时间API解决了旧版日期处理的诸多问题。
此笔记只为了自学&复习，同时也为能够帮助同样努力奋斗的小伙伴们。
笔记配套视频是波哥讲解的2021最新版JDK8新特性详解，笔记内容来自波哥，也自写了一些，如果觉得侵权请联系我。很感谢波哥大佬，受益颇多。
一、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 16 - 2021年 3 月
-
Java SE 17（LTS）- 2021年 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 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 class DemoLambda01 {
public static void main(String[] args) {
//开启一个线程
new Thread(new Runnable() {
@Override
public void run() {
System.out.println("线程1: " + Thread.currentThread().getName());
}
}).start();
System.out.println("主线程中的代码: " + Thread.currentThread().getName());
}
}
代码分析：
-
Thread类需要一个Runnable接口作为参数，其中的抽象方法run方法是用来指定线程任务内容的核心
-
为了指定run方法体，不得不需要Runnable的实现类
-
为了省去定义一个Runnable 的实现类，不得不使用匿名内部类
-
必须覆盖重写抽象的run方法，所有的方法名称，方法参数，方法返回值不得不都重写一遍，而且不能出错
-
实际上，我们只在乎方法体中的代码
2.Lambda表达式初体验
new Thread(()-> {
System.out.println("lambda写法的线程2: " + Thread.currentThread().getName());
}).start();
Lambda表达式是一个匿名函数，可以理解为一段可以传递的代码
Lambda表达式的优点：简化了匿名内部类的使用，语法更加简单
匿名内部类语法冗余，体验了Lambda表达式后，发现Lambda表达式是简化匿名内部类的一种方式
3. Lambda的语法规则
Lambda省去了面向对象的条条框框，Lambda的标准格式由 3 个部分组成：
(参数类型 参数名称) -> {
代码体;
}
格式说明：
-
(参数类型 参数名称)：参数列表
-
{代码体;}：方法体
-
->：箭头，分割参数列表和方法体
3.1 Lambda练习 1
无参无返回值的Lambda
//定义一个接口
public interface userService {
void show();
}
//创建主方法使用
public class DemoLambda02 {
public static void main(String[] args) {
//匿名内部类的写法
goShow(new UserService() {
@Override
public 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 class DemoLambda03 {
public static void main(String[] args) {
List<Person> list = new ArrayList<>();
list.add(new Person("张三",12,170));
list.add(new Person("李四",18,175));
list.add(new Person("王五",32,167));
// Collections.sort(list, new Comparator<Person>() {
// @Override
// public int compare(Person o1, Person o2) {
// return o1.getAge() - o2.getAge();
// }
// });
for (Person person : list) {
System.out.println(person);
}
System.out.println("--------------------------------");
// 我们发现在sort方法的第二个参数是一个Comparator接口的匿名内部类
// 且执行的方法有参数和返回值，那么我们可以改写为Lambda表达式
Collections.sort(list, (Person o1, Person o2) -> {
return o1.getAge() - o2.getAge();
});
}
}
输出：
Person(name=张三, age=12, height=170)
Person(name=李四, age=18, height=175)
Person(name=王五, age=32, height=167)
--------------------------------
4.@FunctionalInterface注解
如果UserService接口中的方法不唯一，那么在DemoLambda2中的lambda报错如下
@FunctionalInterface 这是一个标志注解，被该注解修饰的接口只能声明一个抽象方法
5. Lambda表达式的原理
匿名内部类的本质是在编译时生成一个Class 文件：xxx$1.class
还可以通过反编译工具（Java Decompiler）来查看生成的代码
写的有Lambda表达式的class文件，我们可以通过JDK自带的一个工具查看：javap 对字节码进行反汇编操作。
# -c:表示对代码进行反汇编
# -p:显示所有的类和成员
javap -c -p 文件名.class
反汇编的结果：
在这个反编译的源码中我们看到了一个静态方法lambda$main$0()，为了更加直观的理解这个内容，我们可以在运行的时候添加 -Djdk.internal.lambda.dumpProxyClasses, 加上这个参数命令会将内部class码输出到一个文件中
命令执行
java -Djdk.internal.lambda.dumpProxyClasses 要运行的包名.类名
反编译后的内容：
public class Demo03Lambda {
public static void main(String[] args) {
goShow(new UserService() {
@Override
public 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 方法执行了...");
}
}
可以看到这个匿名的内部类实现了UserService接口，并重写了show()方法。在show方法中调用了Demo03Lambda.lambda$main$0(),也就是调用了Lambda中的内容
小结：
匿名内部类在编译的时候会产生一个class文件。
Lambda表达式在程序运行的时候会形成一个类。
- 在类中新增了一个方法，这个方法的方法体就是Lambda表达式中的代码
- 还会形成一个匿名内部类，实现接口，重写抽象方法
- 在接口中重写方法会调用新生成的方法
6.Lambda表达式的省略写法
在lambda表达式的标准写法基础上，可以使用省略写法的规则为：
-
小括号内的参数类型可以省略
-
如果小括号内有且仅有一个参数，则小括号可以省略
-
如果大括号内有且仅有一个语句，可以同时省略大括号，return 关键字及语句分号。
public class DemoLambda04 {
public static void main(String[] args) {
goStudent((String name,Integer age)->{
return name+age+"666...";
});
//省略写法:小括号参数类型和大括号,分号,return都省略
goStudent((name,age)->name+age+"666...");
System.out.println("------------------------------------");
goOrder((String name)->{
System.out.println("--->"+ name);
return 666;
});
//省略写法:小括号,小括号内的参数类型
goOrder(name -> {
System.out.println("--->"+ name);
return 666;
});
}
public static void goStudent(StudentService studentService) {
studentService.show("张三",12);
}
public static void goOrder(OrderService orderService) {
orderService.show("李四");
}
}
7.Lambda表达式的使用前提
Lambda表达式的语法是非常简洁的，但是Lambda表达式不是随便使用的，使用时有几个条件要特别注意
- 方法的参数或局部变量类型必须为接口才能使用Lambda
- 接口中有且仅有一个抽象方法（@FunctionalInterface）
8.Lambda和匿名内部类的对比
Lambda和匿名内部类的对比
-
所需类型不一样
- 匿名内部类的类型可以是 类，抽象类，接口
- Lambda表达式需要的类型必须是接口
-
抽象方法的数量不一样
- 匿名内部类所需的接口中的抽象方法的数量是随意的
- Lambda表达式所需的接口中只能有一个抽象方法
-
实现原理不一样
- 匿名内部类是在编译后形成一个class
- Lambda表达式是在程序运行的时候动态生成class
三、接口中新增的方法
1. JDK8中接口的新增
在JDK8中针对接口有做增强，在JDK8之前
interface 接口名{
静态常量;
抽象方法;
}
JDK8之后对接口做了增强，接口中可以有默认方法和静态方法
interface 接口名{
静态常量;
抽象方法;
默认方法;
静态方法;
}
2.默认方法
2.1 为什么要增加默认方法
在JDK8以前接口中只能有抽象方法和静态常量，会存在以下的问题：
如果接口中新增抽象方法，那么实现类都必须要抽象这个抽象方法，非常不利于接口的扩展的
2.2 接口默认方法的格式
接口中默认方法的语法格式是
interface 接口名{
修饰符 default 返回值类型 方法名{
方法体;
}
}
public class Demo01Interface {
public static void main(String[] args) {
a a = new b();
a a1 = new c();
//这里执行的是实现类b中的重写的默认方法test3
a.test3();
//因为实现类c中没有重写test3方法，所以这里执行的是接口a中写的默认方法test3
a1.test3();
}
}
interface a{
void test1();
void test2();
/**
* 接口中定义的默认方法
*/
default String test3() {
System.out.println("接口中定义的默认方法");
return "hello";
}
}
class b implements a {
@Override
public void test1() {
}
@Override
public void test2() {
}
@Override
public String test3() {
System.out.println("在b实现类中重写了接口a中的默认方法test3");
return "ok...";
}
}
class c implements a {
@Override
public void test1() {
}
@Override
public void test2() {
}
}
2.3 接口中默认方法的使用
接口中的默认方法有两种使用方式
-
实现类直接调用接口的默认方法
-
实现类重写接口的默认方法
3. 静态方法
JDK8中为接口新增了静态方法，作用也是为了接口的扩展
3.1 语法规则
interface 接口名{
修饰符 static 返回值类型 方法名{
方法体;
}
}
3.2 静态方法的使用
接口中的静态方法在实现类中是不能被重写的，调用的话只能通过接口类型来实现: 接口名.静态方法名();
4. 两者的区别介绍
-
默认方法通过实例调用，静态方法通过接口名调用
-
默认方法可以被实现类继承，实现类可以直接调用接口默认方法，也可以重写接口默认方法
-
静态方法不能被实现类继承，实现类不能重写接口的静态方法，只能使用接口名调用
四、函数式接口
1. 函数式接口的由来
我们知道使用Lambda表达式的前提是需要有函数式接口，而Lambda表达式使用时不关心接口名，抽象方法名。只关心抽象方法的参数列表和返回值类型。因此为了让我们使用Lambda表达式更佳的方法，在JDK中提供了大量常用的函数式接口
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<T> {
/**
* Gets a result.
*
* @return a result
*/
T get();
}
使用：
public class SupplierTest {
public static void main(String[] args) {
fun1(()->{
int[] arr = {
22,31,213,11};
//计算出数组中的最大值
Arrays.sort(arr);
return arr[arr.length-1];
});
}
private static void fun1(Supplier<Integer> supplier) {
//get() 是一个无参有返回值的抽象方法
Integer max = supplier.get();
System.out.println("max = " + max);
}
}
2.2 Consumer
有参无返回值得接口,前面介绍的Supplier接口是用来生产数据的，而Consumer接口是用来消费数据的，使用的时候需要指定一个泛型来定义参数类型
@FunctionalInterface
public interface Consumer<T> {
/**
* 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<String> consumer) {
consumer.accept("Hello World");
}
}
默认方法：andThen
如果一个方法的参数和返回值全部是Consumer类型，那么就可以实现效果，消费一个数据的时候，首先做一个操作，然后再做一个操作，实现组合，而这个方法就是Consumer接口中的default方法andThen方法
使用：
public class ConsumerAndThenTest {
public static void main(String[] args) {
test2(msg1 -> System.out.println(msg1.toLowerCase()),
msg2-> System.out.println(msg2.toUpperCase()));
}
public static void test2(Consumer<String> c1, Consumer<String> c2) {
String str = "Hello World";
//转小写
// c1.accept(str);
//转大写
// c2.accept(str);
//先转小写,再转大写
c1.andThen(c2).accept(str);
}
}
2.3 Function
有参有返回值的接口，Function接口是根据一个类型的数据得到另一个类型的数据，前者称为前置条件，后者称为后置条件。有参数有返回值。
**使用：**传递进入一个字符串返回一个数字
public class FunctionTest {
public static void main(String[] args) {
test(msg -> Integer.parseInt(msg));
}
public static void test(Function<String,Integer> function) {
Integer apply = function.apply("666");
System.out.println("apply = " + apply);
}
}
默认方法：andThen，也是用来进行组合操作。
默认的compose方法的作用顺序和andThen方法刚好相反，而静态方法identity则是输入什么参数就返回什么参数。
2.4 Predicate
有参且返回值为Boolean的接口，在Predicate中的默认方法也提供了逻辑关系操作 and or negate isEquals方法
public class PredicateTest {
public static void main(String[] args) {
test(msg -> msg.length()<3,"hello");
}
public static void test(Predicate<String> predicate,String msg) {
boolean b = predicate.test(msg);
System.out.println("b: " + b);
}
}
五、方法引用
1. 为什么要用方法引用
1.1 lambda表达式冗余
在使用Lambda表达式的时候，也会出现代码冗余的情况，比如：用Lambda表达式求一个数组的和
public class FunctionRefTest01 {
public static void main(String[] args) {
//lambda和getTotal方法冗余了
printMax(a -> {
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<int[]> consumer) {
int[] a = {
10, 20, 30, 40, 50};
consumer.accept(a);
}
}
1.2 解决方案
因为在Lambda表达式中要执行的代码和我们另一个方法中的代码是一样的，这时就没有必要重写一份逻辑了，这时我们就可以“引
最低0.47元/天 解锁文章
扫一扫
845
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
