神奇的Lambda表达式-----函数式编程

关注

原创最新推荐文章于 2026-06-11 07:37:03 发布 957 阅读 AI 写同款· GEO 优化 ›

Java泛型与Lambda表达式：函数式编程的完美结合在Java编程的世界里，我们总是希望能够用更高效、更简洁的方式来实现功能。Java泛型和Lambda表达式就是两个强大的工具，它们能让我们的代码变得更加灵活和优雅。本文的目的就是深入探讨这两者是如何在函数式编程中完美结合的，范围涵盖了从基本概念的解释到实际应用的案例分析。本文首先会介绍核心概念，用有趣的故事引出Java泛型和Lambda表达式，然后详细解释它们的原理和相互关系。接着会阐述核心算法原理和具体操作步骤，给出相关的数学模型和公式。之后通过项目实战，展示代码的实际案例并进行详细解释。阅读详情

在这里插入图片描述
Lambda表达式是jdk1.8出现的一种重要的新特性，它允许将函数作为参数进行传递（函数式编程），能够极大的简洁代码。点击查看Oracle官网有关于jdk8的新特性描述。

以最常见到的使用Runnable创建线程为例。
使用匿名内部类创建：

Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("do something here");
            }
        },"thread");

使用lambda表达式的形式创建：

Thread thread = new Thread(() -> System.out.println("do something here"), "thread");

可以说代码的数量减少很多，看起来也很简洁。

Lambda

简单的语法

参数 -> 表达式
args -> experssion

Lambda表达式特征

可选的类型声明：编译器可以通过上下文来推到类型
可选的参数括号：如果只有一个参数，可以不定义括号
可选的大括号：如果函数体只有一条语句，可以省略大括号
可选的返回关键字：如果主体只有一个表达式返回值，则编译器会自动返回值

简单举例

1、不需要参数: () -> 5
2、接受一个参数: x -> x+5
3、接收两个参数: (x,y) -> x-y
4、接收int类型参数：(int a, int b) -> x+y
5、接收参数，返回空： (String s) -> System.out.println(s);

应用场景

Lambda表达式适合应用在任何有函数式接口的地方

什么是函数式接口？

简单来说就是只有一个抽象方法的接口，从API的形式来看就是具有@FunctionalInterface注解的接口。关于注解可以看我之前的文章点击查看。

那么这里强调函数式接口是具有一个抽象方法的接口。不是所有接口的方法都是抽象的么？事实上接口可以声明Object类中的方法，比如toString，equals方法。比如下面这种情况是可以的：@FunctionalInterface interface Test { void say(); String toString(); }
而且，在jdk8以后，接口中可以添加default方法，这也不是一个抽象方法。你可以通过查看Comparator接口定义来分辨。

常见的函数式接口

java.util.function包下存在很多的函数式接口，适用于不同场景。
在这里插入图片描述
这里就不一一介绍了，下面如果在某个举例中用到再进行详细说明。

方法引用

方法引用是用来直接访问类或者实例的已经存在的方法或者构造方法，方法引用提供了一种引用而不执行方法的方式，如果抽象
方法的实现恰好可以使用调用另外一个方法来实现，就有可能可
以使用方法引用。

使用

静态方法引用

class TT {
    public static String fun2() {
        System.out.println("tt   --   fun2");
        return "fun2";
    }
}

下面分别是以方法引用的形式和lambda语法形式来执行。

public static void main(String[] args) {
        Supplier<String> fun2 = TT::fun2;
        System.out.println(fun2.get());

		Supplier<String> supplier = () -> TT.fun2();
        System.out.println(supplier.get());
}

这里提到了Supplier，它是一个函数式接口。

Supplier< T > 没有参数，返回类型为T，通过get方法来执行获取返回值。

实例方法引用

class TT {
     public void fun(String a) {
        System.out.println("tt"+a+"   --   fun");
    }
}

public static void main(String[] args) {
        Consumer<String> consumer = a -> new TT().fun(a);
        consumer.accept("0");

        Consumer<String> consumer1 = new TT()::fun;
        consumer.accept("1");
    }

这里用到了Consumer函数接口。

Consumer< T >接口是一个参数类型为T，没有返回值的函数接口。通过accept方法来传入参数并执行。

对象方法引用

public static void main(String[] args) {

        Comparator<String> comparator = (a, b) -> a.compareToIgnoreCase(b);
        int compare1 = comparator.compare("a", "b");
        System.out.println(compare1);

        Comparator<String> compare = String::compareToIgnoreCase;
        int i = compare.compare("a", "b");
        System.out.println(i);

    }

Comparator接口大家应该很熟悉了，这里就不多赘述。

那么静态方法和对象方法两者的区别在哪里？
对象方法会将第一个参数作为方法的目标。只需要记住这样一个例子即可：String::compareToIgnoreCase，
那么以Lambda形式来写的话就是
(a, b) -> a.compareToIgnoreCase(b)

构造方法引用

class Acc {

    public Acc() {
        System.out.println("无参构造");
    }

    public Acc(int a) {
        System.out.println("有参构造"+a);
    }
    
}

    public static void main(String[] args) {
        Supplier<Acc> s2 = Acc::new;
        s2.get();

        Consumer<Integer> c1 = Acc::new;
        c1.accept(234);

        Function<Integer,Acc> f1 = Acc::new;
        Acc apply = f1.apply(234444);

    }

这里提到了Function。

Function<T,R> ，其中T为参数，R为返回值。通过apply方法传入参数并返回

为什么用Lambda

lambda最重要的一点是延迟执行，毕竟如果要立即执行代码的话，完全没有必要写再lambda表达式中。上面代码中使用静态引用的方式：

Supplier<String> fun2 = TT::fun2;

这一句话其实是没有执行fun2函数的，大家可以尝试一下。

为什么延迟执行

在一个单独线程中运行代码。
需要多次运行
在适当的时候执行代码
在某种情况下执行代码（比如触发器）

比如输出n个数，使用lambda的方式可以这样写：

public static void repeat(int i, IntConsumer intConsumer) {
        System.out.println("repeat");
        for (int j = 0; j < i; j++) {
            intConsumer.accept(j);
        }
}

调用：

repeat(10, i -> System.out.println(9 - i));

例子

集合的迭代：

    public static void main(String[] args) {
        List<String> list = Arrays.asList("a,b,c,d".split(","));
        list.forEach(System.out::println);
        
    }

排序：

 public static void main(String[] args) {
            String[] array = {"a", "ff", "ab", "cd", "rwdfsd", "abc"};
            //Arrays.sort(array, (a, b) -> a.length() - b.length());
            Arrays.sort(array, Comparator.comparingInt(String::length));
            System.out.println(Arrays.asList(array));
}