Java中的lambda表达式

短命女 2024-02-20 08:38 54阅读 0赞

**目录**

一、背景

二、lambada表达式的基本使用

三、变量捕获

四、lambda在集合中的使用（map和set）

五、优缺点

一、背景

（1）、lambda表达式的定义：

（2）、lambda表达式的语法：

（3）、函数式接口

二、lambada表达式的基本使用

（1）没有使用lambda表达式，简单调用函数式接口展示

（2）上述接口的具体lambda表达式展示

1、无返回值无参数（NoParameterNoReturn）

2、无返回值一个参数（OneParameterNoReturn）

3、无返回值多个参数（MoreParameterNoReturn）

4、有返回值无参数（NoParameterReturn）

5、有返回值一个参数（OneParameterReturn）

6、有返回值多参数（MoreParameterReturn ）

三、变量捕获

（1）、匿名内部类的简单使用

（2）、匿名内部类变量的捕获

（3）、Lambda变量的捕获

四、lambda在集合中的使用（map和set）

（1）、Collection接口

（2）、List接口

（2）、map接口

五、优缺点

优点：

缺点：

都看到这了，给个免费的赞再走吧，谢谢谢谢谢！！！

--------------------

## 一、背景 ##

### （1）、lambda表达式的定义： ###

lambda是JavaSE8的一个重要特性，**允许用lambda表达式来代替功能接口**，lambda表达式和方法一样，有参数，有参数的主体（一个表达式，用花括号括起来）。

### （2）、lambda表达式的语法： ###

> **基本语法:** (parameters) -> expression 或 (parameters) ->\{ statements; \}  
> 
> 
> 1、**parameters：**类似方法体中的形参，这里的参数是函数式接口中方法的参数。
> 
> 2、**->：**可以理解为被用于的意思。
> 
> 3、**statements：**接口中方法的主体，是函数式接口里的方法实现，这里**可以有返回，也可以没有。**

### （3）、函数式接口 ###

**定义：**就是一个接口只有一个抽象方法。

**注意：**1、接口中只有一个抽象方法的才是函数式接口。

2、**@FunctionalInterface 注解** 的作用是加了后编译器会按函数式接口的定义来要求该接口，**如果该接口有两个抽象方法，则会报错**，也可以不加，但是写的时候也要注意，**函数式接口只能一个抽象方法。**

> ![3f62321eb1e94d2db1f71f5919f71e7b.png][]

--------------------

## 二、lambada表达式的基本使用 ##

> 首先，我们先准备好几个函数式接口，代码如下：
> 
>     //无返回值无参数
>     @FunctionalInterface
>     interface NoParameterNoReturn {
>         void test();
>     }
>     //无返回值一个参数
>     @FunctionalInterface
>     interface OneParameterNoReturn {
>         void test(int a);
>     }
>     //无返回值多个参数
>     @FunctionalInterface
>     interface MoreParameterNoReturn {
>         void test(int a,int b);
>     }
>     //有返回值无参数
>     @FunctionalInterface
>     interface NoParameterReturn {
>         int test();
>     }
>     //有返回值一个参数
>     @FunctionalInterface
>     interface OneParameterReturn {
>         int test(int a);
>     }
>     //有返回值多参数
>     @FunctionalInterface
>     interface MoreParameterReturn {
>         int test(int a,int b);
>     }

### （1）没有使用lambda表达式，简单调用函数式接口展示 ###

**lambda表达式也可以理解为简化的匿名内部类，实际上就是创建了一个类，实现了接口，重写了接口里面的方法。**

> 没有使用lambda表达式，我们调用 NoParameterNoReturn函数接口的方法代码如下：
> 
>     //无返回值无参数
>     @FunctionalInterface
>     interface NoParameterNoReturn {
>         void test();
>     }
>     public class Test {
>         public static void main(String[] args) {
>             NoParameterNoReturn noParameterNoReturn = new NoParameterNoReturn() {
>                 @Override
>                 public void test() {
>                     System.out.println("重写了NoParameterNoReturn接口的方法");
>                 }
>             };
>             noParameterNoReturn.test();
>         }
>     }
> 
> 创建一个类，实现NoParameterNoReturn接口，重写了函数式接口的方法。
> 
> 代码执行结果如下：
> 
> ![5cbd900c1c4e49879a01beb0a47eb6f9.png][]

### （2）上述接口的具体lambda表达式展示 ###

#### 1、无返回值无参数（NoParameterNoReturn） ####

> 代码如下：
> 
> >     //无返回值无参数
> >     @FunctionalInterface
> >     interface NoParameterNoReturn {
> >         void test();
> >     }
> >     
> >     NoParameterNoReturn noParameterNoReturn = () -> { System.out.println("重写了test方法");};
> >     noParameterNoReturn.test();
> > 
> > 代码执行结果如下：
> > 
> > ![23e6dc1163a64724b6387f3f82d6556b.png][]

#### 2、无返回值一个参数（OneParameterNoReturn） ####

> 代码如下：
> 
>     //无返回值一个参数
>     @FunctionalInterface
>     interface OneParameterNoReturn {
>         void test(int a);
>     }
>     
>     public static void main(String[] args) {
>             //不使用lambda表达式
>             OneParameterNoReturn oneParameterNoReturn1 = new OneParameterNoReturn() {
>                 @Override
>                 public void test(int a) {
>                     System.out.println("重写了带有一个参数的test方法，参数为：" + a);
>                 }
>             };
>             oneParameterNoReturn1.test(10);
>             System.out.println("===================");
>           //使用lambda表达式
>             OneParameterNoReturn oneParameterNoReturn2 = (int a) -> { System.out.println("重写了带有一个参数的test方法，参数为：" + a);};
>             oneParameterNoReturn2.test(20);
>         }
> 
> 代码执行结果如下：
> 
> ![590e8bdd6595432c8adfafe957b41ab6.png][]

#### 3、无返回值多个参数（MoreParameterNoReturn） ####

> 代码如下：
> 
> >     //无返回值多个参数
> >     @FunctionalInterface
> >     interface MoreParameterNoReturn {
> >         void test(int a,int b);
> >     }
> >     
> >     public static void main(String[] args) {
> >             //不使用lambda表达式
> >             MoreParameterNoReturn moreParameterNoReturn1 = new MoreParameterNoReturn() {
> >                 @Override
> >                 public void test(int a, int b) {
> >                     System.out.println("重写了带有2个参数的test方法，参数：" + a + " " + b);
> >                 }
> >             };
> >             moreParameterNoReturn1.test(10,20);
> >             //使用lambda表达式
> >             MoreParameterNoReturn moreParameterNoReturn2 = (int a, int b) -> {System.out.println("重写了带有2个参数的test方法，参数：" + a + " " + b);};
> >             moreParameterNoReturn2.test(30,40);
> >         }
> > 
> > 代码执行结果如下：
> > 
> > ![004202ddf09140ebbabec98044c146e6.png][]

#### 4、有返回值无参数（NoParameterReturn） ####

代码如下：

>     //有返回值无参数
>     @FunctionalInterface
>     interface NoParameterReturn {
>         int test();
>     }
>     
>     public static void main(String[] args) {
>             //不使用lambda表达式
>             NoParameterReturn noParameterReturn1 = new NoParameterReturn() {
>                 @Override
>                 public int test() {
>                     System.out.println("重写了不带参数的test方法，有返回值");
>                     return 10;
>                 }
>             };
>             System.out.println(noParameterReturn1.test());
>             System.out.println("======================");
>             //使用lambda表达式
>             NoParameterReturn noParameterReturn = () -> {System.out.println("重写了不带参数的test方法，有返回值");return 20;};
>             System.out.println(noParameterReturn.test());
>         }
> 
> 代码结果如下：
> 
> ![3063e75b676c4fd28ae5956f86df22b9.png][]

#### 5、有返回值一个参数（OneParameterReturn） ####

代码如下：

>     //有返回值一个参数
>     @FunctionalInterface
>     interface OneParameterReturn {
>         int test(int a);
>     }
>     
>     public static void main(String[] args) {
>             //不使用lambda表达式
>             OneParameterReturn oneParameterReturn1 = new OneParameterReturn() {
>                 @Override
>                 public int test(int a) {
>                     System.out.println("重写了带有一个参数的test方法，参数：" + a);
>                     return a;
>                 }
>             };
>             System.out.println(oneParameterReturn1.test(10));
>             //使用lambda表达式
>             OneParameterReturn oneParameterReturn2 = (int a) -> {System.out.println("重写了带有一个参数的test方法，参数：" + a);return a;};
>             System.out.println(oneParameterReturn2.test(20));
>         }
> 
> 代码结果如下：
> 
> ![9eb36f33becd4450ad968c91527d64d6.png][]

#### 6、有返回值多参数（MoreParameterReturn ） ####

代码如下：

>     //有返回值多参数
>     @FunctionalInterface
>     interface MoreParameterReturn {
>         int test(int a,int b);
>     }
>     
>     public static void main(String[] args) {
>             MoreParameterReturn moreParameterReturn1 = new MoreParameterReturn() {
>                 @Override
>                 public int test(int a, int b) {
>                     System.out.println("重写了带有一个参数的test方法，参数：" + a + " " + b);
>                     return a + b;
>                 }
>             };
>             System.out.println(moreParameterReturn1.test(10, 10));
>     
>             MoreParameterReturn moreParameterReturn2 = (int a, int b) -> {System.out.println("重写了带有一个参数的test方法，参数：" + a + " " + b);return a + b;};
>             System.out.println(moreParameterReturn2.test(20, 20));
>         }
> 
> 代码结果如下：
> 
> ![c966991a5ea54632a516d3aee9bb3949.png][]

--------------------

## 三、变量捕获 ##

### （1）、匿名内部类的简单使用 ###

>     class TestDemo {
>         public void func(){
>             System.out.println("func()");
>         }
>     }
>     public class Test2 {
>         public static void main(String[] args) {
>             //匿名内部类的简单使用
>             TestDemo testDemo = new TestDemo() {
>                 public void func() {
>                     System.out.println("我是内部类，且重写了func这个方法！");
>                 }
>             };
>             testDemo.func();
>         }
>     }
> 
> 代码结果如下：
> 
> ![1eebca588db947a8aaddc37e77a923d6.png][]

### （2）、匿名内部类变量的捕获 ###

>     class TestDemo {
>         public void func(){
>             System.out.println("func()");
>         }
>     }
>     
>     public static void main(String[] args) {
>             int a = 100;
>             //匿名内部类变量的捕获
>             TestDemo testDemo = new TestDemo() {
>                 public void func() {
>                     //a = 99;err
>                     System.out.println("我是内部类，且重写了func这个方法！");
>                     System.out.println("捕获了a：" + a);
>                 }
>             };
>             testDemo.func();
>         }
> 
> 代码结果如下：
> 
> ![5368f4d2d4624313888cc3223dc6a916.png][]

### （3）、Lambda变量的捕获 ###

>     @FunctionalInterface
>     interface NoParameterNoReturn1 {
>         void test();
>     }
>     
>     public static void main(String[] args) {
>             int a = 100;
>             NoParameterNoReturn noParameterNoReturn = () -> {
>                 //a = 99;err
>                 System.out.println("捕获变量："+a);};
>             noParameterNoReturn.test();
>         }
> 
> 代码结果如下：
> 
> ![8175226781304ce88f280da395bababb.png][]

--------------------

## 四、lambda在集合中的使用（map和set） ##

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

> ### （1）、Collection接口 ###
> 
> forEach() 方法演示：  
> 该方法在接口 Iterable 当中，原型如下：
> 
> ![5881aa592db447cd9be5299f4d1a6241.png][]
> 
> 该方法表示：对容器中的每个元素执行action指定的动作  
> 
> 
> forEach() 的使用,代码如下：
> 
>     public static void main(String[] args) {
>             //不使用lambda表达式
>             ArrayList<String> list1 = new ArrayList<>();
>             list1.add("hello");
>             list1.add("word");
>             list1.add("bit");
>             list1.add("lambda");
>             list1.forEach(new Consumer<String>() {
>                 @Override
>                 public void accept(String s) {
>                     System.out.print(s + " ");
>                 }
>             });
>             System.out.println();
>             System.out.println("=============");
>             //使用lambda表达式
>             ArrayList<String> list2 = new ArrayList<>();
>             list2.add("hello");
>             list2.add("word");
>             list2.add("bit");
>             list2.add("lambda");
>     
>             list2.forEach((String x) -> {System.out.print(x + " ");});
>         }
> 
> 代码结果如下：
> 
> ![03a0c37bc7b941e2994446b3f766a9d0.png][]

> ### （2）、List接口 ###
> 
>   
> sort()方法的演示：  
> sort方法源码：该方法根据c指定的比较规则对容器元素进行排序。
> 
> ![61a37abd3d8a4d8eaa85071c9222fe27.png][]
> 
> sort() 的使用：
> 
>     public static void main(String[] args) {
>             //不使用lambda表达式
>             ArrayList<String> list1 = new ArrayList<>();
>             list1.add("hello");
>             list1.add("word");
>             list1.add("bit");
>             list1.add("lambda");
>             list1.sort(new Comparator<String>() {
>                 @Override
>                 public int compare(String o1, String o2) {
>                     return o1.length() - o2.length();
>                 }
>             });
>             System.out.println(list1);
>             System.out.println("===================");
>             //使用lambda表达式
>             ArrayList<String> list2 = new ArrayList<>();
>             list2.add("hello");
>             list2.add("word");
>             list2.add("bit");
>             list2.add("lambda");
>             list2.sort((String o1, String o2) -> {return o1.length() - o2.length();});
>             System.out.println(list2);
>         }
> 
> 代码结果如下：
> 
> ![c59c605bf68a4f8eb92eb14ccfd3b937.png][]

> ### （2）、map接口 ###
> 
> HashMap 的 forEach()  
> 该方法原型如下：  
> ![5ab67e19e2a44a2b8ca9614ee0d1d211.png][]
> 
> ![64c7f14b771349dc9f1493355f4d5898.png][]
> 
> 作用是对Map中的每个映射执行action指定的操作。
> 
> forEach() 方法演示：
> 
>     public static void main(String[] args) {
>             //不使用lambda表达式
>             HashMap<Integer, String> map1 = new HashMap<>();
>             map1.put(1, "hello");
>             map1.put(2, "word");
>             map1.put(3, "bit");
>             map1.put(4, "lambda");
>             map1.forEach(new BiConsumer<Integer, String>() {
>                 @Override
>                 public void accept(Integer integer, String s) {
>                     System.out.print(integer + "=" + s + " ");
>                 }
>             });
>             System.out.println();
>             System.out.println("=============");
>             //使用lambda表达式
>             HashMap<Integer, String> map2 = new HashMap<>();
>             map2.put(1, "hello");
>             map2.put(2, "word");
>             map2.put(3, "bit");
>             map2.put(4, "lambda");
>             map2.forEach((Integer a, String b) -> {System.out.print(a + "=" + b + " ");});
>         }
> 
> 结果如下：
> 
> ![990628e87861451a98d9b65cbce2453d.png][]

--------------------

## 五、优缺点 ##

### 优点： ###

1、代码简洁，开发迅速

2、方便函数式编程

3、非常容易进行并行计算

4、java引入了lambda表达式，改善了集合操作

### 缺点： ###

1、代码可读性差

2、在非并行计算中，性能未必比传统的for性能高

3、不容易进行调试

##  ##

--------------------

## 都看到这了，给个免费的赞再走吧，谢谢谢谢谢！！！ ##

[3f62321eb1e94d2db1f71f5919f71e7b.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/20/b9ec84bcb7ea45c8a47c71dae27285d9.png
[5cbd900c1c4e49879a01beb0a47eb6f9.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/20/7c91b41edf6f4175bb7ae0c13028dee5.png
[23e6dc1163a64724b6387f3f82d6556b.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/20/e751ed2f23b34771a57cf5ec94766345.png
[590e8bdd6595432c8adfafe957b41ab6.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/20/2a6bec10491f4d26856a1c88dfa873e5.png
[004202ddf09140ebbabec98044c146e6.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/20/4da555b7bcb048debe77ac27cd873786.png
[3063e75b676c4fd28ae5956f86df22b9.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/20/188234603be74b659d5fc4bdd6af3d93.png
[9eb36f33becd4450ad968c91527d64d6.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/20/e122be1f992949948bd2d3bb4e34c686.png
[c966991a5ea54632a516d3aee9bb3949.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/20/aa5fe2e9f25245dc8b8633979e17a858.png
[1eebca588db947a8aaddc37e77a923d6.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/20/ca893fc1bcaf43378fa1ac90f8d7e32e.png
[5368f4d2d4624313888cc3223dc6a916.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/20/4bf0b3267cbb42c491286ce2a24ddd9b.png
[8175226781304ce88f280da395bababb.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/20/c78b72ea1b20466c9df5c4ab5baa5897.png
[0d42910f15464b30a2024fd4765d6ee1.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/20/cbf926442cb9460fbfcdccdf047465fa.png
[5881aa592db447cd9be5299f4d1a6241.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/20/83bd1b93bcf845b682dac7c46a591c09.png
[03a0c37bc7b941e2994446b3f766a9d0.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/20/d505bfdf21ed41f0a0fec8c994521cd8.png
[61a37abd3d8a4d8eaa85071c9222fe27.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/20/7bd1b814cf8f49cbbd239cbac6b085bc.png
[c59c605bf68a4f8eb92eb14ccfd3b937.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/20/40371800df2945b6bfb18039afa141cc.png
[5ab67e19e2a44a2b8ca9614ee0d1d211.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/20/23b5cdd0fefc408e95f9ad7a2ab854fd.png
[64c7f14b771349dc9f1493355f4d5898.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/20/74898027cb4548aebd18879c2a184c45.png
[990628e87861451a98d9b65cbce2453d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/20/d4d844a66ad84e0e9b5981a5bcffb7c1.png