Java中Lambda表达式的使用

一只淡水鱼66

于 2024-08-04 11:49:16 发布

阅读量570

点赞数 13

分类专栏： Java 文章标签： java 开发语言

本文链接：https://blog.csdn.net/yican2580/article/details/140903524

版权

Java 专栏收录该内容

11 篇文章 4 订阅

订阅专栏

Lambda的背景

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

Lambda表达式的语法

基本语法:

(parameters) -> expression 或 (parameters) ->{ statements; }

Lambda表达式由三部分组成：

1. paramaters：类似方法中的形参列表，这里的参数是函数式接口里的参数。这里的参数类型可以明确的声明
也可不声明而由JVM隐含的推断。另外当只有一个推断类型时可以省略掉圆括号。
2. ->：可理解为“被用于”的意思
3. 方法体：可以是表达式也可以代码块，是函数式接口里方法的实现。代码块可返回一个值或者什么都不反回，这里的代码块块等同于方法的方法体。如果是表达式，也可以返回一个值或者什么都不反回。

// 1. 不需要参数,返回值为 2
() -> 2
// 2. 接收一个参数(数字类型),返回其2倍的值
x -> 2 * x
// 3. 接受2个参数(数字),并返回他们的和
(x, y) -> x + y
// 4. 接收2个int型整数,返回他们的乘积
(int x, int y) -> x * y
// 5. 接受一个 string 对象,并在控制台打印,不返回任何值(看起来像是返回void)
(String s) -> System.out.print(s)

函数式接口

在介绍Lambda表达式的使用的时候我们先来介绍函数式接口，这有助于我们快速了解Lambda表达式。

在Java中，函数式接口是指仅包含一个抽象方法的接口，它可以被隐式转换为一个 lambda 表达式或者方法引用。函数式接口的主要用途是支持函数式编程，使得代码更加简洁和易于阅读。

特点：

单一抽象方法：函数式接口只能有一个未实现的方法，这使得它可以表示单一的行为。
默认方法：虽然只能有一个抽象方法，但函数式接口可以包含多个默认方法和静态方法。
@FunctionalInterface 注解：使用 @FunctionalInterface 注解可以清晰地表明一个接口是函数式接口，编译器会强制检查是否满足函数式接口的条件。

示例：

@FunctionalInterface
public interface MyFunctionalInterface {
    void execute();
    
    default void defaultMethod() {
        System.out.println("This is a default method.");
    }
    
    static void staticMethod() {
        System.out.println("This is a static method.");
    }
}

可以使用 lambda 表达式来实现这个函数式接口：

public class Main {
    public static void main(String[] args) {
        MyFunctionalInterface myFunc = () -> System.out.println("Executing...");
        myFunc.execute();  // 输出: Executing...
        
        myFunc.defaultMethod();  // 输出: This is a default method.
        MyFunctionalInterface.staticMethod();  // 输出: This is a static method.
    }
}

结论：

函数式接口是Java 8引入的重要特性，促进了函数式编程的实现，使得编写更加简洁和灵活的代码成为可能。

Lambda表达式的使用

基本语法

Lambda表达式的基本语法如下：

(parameters) -> expression

或者如果有多个语句：

(parameters) -> { statements }

使用示例

下面的例子展示了如何在Java中使用Lambda表达式。

1. 定义函数式接口

首先，我们定义一个简单的函数式接口，该接口只有一个抽象方法：

@FunctionalInterface
public interface MyFunctionalInterface {
    void apply(String message);
}

2. 使用Lambda表达式

接下来，我们使用Lambda表达式来实现这个接口：

public class LambdaExample {
    public static void main(String[] args) {
        // 使用Lambda表达式实现MyFunctionalInterface接口
        MyFunctionalInterface myFunc = (message) -> System.out.println("Message: " + message);
        
        // 调用apply方法
        myFunc.apply("Hello, Lambda!");  // 输出: Message: Hello, Lambda!
    }
}

另一个示例：使用Lambda表达式进行集合操作

Lambda表达式常用于集合操作，特别是与 Stream API结合时。以下是一个使用Lambda表达式过滤和打印列表中所有以“A”开头的字符串的示例：

import java.util.Arrays;
import java.util.List;

public class LambdaStreamExample {
    public static void main(String[] args) {
        List<String> names = Arrays.asList("Alice", "Bob", "Amanda", "Charlie");

        // 使用Lambda表达式过滤以"A"开头的名字
        names.stream()
             .filter(name -> name.startsWith("A"))  // 过滤以“A”开头的名字
             .forEach(name -> System.out.println(name));  // 打印结果
    }
}

总结

Lambda表达式通过简化代码和减少冗余，使得函数式编程在Java中变得更加容易。它特别适用于实现函数式接口，提高了代码的可读性和简洁性。通过以上示例，我们可以看到Lambda表达式在实际应用中的基本使用方式。

语法精简

1. 参数类型可以省略，如果需要省略，每个参数的类型都要省略。
2. 参数的小括号里面只有一个参数，那么小括号可以省略
3. 如果方法体当中只有一句代码，那么大括号可以省略
4. 如果方法体中只有一条语句，且是return语句，那么大括号可以省略，且去掉return关键字。

Lambda的变量捕获

在Lambda当中也可以进行变量的捕获，具体我们看一下代码。

@FunctionalInterface
interface NoParameterNoReturn {
   void test();
}
public static void main(String[] args) {
       int a = 10;
       NoParameterNoReturn noParameterNoReturn = ()->{
           System.out.println("捕获变量："+a);
      };
       noParameterNoReturn.test();
}

Lambda表达式在集合中的使用

在PriorityQueue中的使用

我们在使用PriorityQueue的时候经常要传一个比较器，如下：

public class Main {
    public static void main(String[] args) {
        PriorityQueue<Integer> priorityQueue = new PriorityQueue<>(new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o1 - o2;
            }
        });

    }
}

这时我们就可以用Lambda表达式来代替这个匿名内部类，如下代码：

public class Main {
    public static void main(String[] args) {
        PriorityQueue<Integer> priorityQueue = new PriorityQueue<>((o1,o2)->{return o1 - o2;});
    }
}

这时就提高了代码的简洁性。

在 forEach 方法中的使用

public class Main {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        list.add(3);
        list.add(1);
        list.add(6);
        list.add(4);
        list.forEach(new Consumer<Integer>() {
            @Override
            public void accept(Integer integer) {
                System.out.println(integer);
            }
        });
    }
}

这个方法的作用是遍历整个集合，在传参是的时候要使用 Consumer 这个接口，这时我们就可以利用Lambda表达式来简写代码了。如下：

public class Main {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        list.add(3);
        list.add(1);
        list.add(6);
        list.add(4);
        list.forEach((a)-> System.out.println(a));
    }
}

在 sort 方法中使用

sort 方法是将一个集合进行排序

public class Main {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        list.add(3);
        list.add(1);
        list.add(6);
        list.add(4);
        list.forEach((a)-> System.out.println(a));

        System.out.println("=====");

        list.sort(new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o1-o2;
            }
        });

        list.forEach((a)-> System.out.println(a));
    }
}

用Lambda表达式简化代码

public class Main {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        list.add(3);
        list.add(1);
        list.add(6);
        list.add(4);
        list.forEach((a)-> System.out.println(a));

        System.out.println("=====");

        list.sort((o1,o2) -> {return o1 - o2;});

        list.forEach((a)-> System.out.println(a));
    }
}