详解Java 中的函数式接口

详解Java 中的函数式接口

@FunctionalInterface注解

如果你想自己定义个新的函数式接口,强烈建议你加上*@FunctionalInterface* 注解。可以更好地揭示我们定义这个接口的意思,同时也可以让编译器帮助我们检查接口定义的正确与否。在任何情况下,我们将一个接口只有一个抽象方法的接口都认为是函数是接口。这样的接口实现,才可以被看成是 lambda 的表达式。可能你会说,不对啊,明明我看到很多函数式接口是包含了多个方法的。这里需要说明一点的是,函数式接口只能有一个抽象方法,但是可以有多个默认实现的方法。

最简单的函数式接口

通常情况下,我们满足数据的映射,那就是输入一个数据,映射(对应)输出一个数据。

public interface Function<T, R> { … }	

比如,我们调用Map 方法中computeIfAbsent 方法来实现,当我们尝试获取 key 值为 John 的值是,如果不存在,则我们生成一个(key,key.length())的数据。

Map<String, Integer> nameMap = new HashMap<>();
Integer value = nameMap.computeIfAbsent("John", s -> s.length());

当然也可以采用冒号的语法糖

Integer value = nameMap.computeIfAbsent("John", String::length);

函数式接口含有一个compose 方法来组合 多个函数表达式。(类似于数学中嵌套表达式,y=f1(f2(x))

Function<Integer, String> intToString = Object::toString;
Function<String, String> quote = s -> """ + s + """;
Function<Integer, String> quoteIntToString = quote.compose(intToString);
assertEquals(""5"", quoteIntToString.apply(5));

其中第一个函数表达式是,将对象转换为字符串,第二个则是对字符串加上双引号。

基础数据类型的函数表达式

在 JDK 的 Function 包下的有很多基础类型的函数方法接口,但是这些接口都不是可以直接使用的,都需要自己实现。

  • IntFunction, LongFunction, DoubleFunction: 输入是具体的(Int,Long,Double),但是输出是可以指定的。
  • ToIntFunction, ToLongFunction, ToDoubleFunction: 输入是可以自定义的,输出是具体的(int,Long,Double)。
  • DoubleToIntFunction, DoubleToLongFunction, IntToDoubleFunction, IntToLongFunction, LongToIntFunction, LongToDoubleFunction: 输入和输出都是指定的基础数据类型。

下面让我们根据一个输入 Short 然后输出 Byte 数据类型,来说明用法。java.util.function 下不含这两个数据类型映射。

我们先定义一个函数式接口,从 Short 类型映射到 Byte 类型。

@FunctionalInterface
public interface ShortToByteFunction {
    byte applyAsByte(short s);
}

比如,我们实现如下的逻辑,输入一个 short 类型的数组,然后每个元素都应用我们定义函数式方法实现。

public byte[] transformArray(short[] array, ShortToByteFunction function) {
    byte[] transformedArray = new byte[array.length];
    for (int i = 0; i < array.length; i++) {
        transformedArray[i] = function.applyAsByte(array[i]);
    }
    return transformedArray;
}

然后 每个元素的逻辑,通过 lambda 来具体实现。比如,每个 将每个 short 类型都乘以 2 再转换成 Byte。

short[] array = {(short) 1, (short) 2, (short) 3};
byte[] transformedArray = transformArray(array, s -> (byte) (s * 2));
byte[] expectedArray = {(byte) 2, (byte) 4, (byte) 6};
assertArrayEquals(expectedArray, transformedArray);

二元输入参数的函数 Two-Arity Function Specializations

也就是输入两个不同的参数,输出一个指定数据类型的函数。在 JDK 中,带有 Bi 名称的就是类型。比如BiFunction, ToDoubleBiFunction, ToIntBiFunction, and ToLongBiFunction.

一个典型的用法,就是 Map 中的 replaceAll 方法。

Map<String, Integer> salaries = new HashMap<>();
salaries.put("John", 40000);
salaries.put("Freddy", 30000);
salaries.put("Samuel", 50000);
salaries.replaceAll((name, oldValue) -> 
  name.equals("Freddy") ? oldValue : oldValue + 10000);

其中,将 map 中每个元素 (key,value) 都引用 lambda 中函数表达式来重新应用。

Suppliers 供给型接口 & Consumers 消费型接口

可以理解为一个生产者,通常没有输入,但是能够更具特定规则输出数据(元素)。典型的应用就是一个序列生成器。JDK 里面有更丰富接口定义,如BooleanSupplier, DoubleSupplier, LongSupplier 和 IntSupplier.

int[] fibs = {0, 1};
Stream<Integer> fibonacci = Stream.generate(() -> {
    int result = fibs[1];
    int fib3 = fibs[0] + fibs[1];
    fibs[0] = fibs[1];
    fibs[1] = fib3;
    return result;
});

与Supplier 对应的 Consumer,接收一个输入参数,但是不返回任何数据类型。最常用的就是实现 foreach 中的消费每个迭代元素。

List<String> names = Arrays.asList("John", "Freddy", "Samuel");
names.forEach(name -> System.out.println("Hello, " + name));

Predicates 断言型接口

通常理解,该接口会返回 True 或 False 的数据类型,常见的就是 Stream 中的 Filter 接口实现的逻辑。

Operators

该函数式接口主要就是,输入一个数据类型,返回同样的数据类型。

names.replaceAll(String::toUpperCase);

有一个例外,就是 BinaryOperator 函数式接口是一个归并操作,汇聚和输入的列表元素。典型的入 reduce 函数。

List<Integer> values = Arrays.asList(3, 5, 8, 9, 12);
int sum = values.stream()
  .reduce(0, (i1, i2) -> i1 + i2);

总结

本篇文章就到这里了,希望能够给你带来帮助,也希望您能够多多关注云海天教程的更多内容!