java编程之Lambda、Stream、Optional
代码整洁之道
Lambda
Lambda 表达式，也可称为闭包，它是推动 Java 8 发布的最重要新特性。
Lambda 允许把函数作为一个方法的参数（函数作为参数传递进方法中）。
使用 Lambda 表达式可以使代码变的更加简洁紧凑。 -- 摘自runoob
可以理解lambda表达式为方法接口，具体中只有一个方法，当传入这个方法体时候就代表此方法，如下代码所示
// 接口类
@FunctionalInterface
interface Lu {
void speak(String str);
}
// 通过 -> 指向具体方法 , 多行可以用{}
Lu lu = str -> System.out.println(str);
lu.speak("abc");
// 或者通过方法指向 class::Method
interface MyComparet<T> {
Object compare(int x, int y);
}
class NumberComparetor {
public static int compareMax(int i, int j) {
return i > j ? i : j;
}
}
// 将NumberComparetor::compareMax方法指向 MyComparet默认实现方法，就可以直接调用
MyComparet comparet = NumberComparetor::compareMax;
System.out.println(comparet.compare(1, 2));
使用 Lambda 表达式需要注意以下两点：
- Lambda 表达式主要用来定义行内执行的方法类型接口，例如，一个简单方法接口。在上面例子中，我们使用各种类型的Lambda表达式来定义MathOperation接口的方法。然后我们定义了sayMessage的执行。
- Lambda 表达式免去了使用匿名方法的麻烦，并且给予Java简单但是强大的函数化的编程能力。
Stream流
什么是Stream流
Java8中的Stream是对容器对象功能的增强，它专注于对容器对象进行各种非常便利、高效的聚合操作（aggregate operation），或者大批量数据操作 (bulk data operation)。Stream API借助于同样新出现的Lambda表达式，极大的提高编程效率和程序可读性。同时，它提供串行和并行两种模式进行汇聚操作，并发模式能够充分利用多核处理器的优势，使用fork/join并行方式来拆分任务和加速处理过程。通常，编写并行代码很难而且容易出错, 但使用Stream API无需编写一行多线程的代码，就可以很方便地写出高性能的并发程序。所以说，Java8中首次出现的 java.util.stream是一个函数式语言+多核时代综合影响的产物。
流的创建
- 集合生成，目前最常用的一种
List<Integer> integerList = Arrays.asList(1, 2, 3, 4, 5, 6);
Stream<Integer> stream = integerList.stream();
- 数组生成
int[] intArr = {1, 2, 3, 4, 5, 6};
IntStream stream = Arrays.stream(intArr);
- 文件生成
Stream<String> lines = Files.lines(Paths.get("data.txt"), Charset.defaultCharset());
流的操作
0.数据源对象
// 基础操作对象
List<Integer> list = Arrays.asList(1, 1, 2, 3, 5, 7, 4, 5, 6, 7);
// 集合操作对象 Student类有name和age两个属性
List<Student> studentList = Arrays.asList(new Student("张三",18),
new Student("李四",19),new Student("王五",8),new Student("孙七",66));
1.filter过滤
List<Integer> collect = list.stream().filter(e -> {
return e < 5; // 元素必须小于5
}).collect(Collectors.toList());
collect.forEach(e -> System.out.print(e+"-"));
输出： 1-1-2-3-4-
2.distinct 去重
Stream<Integer> distinct = list.stream().distinct();
distinct.forEach(e -> System.out.print(e+"-"));
输出： 1-2-3-5-7-4-6-
3.limit 返回指定个数
Stream<Integer> limit = list.stream().limit(5);
limit.forEach(e -> System.out.print(e+"-"));
输出：1-1-2-3-5-
4.skip 跳过指定数量
Stream<Integer> skip = list.stream().skip(3); // 跳过前3位
skip.forEach(e -> System.out.print(e+"-"));
输出： 3-5-7-4-5-6-7-
5.Map 流映射--字段属性筛选
List<String> studentName = studentList.stream().map(Student::getName).collect(Collectors.toList());
studentName.forEach(e -> System.out.print(e+"-"));
输出：张三-李四-王五-孙七 name组成的集合
6.reduce 元素进行计算，初始为0， 后面是计算方式 可以 sum , max , min ... ...
// sum 累计求和
Integer sumReduce = list.stream().reduce(0, Integer::sum);
System.out.println(sumReduce);
输出：41
7.max/min 对比 , 返回为option
// 跳过5位后， min 取最小
Integer min = list.stream().skip(5).min(Integer::compareTo).get();
System.out.println(min);
输出： 4
8.collect 返回集合
// 转Set集合
Set<Integer> setCollect = list.stream().collect(Collectors.toSet());
setCollect.forEach(e -> System.out.print(e+"-"));
输出： 1-2-3-4-5-6-7-
9.join 数据拼接
String joining = list.stream().map(String::valueOf).collect(Collectors.joining("-"));
System.out.println(joining);
输出：1-1-2-3-5-7-4-5-6-7
10.groupingBy分组
Map<String, List<Student>> stringListMap = studentList.stream().collect(Collectors.groupingBy(Student::getName));
System.out.println(stringListMap);
输出： {孙七=[com.study.lambda.Student@3d8c7aca], 李四=[com.study.lambda.Student@5ebec15], 张三=[com.study.lambda.Student@21bcffb5], 王五=[com.study.lambda.Student@380fb434]}
{李四=19, 孙七=66, 张三=18, 王五=8}
11.toMap，对象集合转Map对象集合
// 字段转换
Map<String, Integer> nameAgeMap = studentList.stream().collect(Collectors.toMap(Student::getName, Student::getAge));
System.out.println(nameAgeMap);
输出：{李四=19, 孙七=66, 张三=18, 王五=8}
// 对象转换
Map<String, Student> studentMap = studentList.stream().collect(Collectors.toMap(Student::getName , t->t));
System.out.println(studentMap);
输出：{李四=com.study.lambda.Student@5ebec15, 孙七=com.study.lambda.Student@3d8c7aca, 张三=com.study.lambda.Student@21bcffb5, 王五=com.study.lambda.Student@380fb434}
// 对象自定义Max
Student student = studentList.stream().max((a, b) -> a.getAge() > b.getAge() ? 1 : -1).get();
System.out.println(student);
输出：孙七---66
Optional
概述
- Optional 是个容器：它可以保存类型T的值，或者仅仅保存null。Optional提供很多有用的方法，这样我们就不用显式进行空值检测。
- Optional 类的引入很好的解决空指针异常。如果值存在则isPresent()方法会返回true，调用get()方法会返回该对象。
构建
// 构建一个Optional对象；方法有：empty( )、of( )、ofNullable( )
// 定值非空的Optional实例
Optional<Student> student = Optional.of(new Student("张三", 55));
// 返回一个空的Optional实例。 此Optional没有值
Optional<Object> empty = Optional.empty();
// 返回一个Optional与如果指定值是非当前值null ，否则一个空Optional
Optional<Student> zs = Optional.ofNullable(new Student("张三", 55));
源码解析
package java.util;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.function.Supplier;
import java.util.stream.Stream;
/**
一个可能包含也可能不包含非null值的容器对象。 如果存在值，则isPresent()返回true 。 如果不存在任何值，则该对象被视为空，并且isPresent()返回false 。
提供了其他取决于所包含值是否存在的方法，例如orElse() （如果不存在值，则返回默认值）和ifPresent() （如果存在值，则执行操作）。
这是一个基于值的类； 在Optional实例上使用标识敏感的操作（包括引用等于（ == ），标识哈希码或同步）可能会产生不可预测的结果，应避免使用
*/
public final class Optional<T> {
/**
* empty()通用实例
*/
private static final Optional<?> EMPTY = new Optional<>();
/**
* 如果不为空，则为该值；否则为false。 如果为null，则表示不存在任何值
*/
private final T value;
/**
构造一个空实例。
impl注意：
通常，每个VM仅应存在一个空实例EMPTY
*/
private Optional() {
this.value = null;
}
/**
返回一个空的Optional实例。 此Optional没有值。
类型参数：<T> –不存在的值的类型
返回值：一个空的Optional
api注意：
尽管这样做可能很诱人，但应通过将==与Optional.empty()返回的实例进行比较来避免测试对象是否为空。 不能保证它是一个单例。 而是使用isPresent()
*/
public static<T> Optional<T> empty() {
@SuppressWarnings("unchecked")
Optional<T> t = (Optional<T>) EMPTY;
return t;
}
/**
使用描述的值构造一个实例。
参数：值–要描述的非null值
抛出：NullPointerException如果值为null
*/
private Optional(T value) {
this.value = Objects.requireNonNull(value);
}
/**
返回一个Optional描述给定的非null值。
参数：value –要描述的值，必须为非null
类型参数：<T> –值的类型
返回值：存在值的Optiona
*/
public static <T> Optional<T> of(T value) {
return new Optional<>(value);
}
/**
返回一个描述给定值的Optional ，如果不为null ，则返回一个空的Optional 。
参数：值–描述的可能为null值
类型参数：<T> –值的类型
返回值：一个Optional与如果指定值是非当前值null ，否则一个空Optional
*/
public static <T> Optional<T> ofNullable(T value) {
return value == null ? empty() : of(value);
}
/**
如果存在值，则返回该值，否则抛出NoSuchElementException 。
返回值：此Optional描述的非null值
抛出：NoSuchElementException如果不存在任何值
api注意：此方法的首选替代方法是orElseThrow() 。
*/
public T get() {
if (value == null) {
throw new NoSuchElementException("No value present");
}
return value;
}
/**
如果存在值，则返回true ，否则返回false 。
返回值：如果存在值，则为true ，否则为false
*/
public boolean isPresent() {
return value != null;
}
/**
如果不存在值，则返回true ，否则返回false 。
返回值：如果不存在值，则为true ，否则为false
*/
public boolean isEmpty() {
return value == null;
}
/**
如果存在值，则使用该值执行给定的操作，否则不执行任何操作。
参数：动作–要执行的动作（如果存在值）
*/
public void ifPresent(Consumer<? super T> action) {
if (value != null) {
action.accept(value);
}
}
/**
如果存在值，则使用该值执行给定的操作，否则执行给定的基于空的操作。
参数：动作–要执行的动作（如果存在值）emptyAction –要执行的基于空的操作（如果不存在任何值）
抛出：NullPointerException如果存在一个值并且给定的操作为null ，或者不存在任何值并且给定的基于空的操作为null
@since 9
*/
public void ifPresentOrElse(Consumer<? super T> action, Runnable emptyAction) {
if (value != null) {
action.accept(value);
} else {
emptyAction.run();
}
}
/**
如果存在一个值，并且该值与给定的谓词匹配，则返回描述该值的Optional ，否则返回一个空的Optional 。
参数：谓词–应用于值的谓词（如果存在）
返回值：一个Optional描述此的值Optional ，如果一个值存在并且该值给定的谓词相匹配，否则一个空Optional
抛出：NullPointerException如果谓词为null
*/
public Optional<T> filter(Predicate<? super T> predicate) {
Objects.requireNonNull(predicate);
if (!isPresent()) {
return this;
} else {
return predicate.test(value) ? this : empty();
}
}
/**
如果存在值，则返回一个Optional描述（就像by ofNullable ），将给定映射函数应用于该值的结果，否则返回一个空的Optional 。
如果映射函数返回null结果，则此方法返回空的Optional
*/
public <U> Optional<U> map(Function<? super T, ? extends U> mapper) {
Objects.requireNonNull(mapper);
if (!isPresent()) {
return empty();
} else {
return Optional.ofNullable(mapper.apply(value));
}
}
/**
如果存在一个值，则返回将给定Optional -bearing映射函数应用于该值的结果，否则返回一个空的Optional 。
此方法类似于map(Function) ，但是映射函数是其结果已经是Optional函数，如果调用该函数，则flatMap不会将其包装在其他Optional 。
参数：mapper –应用于值的映射函数（如果存在）
类型参数：<U> –映射函数返回的Optional值的类型
返回值：施加的结果Optional荷瘤映射函数此的值Optional ，如果一个值存在，否则一个空Optional
抛出：NullPointerException如果映射函数为null或返回null结果
*/
public <U> Optional<U> flatMap(Function<? super T, ? extends Optional<? extends U>> mapper) {
Objects.requireNonNull(mapper);
if (!isPresent()) {
return empty();
} else {
@SuppressWarnings("unchecked")
Optional<U> r = (Optional<U>) mapper.apply(value);
return Objects.requireNonNull(r);
}
}
/**
如果值存在时，返回一个Optional描述的值，否则将返回一个Optional产生通过供给功能。
参数：供应商–产生要返回的Optional的供应功能
返回值：返回一个Optional描述此的值Optional ，如果一个值存在，否则Optional所生产的供应功能。
抛出：NullPointerException如果提供的函数为null或产生null结果
* @since 9
*/
public Optional<T> or(Supplier<? extends Optional<? extends T>> supplier) {
Objects.requireNonNull(supplier);
if (isPresent()) {
return this;
} else {
@SuppressWarnings("unchecked")
Optional<T> r = (Optional<T>) supplier.get();
return Objects.requireNonNull(r);
}
}
/**
如果存在值，则返回仅包含该值的顺序Stream ，否则返回空Stream 。
返回值：作为Stream的可选值
* @since 9
*/
public Stream<T> stream() {
if (!isPresent()) {
return Stream.empty();
} else {
return Stream.of(value);
}
}
/**
如果存在值，则返回该值，否则返回other 。
参数：其他–要返回的值（如果不存在任何值）。 可以为null 。
返回值：值（如果存在），否则other
*/
public T orElse(T other) {
return value != null ? value : other;
}
/**
如果存在值，则返回该值，否则返回由供应函数产生的结果。
参数：供应商–产生要返回的值的供应函数
返回值：值（如果存在），否则提供功能产生的结果
*/
public T orElseGet(Supplier<? extends T> supplier) {
return value != null ? value : supplier.get();
}
/**
* If a value is present, returns the value, otherwise throws
* {@code NoSuchElementException}.
*
* @return the non-{@code null} value described by this {@code Optional}
* @throws NoSuchElementException if no value is present
* @since 10
*/
public T orElseThrow() {
if (value == null) {
throw new NoSuchElementException("No value present");
}
return value;
}
/**
如果存在值，则返回该值，否则抛出由异常提供函数产生的异常。
参数：exceptionSupplier –产生要抛出的异常的提供函数
类型参数：<X> –引发的异常类型
返回值：值（如果存在）
抛出：X –如果不存在任何值NullPointerException如果不存在任何值并且异常提供函数为null
api注意：带有空参数列表的对异常构造函数的方法引用可用作提供者
*/
public <X extends Throwable> T orElseThrow(Supplier<? extends X> exceptionSupplier) throws X {
if (value != null) {
return value;
} else {
throw exceptionSupplier.get();
}
}
}
API使用
// 获取,直接调用get，如果value为空就会报 NoSuchElementException 异常
Student student1 = student.get();
// Student student2 = emptyStudent.get(); // 报错
// orElse 可以传入一个默认对象
Student student3 =emptyStudent.orElse(new Student("error",-99));
// orElseGet 可以传递 lambda表达式
Student student2 = emptyStudent.orElseGet(() -> {
return new Student("error",-99);
});
System.out.println(student1);
System.out.println(student2);
System.out.println(student3);
参考文档
java中Optional的使用详细解析 https://www.jb51.net/article/209639.htm
JAVA stream流详细教程 https://blog.csdn.net/QiuHaoqian/article/details/120942134
