Java8 - lambda表达式-CSDN博客

本文链接：https://blog.csdn.net/che_j/article/details/107962106

本文深入探讨了Java中Lambda表达式的使用，从基础语法到高级应用，包括参数类型的简化、小括号的省略、方法体大括号的省略，以及方法引用的实践。通过具体示例，展示了不同参数和返回值情况下Lambda表达式的书写方式，以及如何通过方法引用提高代码的可读性和简洁性。

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

lambda表达式

从基础写法到简化写法

如果方法体只有一条语句，并且是 return 语句，则可以省略方法体大括号
简化参数类型，可以不写参数类型，但是必须所有参数都不写
简化参数小括号，如果只有一个参数则可以省略参数小括号
方法引用方法归属者::方法名静态方法的归属者为类名，普通方法归属者为对象

lambda表达式的基本写法

（）-> { };
方法参数 goes to( -> ) 方法实现

DEMO

不同参数没有返回值的demo可见方法noReturnLambda();
不同参数有返回值的demo可见方法 haveReturnLambda();
方法引用的调用可见functionRefer();<方法引用的详细说明可见Java8 - 方法引用 >

public class LambdaTest {

    public static void main(String args[]) {
        //没有返回值
        noReturnLambda();
        //有返回值
        haveReturnLambda();
        //方法引用 调用
        functionRefer();
    }
    /**
     * 方法归属者::方法名 静态方法的归属者为类名，普通方法归属者为对象
     */
    private static void functionRefer(){
        //接口调用 静态的方法
        HaveReturnOneParam lambda1 = a -> doubleNum(a);
        System.out.println("方法引用=======接口调用-静态方法 return："+lambda1.method(1));
        //lambda2 引用了已经实现静态的 doubleNum 方法
        HaveReturnOneParam lambda2 = LambdaTest::doubleNum;
        System.out.println("方法引用=======对象::静态方法 return："+lambda2.method(2));
        LambdaTest test = new LambdaTest();
       //lambda3 引用了已经实现new对象的 addTwo 方法
        HaveReturnOneParam lambda3 = test::addTwo;
        System.out.println("方法引用=======new对象::方法 return："+lambda3.method(3));
        }
    /**
     * 1.参数 数量和类型 要与 接口中定义的一致
     * 2.返回值类型 要与 接口中定义的一致
     */
    public static int doubleNum(int a) { return a * 2; }
    public int addTwo(int a) { return a + 2; }
    /**
     * 有返回值
     */
    private static void haveReturnLambda(){
        /**
         * 无参有返回值
         */
        HaveReturnNoParam returnNoParam = () -> {
            System.out.print("无参有返======ReturnNoParam");
            return 0;
        };
        int res1=returnNoParam.method();
        System.out.println("无参有返======return:" + res1);
        //如果方法体只有一条语句，并且是 return 语句，则可以省略方法体大括号
        HaveReturnNoParam returnNoParam1 = () -> 1;
        System.out.println("无参有返======简化大括号 return:" + returnNoParam1.method());
        /**
         * 一个参数有返回值
         */
        HaveReturnOneParam returnOneParam = (int a) -> {
            System.out.println("一参有返======ReturnOneParam param:" + a);
            return 0;
        };
        int res2 = returnOneParam.method(0);
        System.out.println("一参有返======return:" + res2);
        //简化参数类型 && 小括号 && 大括号
        HaveReturnOneParam returnOneParam1 = a -> a+1;
        System.out.println("一参有返======简化参数类型 && 小括号 && 大括号 return:" +returnOneParam1.method(1));
        /**
         * 多个参数有返回值
         */
        HaveReturnMultiParam returnMultiParam = (int a, int b) -> {
            System.out.println("多参有返======ReturnMultiParam param:" + "{" + a + "," + b +"}");
            return 0;
        };
        int res3 = returnMultiParam.method(0, 0);
        System.out.println("多参有返======return:" + res3);
        HaveReturnMultiParam returnMultiParam1 = (a, b) -> a+b;
        System.out.println("多参有返======简化参数类型 && 小括号 && 大括号 return:"+returnMultiParam1.method(1, 1));
    }
    /**
     * 无返回值
     */
    private static void noReturnLambda(){
        /**
         * 无参无返回值
         */
        NoReturnNoParam noReturnNoParam = () -> {
            System.out.println("无参无返======NoReturnNoParam");
        };
        noReturnNoParam.method();
        //简化方法体大括号，如果方法条只有一条语句，则可以省略方法体大括号
        NoReturnNoParam noReturnNoParam1 = () -> System.out.println("无参无返======简化方法体大括号");
        noReturnNoParam1.method();
        /**
         * 一个参数无返回值
         */
        NoReturnOneParam noReturnOneParam=(int a)->{
            System.out.println("一参无返======NoReturnOneParam param:"+a);
        };
        noReturnOneParam.method(0);
        //简化参数类型，可以不写参数类型，但是必须所有参数都不写
        NoReturnOneParam noReturnOneParam1 = (a)-> {
            System.out.println("一参无返======简化参数类型 NoReturnOneParam1 param:"+a);
        };
        noReturnOneParam1.method(1);
        //简化参数小括号，如果只有一个参数则可以省略参数小括号
        NoReturnOneParam noReturnOneParam2 = a-> {
            System.out.println("一参无返======简化参数类型&&小括号 NoReturnOneParam2 param:"+a);
        };
        noReturnOneParam2.method(2);
        //简化参数小括号，如果只有一个参数则可以省略参数小括号
        NoReturnOneParam noReturnOneParam3 = a -> System.out.println("一参无返======简化参数类型&&小括号&&大括号 NoReturnOneParam3 param:"+a);
        noReturnOneParam3.method(3);
        /**
         * 多个参数无返回
         */
        NoReturnMultiParam noReturnMultiParam = (int a, int b) -> {
            System.out.println("多参无返======NoReturnMultiParam param:" + "{" + a +"," + + b +"}");
        };
        noReturnMultiParam.method(0, 0);
        NoReturnMultiParam noReturnMultiParam1 = ( a , b ) -> {
            System.out.println("多参无返======NoReturnMultiParam1 param:" + "{" + a +"," + b +"}");
        };
        noReturnMultiParam1.method(0, 1);
        NoReturnMultiParam noReturnMultiParam2 = ( a , b ) -> System.out.println("多参无返======NoReturnMultiParam2 param:" + "{" + a +"," + b +"}");
        noReturnMultiParam2.method(0, 2);
    }
}

@FunctionalInterface
interface HaveReturnMultiParam { int method(int a, int b);}
@FunctionalInterface
interface HaveReturnNoParam{ int method();}
@FunctionalInterface
interface HaveReturnOneParam{ int method(int a);}
@FunctionalInterface
interface NoReturnMultiParam { void method(int a, int b);}
@FunctionalInterface
interface NoReturnNoParam{ void method();}
@FunctionalInterface
interface NoReturnOneParam{ void method(int a);}

运行结果

无参无返======NoReturnNoParam
无参无返======简化方法体大括号
一参无返======NoReturnOneParam param:0
一参无返======简化参数类型 NoReturnOneParam1 param:1
一参无返======简化参数类型&&小括号 NoReturnOneParam2 param:2
一参无返======简化参数类型&&小括号&&大括号 NoReturnOneParam3 param:3
多参无返======NoReturnMultiParam param:{0,0}
多参无返======NoReturnMultiParam1 param:{0,1}
多参无返======NoReturnMultiParam2 param:{0,2}
无参有返======ReturnNoParam无参有返======return:0
无参有返======简化大括号 return:1
一参有返======ReturnOneParam param:0
一参有返======return:0
一参有返======简化参数类型 && 小括号 && 大括号 return:2
多参有返======ReturnMultiParam param:{0,0}
多参有返======return:0
多参有返======简化参数类型 && 小括号 && 大括号 return:2
方法引用=======接口调用-静态方法 return：2
方法引用=======对象::静态方法 return：4
方法引用=======new对象::方法 return：5