JAVA-Lambda表达式(高质量)

已于 2025-03-09 22:45:43 修改
阅读量943 收藏 14
点赞数 33
文章标签： java 开发语言
于 2025-02-14 18:32:35 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/Lizhihao_/article/details/145616780
版权

要了解Lambda表达式,首先需要了解什么是函数式接口，函数式接口定义：一个接口有且只有一个抽象方法 。

一、函数式接口

1.@FunctionalInterger

注意：

1. 如果一个接口只有一个抽象方法，那么该接口就是一个函数式接口
2. 如果我们在某个接口上声明了 @FunctionalInterface 注解，那么编译器就会按照函数式接口的定义来要求该接口，这样如果有两个抽象方法，程序编译就会报错的。所以，从某种意义上来说，只要你保证你的接口中只 有一个抽象方法，你可以不加这个注解。加上就会自动进行检测的。

2.函数式接口的使用

//无返回值无参数
@FunctionalInterface
interface NoParameterNoReturn {
    //一般最主要使用
    void test();

    default void test2() {
        System.out.println("JDK1.8新特性，default默认方法可以有具体的实现");
    }
    static void test3() {
        System.out.println("静态方法也可以");
    }
}

public class TestLambda {

    public static void main(String[] args) {
        //用接口接收一个匿名内部类
        NoParameterNoReturn noParameterNoReturn = new NoParameterNoReturn() {
            @Override
            public void test() {
                System.out.println("无参的方法");
            }
            @Override
            public void test2() {
                System.out.println("默认的方法重写了");
            }
        };

        //平时最常用的方式
        noParameterNoReturn.test();
        //默认方法也可以用匿名内部类重写
        noParameterNoReturn.test2();
        //通过类名调用
        NoParameterNoReturn.test3();
    }
}

 执行结果：

2.1 函数式接口的补充介绍

函数式接口中可以有以下几种方法，即便是被@FunctionalInterface修饰:

  1. 抽象方法
  2. 继承的方法
  3. 默认的方法
  4. 静态的方法
  5. 私有的方法
@FunctionalInterface
interface MyFunctionalInterface {
    //抽象方法
    void myAbstractMethod();

    //继承的方法，继承自Object
    boolean equals(Object obj);

    default void defaultMethod() {
        System.out.println("这是默认方法");
    }
    static void staticMethod() {
        System.out.println("这是静态方法");
    }
    //虽然可以有，但是不能访问
    private void helperMethod() {
        System.out.println("这是私有方法");
    }

}
class Test3 implements MyFunctionalInterface {
    @Override
    public boolean equals(Object obj) {
        return super.equals(obj);
    }

    @Override
    public void myAbstractMethod() {
        System.out.println("这是抽象方法");
    }
}


public class TestLambda {
    public static void main(String[] args) {
        //重写抽象方法,并调用
        MyFunctionalInterface myFunctionalInterface = () -> System.out.println("这是抽象方法");
        myFunctionalInterface.myAbstractMethod();
        
        //调用默认方法
        myFunctionalInterface.defaultMethod();
        
        //用类名调用,静态方法
        MyFunctionalInterface.staticMethod();
        
        //需要创建类来实现，继承的方法
        Test3 test3 = new Test3();
//        test3.equals(……)

    }
}

二、Lambda的基本介绍

Lambda 表达式是 Java SE 8 中一个重要的新特性。L ambda 表达式允许你通过表达式来代替功能接口。  Lambda 表达式就和方法一样, 它提供了一个正常的参数列表和一个使用这些参数的主体 (body, 可以是一个表达式或一个代码块) 。 Lambda 表达式（ Lambda expression ） ，基于数学中的 λ 演算得名，也可称为闭包（ Closure ） 。
1. Lambda 表达式的语法
基本语法 : (parameters) -> expression 或 (parameters) ->{ statements; }
Lambda表达式由三部分组成：
1. paramaters ：类似方法中的形参列表，这里的参数是函数式接口里的参数。 这里的参数类型可以明确的声明也可不声明而由JVM隐含的推断 。另外当只有 一个推断类型时可以省略掉圆括号。
2. -> ：可理解为 “ 被用于 ” 的意思
3. 方法体 ：可以是表达式也可以代码块，是函数式接口里方法的实现。代码块可返回一个值或者什么都不反回，这里的代码块块等同于方法的方法体。如果是表达式，也可以返回一个值或者什么都不反回。 如果只有返回什么一条语句，可以不写{} 和 return，他们只能一起不写。 

// 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的使用

1.无返回值情况

1.1 无参数

//无返回值无参数
@FunctionalInterface
interface NoParameterNoReturn {
    void test();
}

public class TestLambda {

    public static void main(String[] args) {
        //用接口接收一个匿名内部类
        NoParameterNoReturn noParameterNoReturn = new NoParameterNoReturn() {
            @Override
            public void test() {
                System.out.println("无参的方法");
            }
        };
        noParameterNoReturn.test();
        System.out.println("===下面用Lambda实现===");


        NoParameterNoReturn noParameterNoReturn1 = () -> System.out.println("无参的方法");
        //或者
        //NoParameterNoReturn noParameterNoReturn1 = () -> {System.out.println("无参的方法");};

        noParameterNoReturn1.test();
    }
}

 结果：

而且发现就连 new 接口类型 都被省略了，所以Lambda表达式其实非常抽象，而且使用Lambda的前提是要熟悉你用的函数式接口。

 1.2 一个参数

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

public class TestLambda {
    public static void main(String[] args) {
        OneParameterNoReturn oneParameterNoReturn = new OneParameterNoReturn() {
            @Override
            public void test(int a) {
                System.out.println(a);
            }
        };
        //调用
        oneParameterNoReturn.test(10);

        System.out.println("===下面用Lambda实现===");
        //                                         此时的参数名，可以随便取
        OneParameterNoReturn oneParameterNoReturn1 = k -> System.out.println(k);
        //或者
//        OneParameterNoReturn oneParameterNoReturn1 = (k) -> {System.out.println(k);};
        oneParameterNoReturn1.test(20);

    }
}

结果：

1.3 多参数情况

//无返回值多个参数
@FunctionalInterface
interface MoreParameterNoReturn {
    void test(int a,int b);
}


public class TestLambda {

    public static void main(String[] args) {
        MoreParameterNoReturn moreParameterNoReturn = new MoreParameterNoReturn() {
            @Override
            public void test(int a, int b) {
                System.out.println(a+b);
            }
        };
        moreParameterNoReturn.test(10,20);

        System.out.println("===下面用Lambda实现===");

        MoreParameterNoReturn moreParameterNoReturn1 = (a,b) -> System.out.println(a+b);
        //当参数是多个，那么()就不能省略了
//          MoreParameterNoReturn moreParameterNoReturn1 = a,b -> System.out.println(a+b);
        moreParameterNoReturn1.test(20, 30);
    }
}

结果：

2. 有返回值情况

//有返回值无参数
@FunctionalInterface
interface NoParameterReturn {
    int test();
}

public class TestLambda {

    public static void main(String[] args) {
        NoParameterReturn noParameterReturn = new NoParameterReturn() {
            @Override
            public int test() {
                return 200;
            }
        };
        System.out.println(noParameterReturn.test());
        System.out.println("===下面用Lambda实现===");

        NoParameterReturn noParameterReturn1 = () -> 500;
        //或者
//        NoParameterReturn noParameterReturn1 = () -> {return 500;};
        System.out.println(noParameterReturn1.test());
    }
}

结果：

2.1 无参数

//有返回值无参数
@FunctionalInterface
interface NoParameterReturn {
    int test();
}
public class TestLambda {

    public static void main(String[] args) {
        NoParameterReturn noParameterReturn = new NoParameterReturn() {
            @Override
            public int test() {
                return 200;
            }
        };
        System.out.println(noParameterReturn.test());
        System.out.println("===下面用Lambda实现===");

//        NoParameterReturn noParameterReturn1 = () -> 500;

//      或者
        NoParameterReturn noParameterReturn1 = () -> {
            // 如果不只一条语句，就必须加上{}和return
            System.out.println(500);
            return 500;};
        System.out.println(noParameterReturn1.test());
    }
}

2.2 一个参数

//有返回值一个参数
@FunctionalInterface
interface OneParameterReturn {
    int test(int a);
}
public class TestLambda {

    public static void main(String[] args) {
        OneParameterReturn oneParameterReturn = new OneParameterReturn() {
            @Override
            public int test(int a) {
                return a;
            }
        };

        System.out.println(oneParameterReturn.test(100));

        System.out.println("===下面用Lambda实现===");

        OneParameterReturn oneParameterReturn1 = a -> {return a;};
        //或者
//        OneParameterReturn oneParameterReturn1 = a -> a;
        System.out.println(oneParameterReturn1.test(200));
    }
}

结果：

2.3 多参数

//有返回值多参数
@FunctionalInterface
interface MoreParameterReturn {
    int test(int a,int b);
}
public class TestLambda {

    public static void main(String[] args) {
        MoreParameterReturn moreParameterReturn = new MoreParameterReturn() {
            @Override
            public int test(int a, int b) {
                return a + b;
            }
        };
        System.out.println(moreParameterReturn.test(10, 20));

        System.out.println("===下面用Lambda实现===");

        MoreParameterReturn moreParameterReturn1 = (a,b) -> {return a+b;};
        //或者
//        MoreParameterReturn moreParameterReturn1 = (a,b) -> a + b;
        System.out.println(moreParameterReturn1.test(20, 30));
    }
}

结果：

四、总结语法精简

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

 五、变量捕获

匿名内部类：

 Lambda：那么Lambda表达式也是同样的

 这种时候我们最后就加上final保护一下

/有返回值无参数
@FunctionalInterface
interface NoParameterReturn {
    int test();
}
public class TestLambda {

    public static void main(String[] args) {
        //加上final保护一下
        final int a = 0;
//        a = 99; err
        NoParameterReturn noParameterReturn = () -> {
//            a = 100; err
            return a;
        };

        System.out.println(noParameterReturn.test());
    }
}

注意：

如果不是在同一作用域下，语法逻辑是不同的。此时的匿名内部类，相当于一个内部类访问外部类的成员，所以是应该访问到的。就不再是变量捕获了。

 六、Lambda在集合中的使用

为了能够让 Lambda 和 Java 的集合类集更好的一起使用，集合当中，也新增了部分接口，以便与 Lambda 表达式对接。

1. 用Lambda写改为大根堆

PriorityQueue做为堆，我们知道他默认是小根堆，如果需要大根堆需要给比较器，现在有了

Lambda就可以很简便：

class Test implements Comparator<Integer> {
    public int compare(Integer o1, Integer o2) {
        return o2 - o1;
    }
}

public class TestLambda {
    public static void main(String[] args) {
        //方式一：
        PriorityQueue<Integer> priorityQueue = new PriorityQueue<>(new Test());

        priorityQueue.offer(1);
        priorityQueue.offer(2);
        priorityQueue.offer(3);
        priorityQueue.offer(4);
        priorityQueue.offer(5);

        System.out.println(priorityQueue);

        //方式二：
        PriorityQueue<Integer> priorityQueue1 = new PriorityQueue<>(new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o2 - o1;
            }
        });

        //方式三：
        PriorityQueue<Integer> priorityQueue2 = new PriorityQueue<>((o1, o2) -> o2 - o1);

}

2. 用Lambda遍历hash表

public static void main(String[] args) {
        HashMap<Integer,String> hashMap = new HashMap<>();
        hashMap.put(1,"hallo");
        hashMap.put(2,"word");
        hashMap.put(3,"and");
        hashMap.put(4,"Lambda");

        hashMap.forEach(new BiConsumer<Integer, String>() {
            @Override
            public void accept(Integer key, String value) {
                System.out.println("key: " + key + "  value: " + value);
            }
        });

        System.out.println("===以下是Lambda实现===");
        hashMap.forEach( (key,value) -> System.out.println("key: " + key + "  value: " + value) );



}

结果：

等等就不一 一举例了

Lizhihao＿
关注
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值