Java 8 Lambda表达式的使用

时间：2021-07-21 22:10:27
  • lambda表达式允许你通过表达式来代替功能接口。lambda表达式就和方法一样,它提供了一个正常的参数列表和一个使用这些参数的主体(body,可以是一个表达式或一个代码块)。
  • Lambda表达式还增强了集合库。 Java SE 8添加了2个对集合数据进行批量操作的包: java.util.function 包以及java.util.stream 包。

　　实现一个接口（功能接口）中的唯一方法（老办法）：

　　  1、接口中的方法无返回值：

 1 package JDK8Test;
 2 interface RunTask
 3 {
 4     void run();
 5 }
 6 public class Main 
 7 {
 8 
 9     public static void main(String[] args) 
10     {
11         RunTask r=new RunTask() 
12         {
13             public void run()
14             {
15                 System.out.println("我是线程要执行的任务");
16             }
17         };
18         r.run();
19     }
20 }

　　首先要创建一个类，这个类实现了这个功能接口，然后在类中对方法进行实现。然后实例化一个这个类的对象r，由对象调用run()方法。（此处使用匿名内部类）

　　Lambda表达式形式：

　　Java提供了一个新的操作符"->" 这个操作符之前有一个括号,括号里面就是接口中的那个唯一的方法的参数列表,操作符后面就是我们以前实现接口中的方法中的语句,具体就以上面的代码为参照。

　　使用前提：

　　①接口中就只有一个抽象方法,也就是我们刚刚定义的接口,里面就只能有一个抽象方法。

　　2、接口中的方法有返回值：

 1 package JDK8Test;
 2 interface RunTask
 3 {
 4     String run();
 5 }
 6 public class Main 
 7 {
 8     public static void main(String[] args) 
 9     {
10         RunTask r=()->System.currentTimeMillis()%2==0?"当前的毫秒值能被2整除":"不能被2整除";
11         String value=r.run();
12         System.out.println(value);
13     }
14 }

　　也就是说，如果返回值是一个String类型的，则”->”后面跟的就必须是一个字符串。调用run()方法时，返回的就是这个字符串。

　　3、接口中的方法有参数：

 1 package JDK8Test;
 2 interface RunTask
 3 {
 4     String run(String name);
 5 }
 6 public class Main 
 7 {
 8     public static void main(String[] args) 
 9     {
10         RunTask r=(who)->who+"在调用我";
11         String value=r.run("Peter");
12         System.out.println(value);
13     }
14 }        //输出    Peter在调用我

　　操作符"->“前面的括号中写了一个参数的变量名,然后你可以看到这个变量在后面的语句中我们就可以使用了！方法中的参数接收一个String类型的，所以who这个变量就必须是字符串类型的，所以who前面可以加一个String。

　　4、实现比较器接口：

 1 package JDK8Test;
 2 import java.util.*;
 3 
 4 public class Main 
 5 {
 6     public static void main(String[] args) 
 7     {
 8         ArrayList<Integer> list=new ArrayList<Integer>();
 9         list.add(5);
10         list.add(8);
11         list.add(6);
12         System.out.println(list);
13         Collections.sort(list, (Integer a,Integer b)->a-b);
14         System.out.println(list);
15     }
16 }        
17 //[5, 8, 6]
18 //[5, 6, 8]

　　可以看得到”->" 操作符前面是接口中的方法的参数列表,后面是实现接口的方法中的表达式。

　　5、实现Consumer接口，遍历集合（老方法）：

 1 package JDK8Test;
 2 import java.util.ArrayList;
 3 import java.util.function.Consumer;
 4 
 5 public class Main 
 6 {
 7     public static void main(String[] args) 
 8     {
 9         ArrayList<Integer> list=new ArrayList<Integer>();
10         list.add(5);
11         list.add(8);
12         list.add(6);
13         Two two=new Two();
14         list.forEach(two);
15     }
16 }    
17 class Two implements Consumer<Integer>
18 {
19     public void accept(Integer t)
20     {
21         System.out.println("遍历中"+t);
22     }
23 }
24 /*输出：
25  遍历中5
26 遍历中8
27 遍历中6 
28 */

　　Lambda表达式方法：

　　

 1 package JDK8Test;
 2 import java.util.ArrayList;
 3 import java.util.function.Consumer;
 4 
 5 public class Main 
 6 {
 7     public static void main(String[] args) 
 8     {
 9         ArrayList<Integer> list=new ArrayList<Integer>();
10         list.add(5);
11         list.add(8);
12         list.add(6);
13         Consumer<Integer> r=(Integer t)->System.out.println("遍历中"+t);
14         list.forEach(r);
15     }
16 }    
17 /*输出：
18 遍历中5
19 遍历中8
20 遍历中6 
21 */

　　5、”->”后面有{}包裹：

　　

 1 package JDK8Test;
 2 import java.util.ArrayList;
 3 import java.util.Collections;
 4 import java.util.function.Consumer;
 5 
 6 public class Main 
 7 {
 8     public static void main(String[] args) 
 9     {
10         ArrayList<Integer> list=new ArrayList<Integer>();
11         list.add(5);
12         list.add(8);
13         list.add(6);
14         System.out.println(list);
15         Collections.sort(list, (Integer a,Integer b)->{return a-b;});
16         System.out.println(list);
17     }
18 }    
19 /*输出：
20 [5, 8, 6]
21 [5, 6, 8]
22 */

　　没有{}和有{}的区别是：
　　①没有{}包裹的不用写return 关键字,有{}包裹的,如果有返回值,必须使用return 关键字返回数据
　　②没有{}包裹的只能写一个语句，而有{}包裹的可以写任意多条语句。

标签：

相关文章