【Java 8】Optional类与函数式编程

Optional类的用法

  Java 的 Optional 类是用来处理可能存在为空的值的情况的。它是在 Java 8 中引入的，旨在减少空指针异常的发生。

  通常我们会用if判断对象是不是null，然后再进行一些处理，但是这样很不优雅。如下：

List<String> list = new ArrayList<>();

// 常规方法
if(list != null){
    
    
	List<String> new_list = new ArrayList<>();
	for(String s : list){
    
    
		if("".equals(s)) continue;
		new_list.add(s);
	}
	return new_list;
}else{
    
    
	return null
}

// 优雅写法 使用Optional + 函数式编程
return Optional.ofNullable(list)
		.filter(s -> !"".equals(s))
		.orElse(null);

Optional类的常用方法

  创建 Optional 对象：

Optional<T> optionalValue = Optional.of(value);  // 值不能为空
Optional<T> optionalNullableValue = Optional.ofNullable(nullableValue);  // 值可以为空
Optional<T> optionalEmpty = Optional.empty();  // 创建一个空的 Optional 对象

  判断 Optional 对象是否包含值：

optionalValue.isPresent();  // 返回 true，如果值存在

  获取 Optional 对象中的值：

T value = optionalValue.get();  // 若值存在，则获取该值，否则抛出 NoSuchElementException 异常

  检查并执行操作：

optionalValue.ifPresent(val -> {
    
    
    // 如果值存在，则执行操作
});

  使用默认值：

T value = optionalValue.orElse(defaultValue);  // 如果值存在，则返回该值，否则返回默认值
T value = optionalValue.orElseGet(() -> {
    
    
    // 如果值不存在，则执行自定义操作生成默认值
});

  其他方法：

optionalValue.map(val -> {
    
    
    // 对值进行映射转换操作
});

optionalValue.filter(val -> {
    
    
    // 过滤值的条件
});

optionalValue.flatMap(val -> {
    
    
    // 针对嵌套 Optional 进行操作
});

  在使用Optional类时，主要结合函数式编程方法使用：Consumer、Predicate和Function类。

Optional.ifPresent与Consumer类

  观察Optional.ifPresent的源码：

    public void ifPresent(Consumer<? super T> consumer) {
    
    
        if (value != null)
            consumer.accept(value);
    }

  Consumer是一个函数式接口，代表接受一个输入参数并且不返回任何结果的操作。它通常用于对给定的参数执行一些操作，比如修改对象的状态、打印信息等。

  Consumer接口包含一个抽象方法 void accept(T t)，该方法接受一个类型为T的参数，并对其进行操作。

  Optional.ifPresent示例代码：

java

Optional.ofNullable(user).ifPresent(o -> {
    
    
	// ifPresent确定是否有值 之后进行赋值或打印等无return操作
    o.setName("...");
    System.out.println(o);
}));

Optional.filter与Predicate类

  观察Optional.filter的源码：

    public Optional<T> filter(Predicate<? super T> predicate) {
    
    
        Objects.requireNonNull(predicate);
        if (!isPresent())
            return this;
        else
            return predicate.test(value) ? this : empty();
    }

  Predicate是一个函数式接口，代表一个断言（判断条件），接受一个输入参数并返回一个布尔值。它通常用于过滤集合或校验输入参数的合法性。

  Predicate接口包含一个抽象方法 boolean test(T t)，该方法接受一个类型为T的参数，并返回一个布尔值表示判断的结果。

  Optional.filter示例代码：

java

Optional.ofNullable(str).filter(o -> !"".equals(o) );

Optional.map与Function类

  观察Optional.map的源码：

    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));
        }
    }

  Function<T, R>是一个函数式接口，代表接受一个输入参数并返回一个结果的操作。它通常用于将一个值转换成另一个值，或执行一些复杂的计算。

  Function接口包含一个抽象方法 R apply(T t)，该方法接受一个类型为T的参数，并返回一个类型为R的结果。

  Optional.map示例代码：

java

Optional.ofNullable(str).map(o -> {
    
    
	// 进行一些操作 然后return数据
	return str;
} );