Java基础—JAVA8新特性

最新推荐文章于 2023-04-02 09:25:17 发布

PassionZheng

最新推荐文章于 2023-04-02 09:25:17 发布

阅读量139

点赞数

分类专栏： Java

本文链接：https://blog.csdn.net/select_alter_drop/article/details/99179232

版权

Java 专栏收录该内容

38 篇文章 0 订阅

订阅专栏

本单元目标

1、JAVA8的引入和新特性
2、Lambda表达式的特点和使用 ★
3、函数式接口 ★
4、方法引用
5、构造器引用和数组引用
6、Stream API ★
7、Option类

一、JAVA8的引入和新特性

2014年 jdk8 LTS ：受商业公司长期支持的版本

2017年 9月jdk9：oracle “6月版本升级计划”

2018年 3月jdk10

2018年9月 jdk11 LTS ：受商业公司长期支持的版本

2019年3月 jdk12

二、Lambda表达式的特点和使用 ★

Lambda表达式相当于匿名内部类的一个简化，是一个匿名函数，可以把 Lambda 表达式理解为是一段可以传递的代码（将代码像数据一样进行传递）：

能用Lambda表达式的地方，肯定能用匿名内部类
能用匿名内部类的地方，不一定能用Lambda表达式，其必须满足以下条件：
- 实现的接口只有一个抽象方法——即，该接口是函数式接口

2.1 引入

对比匿名内部类：

1.匿名内部类应用场景：

1）语法

类名或接口名  对象名 = new 类名或接口名(){
	//实现或重写的方法
};

new A();创建A类的对象
new A(){};创建A的子类对象

2）当做实参传递给方法或构造器 ★

//方法调用：传入接口的实现类，通过匿名内部类的方式
method(new Fly(){
	@Override
	public void f(){
		//重写的接口方法体
		System.out.println("I can fly.");
	}
});

//方法声明
public void method(Fly fly){
	fly.f();
}

//接口声明
interface Fly {
	public void f();
}

//对应的lambda表达式：括号内就是一个Fly接口的匿名内部类
method(()->System.out.println("hahah"));

区别：

匿名内部类：父类或接口的子类
Lambda表达式：只可以作为函数式接口（只能有一个抽象方式）的实现类出现

2.2 Lambda表达式语法

语法：

(参数类型 参数名,参数类型 参数名) -> {方法体的实现}

操作符为 “->” ，该操作符被称为 Lambda 操作符
左侧：指定了 Lambda 表达式需要的参数列表
右侧：指定了 Lambda 体，是抽象方法的实现逻辑，即Lambda 表达式要执行的功能

特点：

1》左侧的参数类型可以省略，因为可由编译器推断得出，称为“类型推断”
2》如果左侧就一个参数，小括号可以省略
3》如果右侧的方法体只有一条语句时，则大括号可以省略，分号也可以省略
- 如果仅有的一句话为return，则return必须省略

三、函数式(Functional)接口

1.函数式接口概述

1.what：

只有一个抽象方法的接口，称为函数式接口

2.如何理解函数式接口：

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

Lambda表达式和函数式接口的关系：

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

简单的说，在Java8中，Lambda表达式就是一个函数式接口的实例，这就是Lambda表达式和函数式接口的关系。

也就是说，只要一个对象是函数式接口的实例，那么该对象就可以用Lambda表达式来表示。所以，以前用匿名内部类表示的函数式接口，现在都可以用Lambda表达式来写。

3.特性：

可以通过 Lambda 表达式来创建该接口的对象。
- 若Lambda 表达式抛出一个受检异常(即：非运行时异常)，那么该异常需要在目标接口的抽象方法上进行声明）
一般在接口上使用@FunctionalInterface 注解：
- 这样做可以检查它是否是一个函数式接口；
- 同时 javadoc 也会包含一条声明，说明这个接口是一个函数式接口。

在这里插入图片描述

2.自定义函数式接口

@FunctionalInterface
public interface MyFunc<T> {
	public T getValue(T t);
}

3.作为参数传递Lambda表达式

在这里插入图片描述

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

4.java.util.function提供的函数式接口

基础的四个函数式接口：

Consumer消费型接口
Supplier供给型接口
Function函数型接口
Predicate断定型接口

1)消费型接口 Consumer<T>

void accept(T t);//只吃不吐

2)供给型接口 Supplier<R>

R get();//返回指定类型的值

3)函数型接口 Function<T,R>

R apply(T t);//接收一个值，返回一个值

4)断定型接口 Predicate<T>

boolean test(T t);//接收一个值，返回true/false

四、方法引用(Method References)

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

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

使用要求：

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

使用方法：使用操作符 “::” 将类或对象与其已经实现的方法名分隔开来。

对象::实例方法名
类::静态方法名
类::实例方法名

1）对象::实例方法名

lambda表达式的方法体，已经有对应对象的方法可以实现

//Consumer型函数式接口：接收一个String值处理
Consumer<String> con = x -> System.out.println(x);
//等价于：
Consumer<String> con = System.out::println;

2）类::静态方法名

lambda表达式的方法体，已经有对应类的静态方法可以实现

//比较器接口：compare方法接收两个Integer的值，进行比较
Comparator<Integer> com = (x,y) -> Integer.compare(x,y);
//等价于：
Comparator<Integer> com = Integer::compare;

3）类::实例方法名

lambda表达式的方法体，已经有对应类的实例化方法可以实现

//函数式接口BiPredicate<T,R>，返回true/false
BiPredicate<String,String> bp = (x,y) -> x.equals(y);
//等价于：
BiPredicate<String,String> bp = String::equals;

注意：当函数式接口方法的第一个参数是需要引用方法的调用者，并且第二个参数是需要引用方法的参数(或无参数)时,可以使用：类::实例方法名

ClassName::methodName

五、构造器引用和数组引用

1. 构造器引用

1）构造器引用（不就是构造方法引用）：

本质上就是Lambda表达式当做函数式接口的实例，可以作为实参传递给构造器。

2）格式：ClassName::new

对应的方法引用：类::实例方法名

lambda表达式的方法体，已经有对应类的实例化方法可以实现
只不过实例化方法是该类的构造方法

3）特性

与函数式接口相结合，自动与函数式接口中方法兼容。
可以把构造器引用赋值给定义的方法，要求:
- 构造器参数列表要与接口中抽象方法的参数列表一致！
- 且方法的返回值即为构造器对应类的对象。

//Function函数式接口：接收一个Integer，返回一个MyClass对象:
Function<Integer, MyClass> fun = n -> new MyClass(n);
//等价于：
Function<Integer, MyClass> fun = MyClass::new;

2. 数组引用

数组引用：本质上就是Lambda表达式当做函数式接口的实例，可以作为实参传递给方法或构造器。

格式：数组类型[]::new

//Function函数式接口：接收一个Integer，返回一个Integer数组:
Function<Integer, Integer[]> fun = n -> new Integer[n];
//等价于：
Function<Integer, Integer[]> fun = Integer[]::new;

总结：

1）能用Lambda表达式的，肯定能用匿名内部类
2）能用匿名内部类的，不一定能用Lambda表达式，必须满足要求：实现的接口为函数式接口
3）能用方法引用|构造器引用|数组引用的，肯定能用Lambda表达式
4）能用Lambda表达式的，不一定能用方法引用|构造器引用|数组引用，必须满足要求：
- ①Lambda体只有一句话
- ②仅有的一句话为：调用方法|调用构造器|返回新数组
- ③调用的“方法|构造器|数组”的“参数类型、返回类型”必须和抽象方法的参数类型、返回类型一致

六、Stream API ★

what:

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

Stream 是 Java8 中处理集合的关键抽象概念，它可以指定你希望对集合进行的操作，可以执行非常复杂的查找、过滤和映射数据等操作。

使用Stream API 对集合数据进行操作，就类似于使用 SQL 执行的数据库查询。也可以使用 Stream API 来并行执行操作。简言之，Stream API 提供了一种高效且易于使用的处理数据的方式。

why:为什么要使用Stream API

实际开发中，项目中多数数据源都来自于Mysql，Oracle等。但现在数据源可以更多了，有MongoDB，Redis等，而这些NoSQL的数据就需要java层面去处理。

1.好处

①采用并行化处理数据，效率更高

②方法丰富、便于使用，且采用流式编程，开发流畅

2.特点

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

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

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

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

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

3.使用步骤

1）创建Stream

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

2）中间操作【可选 0-n 个操作】

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

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

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

4.常见方法

1）开始操作：创建Stream

方式1：通过集合获取一个流

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

集合对象.stream();  --> 返回一个顺序流
集合对象.parallelStream(); --> 返回一个并行流

方式2：通过数组

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

Arrays.stream(array)

方式3：通过Stream的of()

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

语法：Stream.of(T…t)

Stream.of(2,4,6);

方式4：创建无限流

可以使用静态方法 Stream.iterate() 和 Stream.generate(), 创建无限流。
数据源不确定，元素生成是根据规则返回的；

语法：Stream.generate(Supplier s)

供给型接口 Supplier<R>

R get();//返回指定类型的值

如：生成无限的随机数

Stream.generate(Math::random);  -->生成无限个随机数的流

2）中间操作

 * Stream filter(Predicate p):过滤
 * Stream limit(long n):限制最大数量
 * Stream skip(long n):跳过指定数量
 * Stream distinct():去重，要求元素重写hashcode和equals
 * Stream map(Function):根据映射规则，映射成新元素
 * Stream flatMap(Function):根据映射规则，映射成Stream  【了解】
 * Stream sorted():自然排序，要求元素实现Comparable接口
 * Stream sorted(Comparator):定制排序

3）结束操作

 *  count()：统计个数
 *  max(Comparator):最大值  【了解 】
 *  min(Comparator):最小值   【了解】
 *  forEach(Consumer):内部迭代
 *  reduce(BinaryOperator):归约
 *  allMatch(Predicate):全部匹配 【了解】
 *  noneMatch(Predicate):全部不匹配 【了解】
 *  anyMatch(Predicate):有一个匹配即可 【了解】
 *  findFirst():返回第一个
 *  findAny()：返回任何一个
 *  collect(Collectors.toXX()):转换成集合 【了解】