Java语法之 Lambda表达式使用

最新推荐文章于 2025-06-16 14:15:29 发布

liucy007

最新推荐文章于 2025-06-16 14:15:29 发布

阅读量876

点赞数

CC 4.0 BY-SA版权

分类专栏： Java学习文章标签： java

本文链接：https://blog.csdn.net/liucy007/article/details/127049102

Java学习专栏收录该内容

7 篇文章

订阅专栏

本文介绍Java 8中的Lambda表达式，一种简洁的函数式编程方式，可用于替代匿名内部类，简化代码并提高可读性。文章涵盖Lambda表达式的背景、作用、语法及应用场景等关键内容。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

一，Lambda表达式背景

Lambda表达式是Java SE 8中一个重要的新特性。lambda表达式允许你通过表达式来代替功能接口。 lambda表达式就和方法一样,它提供了一个正常的参数列表和一个使用这些参数的主体(body,可以是一个表达式或一个代码块)。 Lambda 表达式（Lambda expression）可以看作是一个匿名函数，基于数学中的λ演算得名，也可称为闭包（Closure）

二，Lambda表达式作用

Lambda 表达式可以取代大部分的匿名内部类，写出更优雅的 Java 代码，尤其在集合的遍历和其他集合操作中，可以极大地优化代码结构。
JDK 也提供了大量的内置函数式接口供我们使用，使得 Lambda 表达式的运用更加方便、高效。
简介匿名内部类
匿名内部类，就是没有名字的一种嵌套类。它是Java对类的定义方式之一，
最本质的还是一个类
该类没有名字（但是系统会分配一个代号在内存中）
为什么使用匿名内部类
在实际开发中，我们常常遇到这样的情况：一个接口/类的方法的某个实现方式在程序中只会执行一次，但为了使用它，我们需要创建它的实现类/子类去实现/重写。此时可以使用匿名内部类的方式，可以无需创建新的类，减少代码冗余。

public class TestLambda {
    public static void main(String[] args) {
        new Interface01() {
            @Override
           public void learn() {
                System.out.println("好好学习，天天向上");
            }
        }.learn();
    }
}

interface Interface01{
    void learn();
}

lambda表达式

public class TestLambda {
    public static void main(String[] args) {
        ((Interface01) () -> System.out.println("好好学习，天天向上")).learn();
    }
}

interface Interface01{
    void learn();
}

常见的线程使用

public class TestThread {
    public static void main(String[] args) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("我是一个线程");
            }
        }).start();
    }
}

lambda表达式

public class TestThread {
    public static void main(String[] args) {
        new Thread(() -> System.out.println("我是一个线程")).start();
    }
}

匿名内部类可以用在具体类、抽象类、接口上，且对方法个数没有要求

public class TestLambda {
    public static void main(String[] args) {
        new Dog(){
            @Override
            public void eat(String food){
                System.out.println("狗子中的二哈喜欢吃"+food);
            }
        }.eat("大骨头---具体类");
    }
}

class Dog{
    public void eat(String food){
        System.out.println("小狗喜欢吃"+food);
    }
}
---------------------------------------------------------
狗子中的二哈喜欢吃大骨头---具体类

三，Lambda表达式对接口的要求

虽然使用 Lambda 表达式可以对某些接口进行简单的实现，但并不是所有的接口都可以使用 Lambda 表达式来实现。Lambda 规定接口中只能有一个需要被实现的方法，不是规定接口中只能有一个方法

jdk 8 中有另一个新特性：default，被 default 修饰的方法会有默认实现，不是必须被实现的方法，所以不影响 Lambda 表达式的使用

public class TestLambda {
    public static void main(String[] args) {
        new Interface01() {
            @Override
            public void learn() {
                System.out.println("好好学习，天天向上");
            }
        }.learn();
    }
}

interface Interface01{
    void learn();
    default void play() {
        System.out.println("发展体育，强身健体");
    }
}

Interface01接口中只能有一个需要被实现的方法learn，可以实现lambda，

public class TestLambda {
    public static void main(String[] args) {
        ((Interface01) () -> System.out.println("好好学习，天天向上")).learn();
    }
}

interface Interface01{
    void learn();
    default void play() {
        System.out.println("发展体育，强身健体");
    }
}
----------------------------
好好学习，天天向上

public class TestLambda {
    public static void main(String[] args) {
          public static void main(String[] args) {
        ((Interface01) () -> System.out.println("好好学习，天天向上")).play();
    }
}

interface Interface01{
    void learn();
    default void play(){
        System.out.println("锻炼身体");
    };
}
-----------------------------------
锻炼身体

假如play方法没有默认实现，则不可以使用lambda表达式

public class TestLambda {
    public static void main(String[] args) {
        new Interface01() {
            @Override
            public void learn() {
                System.out.println("好好学习，天天向上");
            }
            public void play(){
                System.out.println("发展体育，强身健体");
            }
        }.learn();
    }
}

interface Interface01{
    void learn();
    void play();
}

四，@FunctionalInterface注解使用

函数式接口（Functional Interface）：所谓的函数式接口，当然首先是一个接口，然后就是在这个接口里面只能有一个抽象方法。
Java 8为函数式接口引入了一个新注解@FunctionalInterface，主要用于编译级错误检查，加上该注解，当你写的接口不符合函数式接口定义的时候，编译器会报错。
在这里插入图片描述
加上@FunctionalInterface之后，不符合函数式接口定义报错

修改后符合定义规则，注解不再报错

每一个java类都是Object的子类，也都继承了它类中的equals/hashCode/toString方法，那么在类的接口上包含这些默认方法是没有意义的
在这里插入图片描述

五，Lambda基础语法

语法形式为 () -> {}，其中 () 用来描述参数列表，{} 用来描述方法体，-> 为 lambda运算符，读作(goes to)
以下给出6个基本接口以供学习

/**
 * 多参数无返回值
 */
@FunctionalInterface
interface NoReturnMultiParam {
    void method(int a, int b);
}

/**
 * 无参数无返回值
 */
@FunctionalInterface
interface NoReturnNoParam {
    void method();
}

/**
 * 一个参数无返回值
 */
@FunctionalInterface
interface NoReturnOneParam {
    void method(int a);
}

/**
 * 多参数有返回值
 */
@FunctionalInterface
interface ReturnMultiParam {
    int method(int a, int b);
}

/**
 * 无参数有返回值
 */
@FunctionalInterface
interface ReturnNoParam {
    int method();
}

/**
 * 一个参数有返回值
 */
@FunctionalInterface
interface ReturnOneParam {
    int method(int a);
}

语法形式为 () -> {}，其中 () 用来描述参数列表，如果只有一个参数则可以省略参数小括号
{} 用来描述方法体，方法体只有一行{}可以省略，
-> 为 lambda运算符，读作(goes to)

public class LambdaTest {
    public static void main(String[] args) {
        //多参数无返回值
        NoReturnMultiParam noReturnMultiParam = ((NoReturnMultiParam) (a, b) -> System.out.println("NoReturnMultiParam---param:" + a + ":" + b));
        noReturnMultiParam.method(1, 2);
        //无参数无返回值
        NoReturnNoParam noReturnNoParam = () -> System.out.println("NoReturnNoParam");
        noReturnNoParam.method();
        //一个参数无返回值
        NoReturnOneParam noReturnOneParam = a -> System.out.println("noReturnOneParam---param:" + a);
        noReturnOneParam.method(8);
        //多参数有返回值
        ReturnMultiParam returnMultiParam = (a, b) ->{
            System.out.println("ReturnMultiParam---param:"+a+b);
            return a+b;
        };
        returnMultiParam.method(3, 5);
        //无参数有返回值
        ReturnNoParam returnNoParam = () -> {
            System.out.println("ReturnNoParam---return:10");
            return 10;
        };
        returnNoParam.method();
        //一个参数有返回值
        ReturnOneParam returnOneParam = (a) -> {
            System.out.println("ReturnOneParam---param:"+a+" return:"+a+8);
            return a+8;
        };
        returnOneParam.method(8);
    }

}
---------------------------------------------
NoReturnMultiParam---param:1:2
NoReturnNoParam
noReturnOneParam---param:8
ReturnMultiParam---param:35
ReturnNoParam---return:10
ReturnOneParam---param:8 return:88

五，Lambda表达式常用示例

lambda表达式引用方法
有时候我们不是必须要自己重写某个匿名内部类的方法，我们可以可以利用 lambda表达式的接口快速指向一个已经被实现的方法。
语法
方法归属者::方法名静态方法的归属者为类名，普通方法归属者为对象

class TestExe {
    static int doubleNum(int a){
        return a*2;
    }
    int addTwo(int a){
        return a+2;
    }
}

public class Exe01 {
    public static void main(String[] args) {
        //lambda1引用了已经实现的doubleNum方法
        ReturnOneParam lambda1 = TestExe::doubleNum;
        System.out.println(lambda1.method(8));
        
        //lambda2引用了已经实现的addTwo方法
        TestExe exe = new TestExe();
        ReturnOneParam lambda2 = exe::addTwo;
        System.out.println(lambda2.method(8));
    }

构造方法引用
一般我们需要声明接口，该接口作为对象的生成器，通过类名::new 的方式来实例化对象，然后调用方法返回对象。
在这里插入图片描述
Lambda表达式创建线程
我们以往都是通过创建 Thread 对象，然后通过匿名内部类重写 run() 方法，一提到匿名内部类我们就应该想到可以使用 lambda 表达式来简化线程的创建过程。

遍历集合
我们可以调用集合的 public void forEach(Consumer<? super E> action) 方法，通过 lambda 表达式的方式遍历集合中的元素。以下是 Consumer 接口的方法以及遍历集合的操作。Consumer 接口是 jdk 为我们提供的一个函数式接口。
在这里插入图片描述

out变量声明就是PrintStream类
在这里插入图片描述

删除集合中的某个元素
我们通过public boolean removeIf(Predicate<? super E> filter)方法来删除集合中的某个元素，Predicate（[predɪkət]）也是 jdk 为我们提供的一个函数式接口，可以简化程序的编写。
Predicate 是一个泛型函数接口，表示单个参数函数，该函数返回布尔值（true或false）。此接口在java.util.function包中可用，并且包含用于评估给定参数谓词的test（T t）方法。
在这里插入图片描述

集合内元素的排序
在以前我们若要为集合内的元素排序，就必须调用 sort 方法，传入比较器匿名内部类重写 compare 方法，我们现在可以使用 lambda 表达式来简化代码

Lambda表达式中的闭包问题
这个问题我们在匿名内部类中也会存在，如果我们把注释放开会报错，告诉我 num 值是 final 不能被改变。这里我们虽然没有标识 num 类型为 final，但是在编译期间虚拟机会帮我们加上 final 修饰关键字
在这里插入图片描述
Java8中强制申明的常用函数式接口
Runnable、Callable、Comparator、Consumer、Supplier、Function<T, R>、Predicate

1，Function<T, R>接口

Function 接口是一个功能型接口，是一个转换数据的作用。接收一个T参数，返回一个R结果
Function 接口实现 apply 方法来做转换。
Stream 类的 map 方法了，map 方法传入一个 Function 接口，返回一个转换后的 Stream类
在这里插入图片描述

Consumer接口
消费型接口，接收一个参数，并处理，不返回

Predicate接口
Predicate 接口是一个谓词型接口，是一个类似于 bool 类型的判断的接口。接收一个T类型参数，返回一个bool值，例：Stream的filter接口参数为Predicate<? super T>
在这里插入图片描述
Supplier接口
生产者接口,没有参数，返回一个T类型的结果。
1、Supplier 接口可以理解为一个容器，用于装数据的。
2、Supplier 接口有一个 get 方法，可以返回值。
Optional中的 orElseGet 方法的参数就是Supplier<? extends T>
在这里插入图片描述