司内小分享, boss
让我整理一下JAVA8新特性, 噢噢噢噢!!!还有这好事儿, 正好趁着这个机会好好学习下. 基于我不写笔记学不下去的习惯(分享也要有文档), 就出现了本篇内容. 主要讲使用条件和方式, 原理请自行Google
上篇: Lambda
表达式, Collector
, Optional
下篇: Stream
流, LocalDateTime
说明: 测试中生成box
测试数据均为一下方法生成
public static List<Box> generateBoxes() {
List<Box> boxes = new ArrayList<>();
boxes.add(new Box().setName("黄色箱子").setColor("yellow").setSize(5));
boxes.add(new Box().setName("绿色箱子").setColor("green").setSize(8));
boxes.add(new Box().setName("红色箱子").setColor("red").setSize(2));
boxes.add(new Box().setName("黑色箱子").setColor("black").setSize(6));
boxes.add(new Box().setName("紫色箱子").setColor("purple").setSize(10));
boxes.add(new Box().setName("蓝色箱子").setColor("blue").setSize(1));
return boxes;
}
一. Lambda表达式
1.1 描述
函数式编程: 允许把函数作为基本运算单元, 可以作为方法的参数,又称闭包.
方法引用: 是指如果某个方法签名和接口恰好一致(只看参数类型和返回类型,不看方法名称,也不看类的继承关系),就可以直接传入方法引用。
1.2 要求
- Lambda
函数式接口: 有且只有一个必须实现方法的接口(由于JAVA8中接口可以有了默认实现, 所以定义了一个@FunctionalInterface
注解作为函数式接口的标记)
如:Comparator
、Runnable
以及四大函数式接口Consumer
(返回void
)、Function
(返回映射泛型)、Predicate
(返回boolean
)、Supplier
(返回定义的泛型)
Lambda
表达式可以直接访问外部域变量, 但只能引用标记了final
的外层局部变 量,不能lambda
内部修改定义在域外的局部变量. - 方法引用
如果某个方法签名和接口恰好一致,就可以直接传入方法引用 - 四大函数式接口
简单的讲就是四类函数容器(容器的概念和思想很重要啊)
1.3 格式
Lambda
表达式: “->
”
方法引用: “::
”
1.4 特征
Lambda
:
可选类型声明: 不需要声明参数类型,编译器可以统一识别参数值。
可选的参数圆括号: 一个参数无需定义圆括号,但无参数或者多个参数需要定义圆括 号。
可选的大括号:如果主体包含了一个语句,就不需要使用大括号。
可选的返回关键字:如果主体只有一个表达式返回值则编译器会自动返回值,大括号需 要指定表达式返回了一个数值。- 方法引用
1)在使用lambda
表达式时, 如果匿名函数的返回值类型和参数类型都已经确定, 则可以将任何符合要求的方法以方法引用的方式传入
2)第一不关心方法名; 第二不关心类的继承关系; 第三不关心方法实现
1.5 案例
以数组、集合排序为例
Lambda
private static void lambda() {
System.out.println("源数据boxes_1:");
List<Box> boxes = GenerateUtil.generateBoxes();
System.out.println(boxes);
System.out.println("java7排序:");
// 本质是创建匿名内部类
// 编译时会生成Xxx$n.class
boxes.sort(new Comparator<Box>() {
@Override
public int compare(Box o1, Box o2) {
return o1.getSize() - o2.getSize();
}
});
System.out.println(boxes);
System.out.println("=======================================");
System.out.println("源数据boxes_1");
List<Box> boxes2 = GenerateUtil.generateBoxes();
System.out.println(boxes2);
System.out.println("java8排序:");
// 本质是匿名函数
boxes2.sort((box1, box2) -> box1.getSize() - box2.getSize());
System.out.println(boxes2);
// 特别的, 可以用来创建函数式接口的实例
Comparator<Box> comparator = (o1, o2) -> o1.getSize() - o2.getSize();
}
- 方法引用
public static int ohMyGod(Integer num1, Integer num2) {
// 为了与原数字排序方式混淆, 此处使用倒序排序
return num2 - num1;
}
private static void methodReference() {
Integer[] numbers = {5, 8, 2, 3, 4, 1, 9, 0};
Arrays.sort(numbers, LambdaDemo::ohMyGod);
// Arrays.sort(numbers, Math::max);
System.out.println(Arrays.toString(numbers));
}
如上: ohMyGod
的方法返回值和参数与compare
方法一致, 此处就可以使用方法引用, Math
的max
方法也符合要求, 也可以使用. 这两个方法名字, 继承和实现关系, 方法实现都不相同, 但不影响使用.
二. Collector
和Collectors
2.1 描述
Collector
: 可变的聚合操作, 定义一个可变容器, 将新输入的元素添加到可变容器中(可以认为是可变容器的操作容器)
Collectors
: 收集器工具类, 定义部分常用收集器
2.2 原理
有三个泛型:
T
: 元素类型
A
: 可变容器类型
R
: 结果容器类型
有五个方法:
Supplier
: 创建新的结果容器
Accumulator
: 合并元素到结果容器中
Combiner
: 合并两个结果容器
Finisher
: 将结果容器转为最终表示
Characteristics
: 给collector
设置特征值
工作原理即使用Collector中定义的方法对内容进行可达到目的性的操作
2.3 特征
有三个特征值:
CONCURRENT
: 表示结果容器只有一个
UNORDERED
: 表示流中的元素无序
IDENTITY_FINISH
: 表示中间结果容器类型与最终结果类型一致
2.4 案例
Collector
- 自定义一个实现
public class MyCollector<T> implements Collector<T, List<T>, List<T>> {
// 创建一个新容器
@Override
public Supplier<List<T>> supplier() {
System.out.println("supplier execute");
return ArrayList::new;
}
// 向容器中添加元素
@Override
public BiConsumer<List<T>, T> accumulator() {
System.out.println("accumulator execute");
return List::add;
}
// 容器合并
@Override
public BinaryOperator<List<T>> combiner() {
System.out.println("combiner execute");
return (container1, container2) -> {
container1.addAll(container2);
return container1;
};
}
// 结果容器
@Override
public Function<List<T>, List<T>> finisher() {
System.out.println("finisher execute");
return (result) -> result;
}
@Override
public Set<Characteristics> characteristics() {
return Collections.unmodifiableSet(EnumSet
.of(Collector.Characteristics.IDENTITY_FINISH));
}
}
- 自定义一个操作
public static <T, A, R> R operate(T[] ts1, A ts2, Collector<T, A, R> collector) {
// 获取一个新容器
A a = collector.supplier().get();
BiConsumer<A, T> accumulator = collector.accumulator();
// 向新容器中添加元素
for (T t : ts1) {
// 遇到c时便不再继续添加
if ("c".equals(t)) {
break;
}
accumulator.accept(a, t);
}
BinaryOperator<A> combiner = collector.combiner();
// 合并容器操作
A apply = combiner.apply(a, ts2);
Function<A, R> finisher = collector.finisher();
// 容器转为结果操作
return finisher.apply(apply);
}
- 执行
private static void myCollector() {
// 创建一个数组和一个集合, 进行操作
String[] strings = {"a", "b", "c", "d"};
List<String> strs = new ArrayList<>(Arrays.asList("e", "f", "g"));
List<String> operate = Operations.operate(strings, strs, new MyCollector<>());
System.out.println(operate);
}
- 结果
Collectors
工具集不做过多介绍
常用的方法:toXxx
,groupBy
,joining
,reducing
等
大部分的容器操作都可以通过下篇的Stream
流实现
三. Optional
3.1 描述
容器对象, 容器中的值可以为null
定义对象检测方法和对象处理方法, 用于进行对象检测(空值检测), 空值问题的解决方 案
3.2 案例
- 创建
Optional.of
: 不允许为null
值的创建方式, 会报空指针异常
Optional.ofNullable
: 允许为null
值的创建方式
Optional.empty
: 值为null
的创建方式(Optional
内部维护的空值对象)
Optional<Box> box = Optional.of(new Box());
Optional<Box> box1 = Optional.ofNullable(new Box());
Optional<Box> box2 = Optional.empty();
null
值调用
orElse
: 当前处理容器中的Optional
值为null
时, 则将orElse
的参数作为返回值
orElseGet
: 当前处理容器中的Optional
值为null
时, 则将orElseGet
中定义的方法返回值作为方法返回值
orElseThrow
: 当前处理容器中的Optional
值为null
时, 则将orElseThrow
中定义的方法返回的异常抛出
private static void orElse() {
Box b = null;
Box box1 = Optional.ofNullable(b).orElse(new Box().setName("1"));
Box box2 = Optional.ofNullable(b).orElseGet(() -> new Box().setName("2"));
Box box = Optional.ofNullable(b).orElseThrow(() -> new RuntimeException("box 不存在!"));
}
- 映射值
map
: 根据参数定义的函数, 获取值对象的相应映射值, 创建映射值的Optional
容器并返回
flagMap
: 参数定义的函数的返回值必须是Optional
容器, 方法的返回值结果都已映射值对象的Optional
容器
Optional<Box> box = Optional.of(new Box().setName("1"));
Optional<String> s1 = box.map((b) -> b.getName());
Optional<String> s2 = box.flatMap((b) -> Optional.ofNullable(b.getName()));
- 判空
isPresent
: 判断空值
ifPresent
: 判断空值, 在判断不为null
时进行处理操作
Optional<Box> box = Optional.empty();
Random random = new Random();
int i = random.nextInt();
if (i % 2 == 0) {
box = Optional.of(new Box().setName("1"));
}
System.out.println(box.isPresent() ? "不为 null" : "为 null");
box.ifPresent(System.out::println);
- 筛选
filter
: 对容器中的值进行过滤; 如果存在值符合条件, 则返回这个Optional
容器, 如果不存在, 返回Optional
的empty
对象
double random = Math.random() * 10;
Optional<Box> box = Optional.of(new Box().setName("1").setSize((int) random));
Optional<Box> box1 = box.filter(b -> b.getSize() > 4);
System.out.println(box1);
空指针解决方案演示:
User user = new User();
String s = Optional.ofNullable(user)
.map(User::getAddress)
// .orElse(new Address())
.map(Address::getProvince)
// .orElseGet(Province::new)
.flatMap((p -> {
City city = new City();
p.setCity(city);
return Optional.of(city);
}))
.map(City::getStreet)
.orElseThrow(() -> new RuntimeException("容器中值为 null"));
方式一: 添加默认值的方式
方式二: 抛异常的方式(map
方法在某次返回empry
之后, 后续的所有操作都是对empry
的操作, 除非使用flatMap
进行手动创建新的数据容器)
日 期 : 2022 − 02 − 12 \color{#00FF00}{日期:2022-02-12} 日期:2022−02−12