JDK1.8 -lambda中常用内置函数式接口

703 阅读5分钟

1 常用的函数式接口

1.1 Predicate

java.util.function.Predicate 接口定义了一个名叫 test 的抽象方法,它接受泛型 T 对象,并返回一个 boolean 。在你需要表示一个涉及类型 T 的布尔表达式时,就可以使用这个接口。

@FunctionalInterface
    public interface Predicate<T>{
        boolean test(T t);
    }
    public static <T> List<T> filter(List<T> list, Predicate<T> p) {
        List<T> results = new ArrayList<>();
        for(T s: list){
            if(p.test(s)){
                results.add(s);
            }
        }
        return results;
    }
    Predicate<String> nonEmptyStringPredicate = (String s) -> !s.isEmpty();
    List<String> nonEmpty = filter(listOfStrings, nonEmptyStringPredicate);

1.2 Consumer

ava.util.function.Consumer 定义了一个名叫 accept 的抽象方法,它接受泛型 T 的对象,没有返回( void )。

@FunctionalInterface
    public interface Consumer<T>{
        void accept(T t);
    }
    public static <T> void forEach(List<T> list, Consumer<T> c){
        for(T i: list){
            c.accept(i);
        }
    }
    forEach(
            Arrays.asList(1,2,3,4,5),
            (Integer i) -> System.out.println(i)
            );

1.3 Function

java.util.function.Function<T, R> 接口定义了一个叫作 apply 的方法,它接受一个 泛型 T 的对象,并返回一个泛型 R 的对象。

@FunctionalInterface
    public interface Function<T, R>{
        R apply(T t);
    }
    public static <T, R> List<R> map(List<T> list,
                                     Function<T, R> f) {
        List<R> result = new ArrayList<>();
        for(T s: list){
            result.add(f.apply(s));
        }
        return result;
    }
    // [7, 2, 6]
    List<Integer> l = map(
            Arrays.asList("lambdas","in","action"),
            (String s) -> s.length()
    );

1.4 常用的函数式接口

在这里插入图片描述
在这里插入图片描述

2 Optional

2.1 创建 Optional 对象

  1. 声明一个空的 Optional 你可以通过静态工厂方法 Optional.empty ,创建一个空的Optional对象: Optional optCar = Optional.empty();
  2. 依据一个非空值创建 Optional 使用静态工厂方法 Optional.of ,依据一个非空值创建一个Optional 对象: Optional optCar = Optional.of(car); 如果 car 是一个 null ,这段代码会立即抛出一个NullPointerException ,而不是等到你试图访问 car 的属性值时才返回一个错误。
  3. 可接受 null 的 Optional 使用静态工厂方法 Optional.ofNullable ,你可以创建一个允许null 值的 Optional对象: Optional optCar = Optional.ofNullable(car); 如果 car 是 null ,那么得到的 Optional 对象就是个空对象。

2.2 使用 map 从 Optional 对象中提取和转换值

从对象中提取信息是一种比较常见的模式。比如,你可能想要从 insurance 公司对象中提取公司的名称。提取名称之前,你需要检查 insurance 对象是否为 null ,代码如下所示:

String name = null;
if(insurance != null){
	name = insurance.getName();
}

为了支持这种模式, Optional 提供了一个 map 方法。

Optional<Insurance> optInsurance = Optional.ofNullable(insurance);
Optional<String> name = optInsurance.map(Insurance::getName);

2.3 使用 flatMap 链接 Optional 对象

@Data
public class Person {

    Optional<Car> car;

}

@Data
class Car{
    Optional<Insurance> insurance;
}

@Data
class Insurance {
    String name;
}

由于我们刚刚学习了如何使用 map ,你的第一反应可能是我们可以利用 map 重写之前的代码, 如下所示:

ptional<Person> optPerson = Optional.of(person);
Optional<String> name = optPerson.map(Person::getCar)
									.map(Car::getInsurance)
									.map(Insurance::getName);

不幸的是,这段代码无法通过编译。为什么呢? optPerson 是 Optional 类型变量, 调用 map 方法应该没有问题。但 getCar 返回的是一个 Optional 类型的对象(如代码清单10-4所示),这意味着 map 操作的结果是一个 Optional<Optional> 类型的对象。因此,它对 getInsurance 的调用是非法的,因为最外层的 optional 对象包含了另一个 optional对象的值,而它当然不会支持 getInsurance 方法。

正确的写法应该是:

public String getCarInsuranceName(Optional<Person> person) {
	return person.flatMap(Person::getCar)
				.flatMap(Car::getInsurance)
				.map(Insurance::getName)
				.orElse("Unknown");
}

2.4 默认行为及解引用 Optional 对象

我们决定采用 orElse 方法读取这个变量的值,使用这种方式你还可以定义一个默认值,遭遇空的 Optional 变量时,默认值会作为该方法的调用返回值。 Optional 类提供了多种方法读取Optional 实例中的变量值。

  1. get() 是这些方法中最简单但又最不安全的方法。如果变量存在,它直接返回封装的变量值,否则就抛出一个 NoSuchElementException 异常。所以,除非你非常确定 Optional变量一定包含值,否则使用这个方法是个相当糟糕的主意。此外,这种方式即便相对于嵌套式的 null 检查,也并未体现出多大的改进。
  2. orElse(T other) 它允许你在Optional 对象不包含值时提供一个默认值。
  3. orElseGet(Supplier<? extends T> other) 是 orElse 方法的延迟调用版, Supplier方法只有在 Optional 对象不含值时才执行调用。如果创建默认值是件耗时费力的工作,你应该考虑采用这种方式(借此提升程序的性能),或者你需要非常确定某个方法仅在Optional 为空时才进行调用,也可以考虑该方式(这种情况有严格的限制条件)。
  4. orElseThrow(Supplier<? extends X> exceptionSupplier) 和 get 方法非常类似,它们遭遇 Optional 对象为空时都会抛出一个异常,但是使用 orElseThrow 你可以定制希望抛出的异常类型。
  5. ifPresent(Consumer<? super T>) 让你能在变量值存在时执行一个作为参数传入的方法,否则就不进行任何操作。

2.5 使用 filter 剔除特定的值

你经常需要调用某个对象的方法,查看它的某些属性。比如,你可能需要检查保险公司的名称是否为“Cambridge-Insurance”。为了以一种安全的方式进行这些操作,你首先需要确定引用指向的 Insurance 对象是否为 null ,之后再调用它的 getName 方法,如下所示:

if(insurance != null && "CambridgeInsurance".equals(insurance.getName())){
	System.out.println("ok");
}

使用 Optional 对象的 filter 方法,这段代码可以重构如下:

Insurance insurance = new Insurance();
insurance.setName("wtj");

Optional<Insurance> ins = Optional.of(insurance);
ins.filter(insu ->
  "wtj".equals(insu.getName())
 ).ifPresent(x -> System.out.println("ok"));

filter 方法接受一个谓词作为参数。如果 Optional 对象的值存在,并且它符合谓词的条件,filter 方法就返回其值;否则它就返回一个空的 Optional 对象。

2.6 基础类型的 Optional 对象,以及为什么应该避免使用它们

与 Stream 对象一样, Optional 也提供了类似的基础类型—— OptionalInt 、** OptionalLong** 以及 OptionalDouble,我们讨论过使用基础类型 Stream 的场景,尤其是如果 Stream 对象包含了大量元素,出于性能的考量,使用基础类型是不错的选择,但对 Optional 对象而言,这个理由就不成立了,因为 Optional对象最多只包含一个值。

不推荐大家使用基础类型的 Optional ,因为基础类型的 Optional 不支持 map 、flatMap 以及 filter 方法,而这些却是 Optional 类最有用的方法。