Lambda表达式与函数式接口详解

最新推荐文章于 2025-03-17 15:26:22 发布

置顶筱白爱学习

最新推荐文章于 2025-03-17 15:26:22 发布

阅读量2.4k

点赞数 3

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

本文链接：https://blog.youkuaiyun.com/weixin_43552143/article/details/122364188

版权

爱学习→Java 专栏收录该内容

36 篇文章

订阅专栏

本文深入讲解Java8中的Lambda表达式和函数式接口，包括语法、特性及多种实用案例，如事件处理、列表迭代、过滤操作等，帮助读者掌握高效编程技巧。

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

1.用lambda表达式实现Runnable

2.使用Java 8 lambda表达式进行事件处理

3.使用lambda表达式对列表进行迭代

4.使用lambda表达式和函数式接口Predicate

5.如何在lambda表达式中加入Predicate

6.Java 8中使用lambda表达式的Map和Reduce示例

10.计算集合元素的最大值、最小值、总和以及平均值

一、函数式接口

函数式接口，有且仅有一个抽象方法，Object的public方法除外。

1.语法：

@FunctionalInterface
public interface Func{
    Object clone();   // Object的方法
    void run();       // 自定义抽象方法
}

2.函数式接口特征：

接口中标注了@FunctionalInterface注解
接口中只有一个抽象方法会被编译器自动认识成函数式接口
接口中有一个抽象方法，同时包含了Object类的其他抽象方法也会被识别成抽象接口

3.函数式接口汇总：

名称	一元接口	说明	二元接口	说明
一般函数	Function	一元函数，抽象apply方法	BiFunction	二元函数，抽象apply方法
算子函数（输入输出同类型）	UnaryOperator	一元算子，抽象apply方法	BinaryOperator	二元算子，抽象apply方法
谓词函数(输出boolean)	Predicate	一元谓词，抽象test方法	BiPredicate	二元谓词，抽象test方法
消费者（无返回值）	Consumer	一元消费者函数，抽象accept方法	BiConsumer	二元消费者，抽象accept方法
供应者（无参数，只有返回值）	Supplier	供应者函数，抽象get方法	-	-

二、lambda

1.lambda前置条件：

必须是函数式接口才可以使用lambda表达式

2.lambda表达式的语法:

(参数名) -> {代码块};    // 单行可以不加{}，多行必须加{}

LambdaParameters -> LambdaBody
args -> expr或者(object... args) -> {函数式接口抽象方法实现逻辑}
1.()参数的个数，根据函数式接口里面抽象的参数个数来决定，当参数只有一个的时候，()可以省略
2.当expr逻辑非常简单的时候，{}和return可以省略

3.表达式案例

 ()->{}
 ()->{System.out.println(1);}
 ()->System.out.println(1)
 ()->{return 100;}
 ()->100
 ()->null
 (int x)->{return x+1;}
 (int x)->x+1
 (x)->x+1
 x->x+1

4.lambda表达式三种编写方式：

1) expression：单条语句表达式

2) statement：语句块

3) reference：方法引用

expression单条语句表达式：

expression表达式中不需要写return关键字，解释器会自动将表达式的计算结果进行返回。

// 例： （参数）-> 表达式

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

statement语句块：

statement语句块通过大括号{}包裹多条语句，如果是需要返回结果的接口，必须显示的加上return指明返回的变量

// 例： (参数) -> {}

// 无返回值：
public interface MyInterface{
    void test(String n, String c);
}

public static void testLambada1(){
    MyInterface myInterface = (String n,String c) -> {
        System.out.println(n);
        System.out.println(c);
    };
    myInterface.test("abc","123");
}

// 有返回值：
public interface MyInterface1{
    String test1(String n, String c);
}

public static void testLambada2(){
    MyInterface1 myInterface = (String n,String c) -> {
        System.out.println(n);
        System.out.println(c);
        return n + c;
    };
    System.out.println(myInterface.test1("abc","123"));
}

reference方法引用：

如果某个方法再结构上与lambada表达式中对应方法是匹配的那么就可以直接引用给lambada表达式，其总共包含4种引用类型语法格式见表格：

类型	语法
基于实例方法引用	object::methodName
构造方法引用	className::new
基于参数实例方法引用	className::methodName
静态方法引用	className::staticMethodName

基于实例方法引用(示例)：

package com.test.demo;

import java.util.function.Supplier;
import java.util.function.UnaryOperator;

/**
 * Created by xiaobaiaixuexi on 2022-1-10
 */
public class InstantMethodUse {

    String put() {
        return "hello";
    }

    public String toUpCase(String s) {
        return s.toUpperCase();
    }

    // 调用当前实例的方法
    void test() {
        UnaryOperator<String> unaryOperator = this::toUpCase;
        System.out.println(unaryOperator.apply("this inst method"));

    }

    public static void main(String[] args) {
        Supplier<String> stringSupplier = () -> new InstantMethodUse().put();
        Supplier<String> stringSupplier1 = () -> {
            return new InstantMethodUse().put();
        };
        Supplier<String> stringSupplier2 = new InstantMethodUse()::put;
        System.out.println(stringSupplier2.get());
        //普通lambda表达式使用
        Supplier<String> stringSupplier3 = () -> new InstantMethodUse().put();

        //两种方式使用
        UnaryOperator<String> unaryOperator = new InstantMethodUse()::toUpCase;
        //新建对象引用
        InstantMethodUse instantMethodUse = new InstantMethodUse();
        UnaryOperator<String> unaryOperator1 = instantMethodUse::toUpCase;
        System.out.println(unaryOperator.apply("lambda instMethod Use") + "  ===  " + unaryOperator1.apply("lambda instMethod Use"));

        instantMethodUse.test();
    }
}

构造方法引用(示例)：

// 构造方法引用示例：

public interface MyInterface{
    // 获取所有
    List<String> getAll();
}

public static void main(String[] args){
    MyInterface i = ArrayList:new;
}

基于参数示例方法引用(示例)：

// 基于参数示例方法引用(示例)：

public interface MyInterface{
    // 比较一下
    void compare(String str1, String str2);
}

pulbic static void main(String[] args){
    MyInterface i = String::compareTo;
}

基于静态方法引用(示例)：

package com.test.demo;

import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Supplier;

/**
 * Created by xiaobaiaixuexi on 2022-1-10
 */
public class StaticMethodUse {

    static <T> String hello(T s) {
        return s.toString();
    }
    static <T> String ret() {
        return "hello";
    }
    static void getSize(String s) {
        System.out.println(s.length());
    }
    static String toUpCase(String s){
        return s.toUpperCase();
    }
    public static void main(String[] args) {
        Supplier<String> supplier = () -> hello("hello");
        //使用方法引用 Supplier T get();
        // 1、只支持输出参数，不支持输入参数，所以一下方法报错
        //2、方法的引用为什么不需要括号?因为其仅仅是方法的引用，并没有执行
//        Supplier<String> stringSupplier = StaticMethodUse::hello("wqer");  // 报错
        Supplier<String> s = StaticMethodUse::ret;
        Supplier<String> supplier1 = Fun::put;
        Function<Integer, String> function = StaticMethodUse::hello;
        //方法的参数必须在调用的时候传入,必须调用函数式接口
        System.out.println("function" + function.apply(123));

        //普通lambda使用
        Consumer<String> consumer = size -> StaticMethodUse.getSize(size);
        //方法的引用为什么不需要括号?因为其仅仅是方法的引用，并没有执行
        Consumer<String> c1 = StaticMethodUse::getSize;
        c1.accept("hello use lambda");

        //输出参数大写
        Function<String ,String> function1 = (ss) -> ss.toUpperCase();
        Function<String,String> function2 = StaticMethodUse::toUpCase;
        Function<String,String> function3 = Fun::toUpCase;
        System.out.println(function1.apply("aasdf"));
        System.out.println(function2.apply("aasdf"));
        System.out.println(function3.apply("aasdf"));
    }
}

class Fun {
    static String put() {
        return "hello";
    }
    static String toUpCase(String s){
        return s.toUpperCase();
    }
}

5.lambda表达式主要特征总结：

可选类型声明：不需要声明参数类型，编译器可以统一识别参数值。
可选的参数圆括号：一个参数无需定义圆括号，但多个参数需要定义圆括号。
可选的大括号：如果主题包含了一个语句，就不需要使用大括号。
可选的返回关键字：如果主体只有一个表达式返回值则编译器会自动返回值，大括号需要指定表达式返回了一个数值。

三、常用lambda表达式的实现案例

1.用lambda表达式实现Runnable

// Java 8之前：
new Thread(new Runnable() {
    @Override
    public void run() {
    System.out.println("Before Java8, too much code for too little to do");
    }
}).start();

//Java 8方式：
new Thread( () -> System.out.println("In Java8, Lambda expression rocks !!") ).start();

输出：

too much code, for too little to do
Lambda expression rocks !!

2.使用Java 8 lambda表达式进行事件处理

如果你用过Swing API编程，你就会记得怎样写事件监听代码。这又是一个旧版本简单匿名类的经典用例，但现在可以不这样了。你可以用lambda表达式写出更好的事件监听代码，如下所示：

// Java 8之前：
JButton show =  new JButton("Show");
show.addActionListener(new ActionListener() {
    @Override
    public void actionPerformed(ActionEvent e) {
    System.out.println("Event handling without lambda expression is boring");
    }
});

// Java 8方式：
show.addActionListener((e) -> {
    System.out.println("Light, Camera, Action !! Lambda expressions Rocks");
});

3.使用lambda表达式对列表进行迭代

// Java 8之前：
List features = Arrays.asList("Lambdas", "Default Method", "Stream API", "Date and Time API");
for (String feature : features) {
    System.out.println(feature);
}

// Java 8之后：
List features = Arrays.asList("Lambdas", "Default Method", "Stream API", "Date and Time API");
features.forEach(n -> System.out.println(n));
 
// 使用Java 8的方法引用更方便，方法引用由::双冒号操作符标示，
// 看起来像C++的作用域解析运算符
features.forEach(System.out::println);

输出：

Lambdas
Default Method
Stream API
Date and Time API

4.使用lambda表达式和函数式接口Predicate

// 以下代码，如果报错，则需要把泛型加上
public static void main(args[]){
    List languages = Arrays.asList("Java", "Scala", "C++", "Haskell", "Lisp");
 
    System.out.println("Languages which starts with J :");
    filter(languages, (str)->str.startsWith("J"));
 
    System.out.println("Languages which ends with a ");
    filter(languages, (str)->str.endsWith("a"));
 
    System.out.println("Print all languages :");
    filter(languages, (str)->true);
 
    System.out.println("Print no language : ");
    filter(languages, (str)->false);
 
    System.out.println("Print language whose length greater than 4:");
    filter(languages, (str)->str.length() > 4);
}
 
public static void filter(List names, Predicate condition) {
    for(String name: names)  {
        if(condition.test(name)) {
            System.out.println(name + " ");
        }
    }
}

输出：

Languages which starts with J :
Java
Languages which ends with a
Java
Scala
Print all languages :
Java
Scala
C++
Haskell
Lisp
Print no language :
Print language whose length greater than 4:
Scala
Haskell

// 更好的办法
public static void filter(List names, Predicate condition) {
    names.stream().filter((name) -> (condition.test(name))).forEach((name) -> {
        System.out.println(name + " ");
    });
}

5.如何在lambda表达式中加入Predicate

java.util.function.Predicate 允许将两个或更多的 Predicate 合成一个。它提供类似于逻辑操作符AND和OR的方法，名字叫做and()、or()和xor()，用于将传入 filter() 方法的条件合并起来。例如，要得到所有以J开始，长度为四个字母的语言，可以定义两个独立的 Predicate 示例分别表示每一个条件，然后用 Predicate.and() 方法将它们合并起来，如下所示：

// 甚至可以用and()、or()和xor()逻辑函数来合并Predicate，
// 例如要找到所有以J开始，长度为四个字母的名字，你可以合并两个Predicate并传入
Predicate<String> startsWithJ = (n) -> n.startsWith("J");
Predicate<String> fourLetterLong = (n) -> n.length() == 4;
names.stream()
    .filter(startsWithJ.and(fourLetterLong))
    .forEach((n) -> System.out.print("nName, which starts with 'J' and four letter long is : " + n));

6.Java 8中使用lambda表达式的Map和Reduce示例

6.1 示例一

// 不使用lambda表达式为每个订单加上12%的税
List costBeforeTax = Arrays.asList(100, 200, 300, 400, 500);
for (Integer cost : costBeforeTax) {
    double price = cost + .12*cost;
    System.out.println(price);
}
 
// 使用lambda表达式
List costBeforeTax = Arrays.asList(100, 200, 300, 400, 500);
costBeforeTax.stream().map((cost) -> cost + .12*cost).forEach(System.out::println);

输出：

6.2 示例二

在上个例子中，可以看到map将集合类（例如列表）元素进行转换的。还有一个 reduce() 函数可以将所有值合并成一个。Map和Reduce操作是函数式编程的核心操作，因为其功能，reduce 又被称为折叠操作。另外，reduce 并不是一个新的操作，你有可能已经在使用它。SQL中类似 sum()、avg() 或者 count() 的聚集函数，实际上就是 reduce 操作，因为它们接收多个值并返回一个值。流API定义的 reduceh() 函数可以接受lambda表达式，并对所有值进行合并。IntStream这样的类有类似 average()、count()、sum() 的内建方法来做 reduce 操作，也有mapToLong()、mapToDouble() 方法来做转换。这并不会限制你，你可以用内建方法，也可以自己定义。在这个Java 8的Map Reduce示例里，我们首先对所有价格应用 12% 的VAT，然后用 reduce() 方法计算总和。

// 为每个订单加上12%的税
// 老方法：
List costBeforeTax = Arrays.asList(100, 200, 300, 400, 500);
double total = 0;
for (Integer cost : costBeforeTax) {
    double price = cost + .12*cost;
    total = total + price;
}
System.out.println("Total : " + total);
 
// 新方法：
List costBeforeTax = Arrays.asList(100, 200, 300, 400, 500);
double bill = costBeforeTax.stream().map((cost) -> cost + .12*cost).reduce((sum, cost) -> sum + cost).get();
System.out.println("Total : " + bill);

输出：

Total : 1680.0
Total : 1680.0

7.通过过滤创建一个String列表

过滤是Java开发者在大规模集合上的一个常用操作，而现在使用lambda表达式和流API过滤大规模数据集合是惊人的简单。流提供了一个 filter() 方法，接受一个 Predicate 对象，即可以传入一个lambda表达式作为过滤逻辑。下面的例子是用lambda表达式过滤Java集合，将帮助理解。

// 创建一个字符串列表，每个字符串长度大于2
List<String> filtered = strList.stream().filter(x -> x.length()> 2).collect(Collectors.toList());
System.out.printf("Original List : %s, filtered list : %s %n", strList, filtered);

输出：

Original List : [abc, , bcd, , defg, jk], filtered list : [abc, bcd, defg]

8.对列表的每个元素应用函数

我们通常需要对列表的每个元素使用某个函数，例如逐一乘以某个数、除以某个数或者做其它操作。这些操作都很适合用 map() 方法，可以将转换逻辑以lambda表达式的形式放在 map() 方法里，就可以对集合的各个元素进行转换了，如下所示。

// 将字符串换成大写并用逗号链接起来
List<String> G7 = Arrays.asList("USA", "Japan", "France", "Germany", "Italy", "U.K.","Canada");
String G7Countries = G7.stream().map(x -> x.toUpperCase()).collect(Collectors.joining(", "));
System.out.println(G7Countries);

输出：

USA, JAPAN, FRANCE, GERMANY, ITALY, U.K., CANADA

9.复制不同的值，创建一个子列表

本例展示了如何利用流的 distinct() 方法来对集合进行去重。

// 用所有不同的数字创建一个正方形列表
List<Integer> numbers = Arrays.asList(9, 10, 3, 4, 7, 3, 4);
List<Integer> distinct = numbers.stream().map( i -> i*i).distinct().collect(Collectors.toList());
System.out.printf("Original List : %s,  Square Without duplicates : %s %n", numbers, distinct);

输出：

Original List : [9, 10, 3, 4, 7, 3, 4],  Square Without duplicates : [81, 100, 9, 16, 49]

10.计算集合元素的最大值、最小值、总和以及平均值

IntStream、LongStream 和 DoubleStream 等流的类中，有个非常有用的方法叫做 summaryStatistics() 。可以返回 IntSummaryStatistics、LongSummaryStatistics 或者 DoubleSummaryStatistic s，描述流中元素的各种摘要数据。在本例中，我们用这个方法来计算列表的最大值和最小值。它也有 getSum() 和 getAverage() 方法来获得列表的所有元素的总和及平均值。

//获取数字的个数、最小值、最大值、总和以及平均值
List<Integer> primes = Arrays.asList(2, 3, 5, 7, 11, 13, 17, 19, 23, 29);
IntSummaryStatistics stats = primes.stream().mapToInt((x) -> x).summaryStatistics();
System.out.println("Highest prime number in List : " + stats.getMax());
System.out.println("Lowest prime number in List : " + stats.getMin());
System.out.println("Sum of all prime numbers : " + stats.getSum());
System.out.println("Average of all prime numbers : " + stats.getAverage());

输出：

Highest prime number in List : 29
Lowest prime number in List : 2
Sum of all prime numbers : 129
Average of all prime numbers : 12.9

作者：筱白爱学习！！

欢迎关注转发评论点赞沟通，您的支持是筱白的动力！