【Java8特性】——Lambda表达式-CSDN博客

本文链接：https://blog.csdn.net/qq_42000631/article/details/132420663

本文详细介绍了Java8中的Lambda表达式，包括其组成（操作符、形参列表和Lambda体），以及不同情况下的语法格式，如无参、单参数、多参数和类型推断等，并通过示例展示其在Consumer和Comparator接口的应用。

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

一、概述

在Java8 语言中引入的一种新的语法元素和操作符。本质是作为函数式接口的一个实例，依赖于函数式接口。

二、组成

1. Lambda操作符

-> ：Lambda操作符或者箭头操作符，

2. Lambda形参列表

左侧：指定了Lambda表达式需要的参数列表

3. Lambda体

右侧：制定了Lambda体，是抽象方法的实现逻辑，也即Lambda表达式要执行的功能

三、语法格式

1. 无参，无返回值

     /**
     * Lambda 无参，无返回值
     */
    @Test
    public void test1() {
        Runnable r1 = new Runnable() {
            @Override
            public void run() {
                System.out.println("test1.1");
            }
        };
        r1.run();
        System.out.println("--------------------------");
        //无参，无返回值
        Runnable r2 = () -> {
            System.out.println("test1.2");
        };
        r2.run();
    }

2. 需要一个参数，但是没有返回值

/**
     * Lambda 需要一个参数，但是没有返回值
     */
    @Test
    public void test2() {
        Consumer<String> con1 = new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        };
        con1.accept("test2.1");
        System.out.println("--------------------------");
        //需要一个参数，但是没有返回值
        Consumer<String> con2 = (String s) -> {
            System.out.println(s);
        };
        con2.accept("test2.2");
    }

3. 数据类型可以省略，因为可以由编译器推断得出，称为“类型推断”

/**
     * Lambda 数据类型可以省略，因为可以由编译器推断得出，称为“类型推断”
     */
    @Test
    public void test3() {
        //需要一个参数，但是没有返回值
        Consumer<String> con = (s) -> {
            System.out.println(s);
        };
        con.accept("test3.1");
    }

4. 如果只需要一个参数时，小括号可以省略

/**
     * Lambda 如果只需要一个参数时，小括号可以省略
     */
    @Test
    public void test4() {
        //需要一个参数，但是没有返回值
        Consumer<String> con4 = s -> {
            System.out.println(s);
        };
        con4.accept("test4.1");

    }

5. 需要两个或者以上的参数，多条执行语句，并且可以有返回值

/**
     * Lambda 需要两个或者以上的参数，多条执行语句，并且可以有返回值
     */
    @Test
    public void test5() {

        Comparator<Integer> com1 = new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                System.out.println("o1 : " + o1);
                System.out.println("o2 : " + o2);
                return o1.compareTo(o2);
            }
        };
        System.out.println("result1:" + com1.compare(12, 21));
        System.out.println("--------------------------");
        //需要两个或者以上的参数，多条执行语句，并且可以有返回值
        Comparator<Integer> com2 = (o1, o2) -> {
            System.out.println("o1 : " + o1);
            System.out.println("o2 : " + o2);
            return o1.compareTo(o2);
        };
        System.out.println("result2 : " + com2.compare(32, 21));
    }

6. Lambda体只有一条语句时，return 和大括号若有，都可以省略

/**
     * Lambda Lambda体只有一条语句时，return 和 大括号 若有，都可以省略
     */
    @Test
    public void test6() {
        //需要两个或者以上的参数，多条执行语句，并且可以有返回值
        Comparator<Integer> com2 = (o1, o2) -> o1.compareTo(o2);
        System.out.println("result2 : " + com2.compare(33, 21));
    }