禅与计算机
sharkchili
2026-03-25
目录

Java8函数式方法引用最佳实践

@[toc]

# 写在文章开头

这是笔者很早写的文章，如今再回顾有了不一样的理解，所以在此进行简单的整理和梳理，希望对你有帮助。

我是 SharkChili ，Java 开发者，Java Guide 开源项目维护者。欢迎关注我的公众号：写代码的SharkChili，也欢迎您了解我的开源项目 mini-redis：https://github.com/shark-ctrl/mini-redis (opens new window)。

为方便与读者交流，现已创建读者群。关注上方公众号获取我的联系方式，添加时备注加群即可加入。

# 详解lambda中的方法引用

# 方法引用使用的推导

我们现在有一个苹果类，其代码定义如下：

@Data
@AllArgsConstructor
public class Apple  {
    private int weight;
    
}
1
2
3
4
5
6

因为重量单位的不同，所以得出的重量的结果可能是不同的，所以我们将计算重量的核心部分抽象成函数式接口，如下function所示，它要求我们传入Apple返回Integer：

private static int getWeight(Apple apple, Function<Apple,Integer> function) {
        return function.apply(apple);
    }
1
2
3

假设我们对重量无需任何单位换算即原原本本返回重量本身，那么我们的表达式则直接是(a)->a.getWeight()，对应代码如下：

 Apple apple=new Apple(1);
 System.out.println(getWeight(apple,(a)->a.getWeight()));
1
2

其实这个表达式还不是最精简的，按照方法引用的语法糖，如果我们的lambda表达式符合：(arg)->arg.method()，即传入的lambda就是(实例变量)->实例变量.实例方法()，那么这个表达式就可以直接缩写为arg ClassName::invokeMethod：

于是我们的代码就可以精简成下面这样：

System.out.println(getWeight(apple,Apple::getWeight));
1

除了上述这个公式以外，其实还有另外两种公式，如下所示我们的map映射希望将流中的字符串转为整型，然后输出：

  Arrays.asList("1").stream()
                .map(s -> Integer.parseInt(s))
                .forEach(i -> System.out.println(i));
1
2
3

按照jdk8的语法糖，对应的静态类调用静态方法的表达式(args)->className.staticMethod(args)可以直接缩写为className->staticMethod(args)，于是我们的整型转换的就可以直接缩写为Integer::parseInt：

 Arrays.asList("1").stream()
                .map(Integer::parseInt)
                .forEach(i -> System.out.println(i));
1
2
3

最后一种则是针对多参数的如下所示，这是一个常规的排序lambda编程：

 List<String> str = Arrays.asList("a","b","A","B");
str.sort((s1, s2) -> s1.compareToIgnoreCase(s2));
1
2

按照Java8的语法糖：(arg1,arg2)->arg1.instanceMethod(arg2)可以直接转换为arg1ClassName::invokeInstanceMethod，于是我们的就有了下面的推导：

最终我们的表达式就变成了这样：

List<String> str = Arrays.asList("a","b","A","B");
        str.sort(String::compareToIgnoreCase);
1
2

# 方法引用对于对象构造的抽象

实际上对象构造也可以通过方法引用表达，其整体缩写的语法和静态方法引用类似，如下图所示本质上new的动作就可以直接理解为对于new的调用，同理简写为className::new来表达：

我们不妨结合几个例子进行说明，如下便是苹果对象的类定义，即带有重量、颜色等属性，同时支持含参或不含参的方式构造：

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Apple {
    private int weight;

    private String color;


}
1
2
3
4
5
6
7
8
9
10

简单的苹果对象创建就像下面这样new创建

 //普通对象创建
        Apple apple = new Apple();
1
2

实际上这个创建步骤在函数式中可以抽象的理解为Supplier接口()->T，其中T为Apple，所以我们表达式可以转换为如下方式：

 Supplier<Apple> apply = () -> new Apple();
 Apple apple1 = apply.get();
1
2

此时，基于我们上述的图解，即可将Supplier对象构造推导出构造函数的方法引用：

于是就有了下方代码：

 //采用方法引用缩写
        Supplier<Apple> apply2 = Apple::new;
        Apple apple2 = apply2.get();
1
2
3

我们再来一个难一点的例子，因为我们的构造器为传参顺序为weight、color然后创建Apple实例，对此我们可以大体抽象出函数式接口的签名为(Integer,String)->Apple，基于这个签名我们可以直接套用公式BiFunction，它的签名为(T,U)->R，参数列表符合要求，我们直接将类型代入完成函数式接口抽象：

private static Apple createApple(Integer weight,String color,BiFunction<Integer, String, Apple> func) {
        return func.apply(weight, color);
    }
1
2
3

基于上述的签名的参数列表和预期返回值，我们得出下面这样一条lambda表达式作为入参传入，由此得到一个Apple实例：

 createApple(1,"yellow",(w,s)->new Apple(w,s));
1

按照上文所说的公式，于是我们的表达式又可以转为方法引用：

对应的代码如下所示：

 createApple(1,"yellow",Apple::new);
1

# lambda和方法引用的结合

我们希望对苹果类进行排序，对此我们给出苹果类的实例集合：

List<Apple> appleList = Arrays.asList(new Apple(80, "green"),
                new Apple(200, "red"),
                new Apple(155, "yellow"),
                new Apple(120, "red"));
1
2
3
4

查看函数式接口Comparator的抽象方法 int compare(T o1, T o2);得出对应的函数签名为(T,T)->Integer，代入我们的Apple类，那么这个比较器的函数描述符则是(Apple,Apple)->Integer，于是我们就有了下面这条lambda表达式：

 Comparator<Apple> comparator = (a1,a2)->a1.getWeight()-a2.getWeight();
1

我们键入如下代码进行调用输出：

 appleList.sort(comparator);
 appleList.forEach(System.out::println);
1
2

和预期比较结果一致：

Apple(weight=80, color=green)
Apple(weight=120, color=red)
Apple(weight=155, color=yellow)
Apple(weight=200, color=red)
1
2
3
4

实际上我们还可以做的更加精简，因为JDK8中的Comparator已经为比较器提供了一个方法comparing，查看其源码可以看到他要求传入一个入参keyExtractor，从语义上就可以知道这个参数是作为比较的条件，以我们的例子就是Apple的weight。 这个keyExtractor是Function接口，查看其泛型我们也可以知晓它的函数式签名为T->R，由此我们可以推理出该方法本质就是通过Function接口变量keyExtractor生成比较变量的实例然后调用compareTo进行比较并返回结果：

//要求传入keyExtractor即作为比较的条件
public static <T, U extends Comparable<? super U>> Comparator<T> comparing(
            Function<? super T, ? extends U> keyExtractor)
    {
        //......
        return (Comparator<T> & Serializable)
        	//通过keyExtractor生成key值调用其compareTo方法进行比较
            (c1, c2) -> keyExtractor.apply(c1).compareTo(keyExtractor.apply(c2));
    }
1
2
3
4
5
6
7
8
9

基于上述分析我们就可以开始编写这个比较器的keyExtractor的lambda表达式了，如下图，通过keyExtractor泛型得出函数描述符为(T)->R，基于我们的场景推导出公式是apple实例->apple实例的weight，最后comparing会基于这个函数接口生成的R对象(我们的场景是weight即int类型)调用compareTo进行比较：

于是我们就有了这样一条lambda表达式，但这还不是最精简的：

Comparator<Apple> comparator = Comparator.comparing(a->a.getWeight());
1

按照lambda的语法糖:instance->instance.method 可以直接转为instanceType::method，我们最终的表达式如下，预期结果也和之前一致：

 Comparator<Apple> comparator = Comparator.comparing(Apple::getWeight);
1

当然有时候我们希望能够对结果进行反向排序，我们也只需在comparing方法后面加一个reversed即实现，从语义和使用上是不是都很方便呢？

Comparator<Apple> comparator = Comparator.comparing(Apple::getWeight).reversed();
1

# 复合表达式

# 复合比较器

自此我们基本将方法引用的推导和使用都讲完了，接下来我们还是基于lambda做一些实用的拓展，先来说说复合比较器，以上文的苹果为例，假设我们希望当重量一样时，在比较颜色进行进一步比较，那么我们就可以直接通过thenComparing生成复合表达式：

 Comparator<Apple> comparator = Comparator.comparing(Apple::getWeight).reversed().thenComparing(Apple::getColor);
1

# 谓词复合

还是用上面的例子，我们希望根据不同的条件从苹果集合中过滤出复合条件的苹果，对此我们基于Predicate即断言函数式接口编写了一个filterApple方法：

private static List<Apple> filterApple(List<Apple> appleList, Predicate<Apple> predicate) {
        List<Apple> list = new ArrayList<>();
        for (Apple apple : appleList) {
            //复合predicate设定条件的苹果存入集合中
            if (predicate.test(apple)) {
                list.add(apple);
            }
        }
        return list;
    }
1
2
3
4
5
6
7
8
9
10

假如客户需要过滤出红色的苹果，基于predicate的签名我们得出这样一个表达式，这里就不多介绍了：

 filterApple(appleList, apple -> apple.getColor().equals("red"));
1

假如这时候我们有需要过滤出不为红色的苹果呢？其实JDK8为我们提供了一个非常强大的谓词negate，我们完全可以基于上面的代码进行改造从而实现需求，如下所示negate就相当于!"red".equals(a.getColor());，语义是不是很清晰呢？

Predicate<Apple> predicate = apple -> apple.getColor().equals("red");
        filterApple(appleList, predicate.negate());
1
2

但是我们需要再次变化了，我们希望找出红色且重量大于150，或者颜色为绿色的苹果，这时候又怎么办呢？我们说过JDK8提供了and、or等谓词，我们的代码完全可以写成下文所示,可以看到代码语义以及流畅度都相比JDK8之前的各种&& ||拼接for循环来说优雅非常多：

 //过滤出红色的苹果
        Predicate<Apple> predicate = apple -> apple.getColor().equals("red");
        //过滤出红色且大于150 或者绿色的苹果
        Predicate<Apple> redAndHeavyAppleOrGreen = predicate.and(apple -> apple.getWeight() > 150).
                or(apple -> apple.getColor().equals("green"));


        filterApple(appleList, redAndHeavyAppleOrGreen);
1
2
3
4
5
6
7
8

# 函数复合

我们都说代码和数学息息相关，其实java8也提供很多函数式接口可以运用于数学公式上,例如，我们现在需要计算f(g(x))，这个公式学过高数的同学都知道，是先计算g(x)再将g(x)的结果作为入参交给f(x)计算，对应题解案例如下：

我们假设g(x)=x * 2
f(x)=x+1
假如x=1
那么g(f(x))最终就会等于4
1
2
3
4

了解数学公式之后，我们完全可以使用java代码表示出来，首先我们先声明一下f(x)和g(x)：

//f(x)
 Function<Integer, Integer> f = x -> x + 1;
 //g(x)
 Function<Integer, Integer> g = x -> x * 2;
1
2
3
4

在表示g(f(x))，通过复合表达式andThen表达了数学的计算顺序，即显得出f(x)结果，然后(andThen)代入g(x)中：

 //意味先计算f(x)在计算g(x)
 Function<Integer, Integer> h = f.andThen(g);
System.out.println(result); //输出 4
1
2
3

基于上面的例子，如果我们还需要计算f(g(x))要怎么办呢？从f(x)角度来看，g(x)的结果组合到f(x)上，所以我们可以直接实用compose方法：

 Function<Integer, Integer> fgx = f.compose(g);
Integer result = fgx.apply(1);
System.out.println(result);// 输出 3
1
2
3

其实,按照奥卡姆剃刀守则，如果按照笔者的习惯，会优先使用第一种，即fg(x)用 g.andThen(f);,即先算g再算f,而gf(x)则用f.andThen(g);即先算f再算g。

# 小结

自此我们将方法引用的推导和实用，以及各种表达式组合的内容都介绍完了，希望对你有帮助。

我是 SharkChili ，Java 开发者，Java Guide 开源项目维护者。欢迎关注我的公众号：写代码的SharkChili，也欢迎您了解我的开源项目 mini-redis：https://github.com/shark-ctrl/mini-redis (opens new window)。

为方便与读者交流，现已创建读者群。关注上方公众号获取我的联系方式，添加时备注加群即可加入。

# 参考

《Java 8 in Action》

编辑 (opens new window)
上次更新: 2026/03/26, 01:05:31
基于lambda简化设计模式
使用Java8并行流的注意事项

← 使用Java8并行流的注意事项→

最近更新
01
基于EasyExcel实现高效导出
03-25
02
从开源框架中学习那些实用的位运算技巧
03-25
03
浅谈分布式架构设计思想和常见优化手段
03-25
更多文章>
Theme by Vdoing | Copyright © 2025-2026 Evan Xu | MIT License | 桂ICP备2024034950号 | 桂公网安备45142202000030
×
×