在之前的文章，到目前为止我们已经看到了三个功能接口，Consumer，BiConsumer和Predicate。没看过的同学可以先了解一下。

Java8精华-函数式编程（一）读完这篇，你将彻底理解

Java8精华-函数式编程-Consumer（二）

java8精华-函数式编程-BiConsumer（三）

java8精华-函数式编程-Predicate（四）

在本文中，我们将了解另一个函数式接口Function。

Function是函数式编程中另一个值得关注的重要接口。顾名思义，它代表一个应用于给定输入并返回结果的函数。接口定义如下所示。

@FunctionalInterface
public interface Function<T, R> {

    R apply(T t);

    default <V> Function<V, R> compose(
                       Function<? super V, ? extends T> before) {
        Objects.requireNonNull(before);
        return (V v) -> apply(before.apply(v));
    }

    default <V> Function<T, V> andThen(
                       Function<? super R, ? extends V> after) {
        Objects.requireNonNull(after);
        return (T t) -> after.apply(apply(t));
    }

    static <T> Function<T, T> identity() {
        return t -> t;
    }
}

可以看到抽象方法是R apply(T t)。接受我们有两个类型参数：T 和 R。

T：是输入参数的类型

R：是返回值的类型。

这里提到一个重要注意事项是Function 与 Consumer 完全相同，只是它返回一个值，而 Consumer 不返回值。

什么时候使用

有很多地方可以使用，这里了解两种情况

1、使用 Stream 对象上的 map() 方法。

2、使用map对象的computeIfAbsent()方法。

在Stream对象上使用map()

假设我们有一个代表整数值的 String 对象流，并且我们希望将它们转换为整数。所以函数的输入是一个字符串，输出是一个整数。以下是我们如何实现它。

Function<String, Integer> atoi = new Function<String, Integer>() {
    @Override
    public Integer apply(String s) {
        return Integer.valueOf(s);
    }
};

将上面的匿名内部类转换为 lambda 我们得到了这个。

Function<String, Integer> atoi = str -> Integer.valueOf(str);

这是表示整数的字符串流。

Stream<String> numberStrs = 
                 Stream.of("11", "111", "11111", "1111111");

现在，在这个流对象上，我们将这个函数 atoi 与下面的 map() 方法一起使用

Stream<Integer> numbers = numberStrs.map(atoi);

我们甚至可以将其放在一行中，如下所示。

Stream<Integer> numbers = numberStrs.map(
                                     str -> Integer.valueOf(str));

map() 方法将函数 atoi 应用于流中的每个对象并返回一个新流。所以我们在这里所做的是将字符串对象流转换为整数对象流。

我们可以根据需要连接任意多个 map() 方法来应用不同的转换。例如，将字符串转换为整数后，如果我们想要将平方作为长整数返回，则可以按如下方式执行。

Stream<Long> longNumbers = numberStrs
                .map(s -> Integer.valueOf(s)) 
                .map(i -> i * i) 
                .map(l -> Long.valueOf(l)); 

map() 方法还有其他变体，采用 Function 接口的其他变体。

Map 对象上使用computeIfAbsent()

这是Function 实现 lambda 的第二个地方。想要实现的功能是，当该key的数据在map不存在时才将数据添加进去

假设我们有一个字符串及其长度的键值对，如下所示。

Map<String, Integer> numbersMap = new HashMap<>(Map.of(
        "Two", "Two".length(),
        "THREE", "THREE".length(),
        "FOUR", "FOUR".length(),
        "FIVE", "FIVE".length()
));

现在，仅当没有具有给定key的数据时，才添加到map。在这种情况下，我们可以使用computeIfAbsent()方法并给出实现Function接口的lambda。

numbersMap.computeIfAbsent("SIX", v -> v.length());

这里的key是 SIX，map中不存在。因此，上面的代码将在map中添加一个数据，其中 SIX为key，3 为值。

“Function”的变体

Function 接口有多种的变体，如下所示。

1. ToIntFunction：接受参数 T，并返回整数值。
2. ToLongFunction：接受参数 T，并返回一个 long 值。
3. ToDoubleFunction：采用参数 T，并返回double值。
4. BiFunction：采用两个参数 T 和 U，并返回 R。

这些函数分别与 IntStream、LongStream、DoubleStream 和 Stream 类一起使用，它们各自的映射方法是 mapToInt()、mapToLong() 和 mapToDouble()。

LongStream longs = numberStrs
        .map(str -> Integer.valueOf(str))
        .mapToLong(i -> i);

或者我们可以简单地按照下面的方法做，这比上面的方法更好。

LongStream longs = numberStrs.mapToLong(str -> Long.valueOf(str));

除了我们下面讨论的 BiFunction 之外，所有其他变体都是相通的。相信大家都能看明白

BiFunction接口

BiFunction 与 BiConsumer 相同，只是它返回一个值。因此 BiFunction 接受两个参数并返回一个值。接口定义如下所示。

@FunctionalInterface
public interface BiFunction<T, U, R> {

    R apply(T t, U u);

    default <V> BiFunction<T, U, V> andThen(
                       Function<? super R, ? extends V> after) {
        Objects.requireNonNull(after);
        return (T t, U u) -> after.apply(apply(t, u));
    }
}

它有抽象方法 apply() 和默认方法 andThen()。

BiFunction 共有 3 个类型参数。 T和U是输入类型参数，R是返回值类型。

哪里使用BiFunction

每当我们想要将两个值转换为另一个值或处理像map这样的两个值对象的数据时，我们可以使用 BiFunction。

BiFunction<Integer, Integer, Double> exponent = 
                                     (x, y) -> Math.pow(x, y);

我们在这里所说的类型参数是指有两个输入参数，它们是整数，结果是双精度值。

我们也可以在 Map 对象上使用它。假设我们有一个以字符串为key、以整数为value的map，如下所示，我们可以使用 BiFunction 来转换map的所有值。

例如，我们有下面的map。

Map<String, Integer> numbersMap = new HashMap<>(Map.of(
        "Two", 2,
        "THREE", 3,
        "FOUR", 4,
        "FIVE", 5
));

将 BiFunction 与 ReplaceAll() 方法结合使用

现在我们希望map的每个值都计算平方。如果没有 lambda，迭代所有值并将它们再次放入map将会很痛苦。这里replaceAll()就派上用场了。

ReplaceAll() 的作用是，它获取 BiFunction，将其应用于与特定key对应的每个value，获取应用 BiFunction 的结果的新value，并替换该key的新value。我们是这样做的。

System.out.println("前: " + numbersMap);
numbersMap.replaceAll((k, v) -> v * v); 
System.out.println("后: " + numbersMap);

输出
前: {FIVE=5, Two=2, FOUR=4, THREE=3}
后: {FIVE=25, Two=4, FOUR=16, THREE=9}

让我们来分解一下。我们在这里使用的 lambda 是 (k, v) -> v * v 。参数 k 和 v 是输入，它们是字符串和整数。返回值为 Integer，即 v * v

如果你不理解 lambda，只需先简单地编写匿名内部类，然后将其转换为 lambda。这里我来写一下匿名内部类。

numbersMap.replaceAll(new BiFunction<String, Integer, Integer>() {
    @Override
    public Integer apply(String k, Integer v) {
        return v * v;
    }
});

将 BiFunction 与computeIfPresent() 结合使用

例如，我们想要更改现有key的value。我们可以按如下方式执行此操作。

Map<String, Integer> numbersMap = new HashMap<>(Map.of(
        "Two", 2,
        "THREE", 3,
        "FOUR", 4,
        "FIVE", 5
));
numbersMap.replaceAll((k, v) -> v * v);
numbersMap.computeIfPresent("FOUR", (k,v) -> k.length())

输出
{FIVE=25, Two=4, THREE=9, FOUR=4}

上面就是Function的所有基础知识。函数有很多变体，例如IntFunction、ToIntFunction、LongFunction等等ToLongFunction。我们需要查看Java Docs注释来选择适合我们的。但问题是，如果我们处理像 int、long 和 double 这样的基本类型，最好使用IntFunction、ToIntFunction和基本类型的其他变体，因为它们有更好的性能，因为不涉及自动装箱。

概括

1. Function类似，Consumer但唯一的区别是Function返回值，Consumer不返回值。
2. 我们使用 Function withcomputeIfAbsent()和BiFunctionwith computeIfPresent()。
3. 尽量使用函数的基本类型变体总，因为避免自动装箱，并且可以以更少的内存占用提供更好的性能。