Lambda表达式

Lambda表达式

1. lambda 表达式定义

   • Lambda表达式是java 8引入的一种函数式编程的概念。它允许我们将函数作为参数传递给方法，或者在函数中返回另一个函数。
   • Lambda表达式可以省略参数的类型，编译器会根据上下文自动推断类型。
   • Lambda表达式可以替代匿名内部类的写法，使代码更加简洁易读。

2. lambda表达式基础语法

   • (参数列表) -> {表达式或代码块}

     (parameters) -> expression
     或
     (parameters) ->{ statements; }
     

3. lambda表达式的重要特征：

   • 可选类型声明：不需要声明参数类型，编译器可以统一识别参数值。
   • 可选的参数圆括号：一个参数无需定义圆括号，但多个参数需要定义圆括号。
   • 可选的大括号：如果主体包含了一个语句，就不需要使用大括号。
   • 可选的返回关键字：如果主体只有一个表达式返回值则编译器会自动返回值，大括号需要指定表达式返回了一个数值。

4. lambda表达式案例

   • 简单案例

     // 1. 不需要参数,返回值为 5  
     () -> 5  
       
     // 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表达式对一个整数列表进行遍历并打印出每个元素

       List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
       numbers.forEach((number) -> System.out.println(number));
       
       

       控制台输出

       1
       2
       3
       4
       5
       

     • 使用Lambda表达式对一个字符串列表进行排序(自然排序)

       List<String> names = Arrays.asList("Alice", "David", "Charlie", "Bob");
       Collections.sort(names, (name1, name2) -> name1.compareTo(name2));
       System.out.println(names);
       

       控制台输出

       Alice, Bob, Charlie, David
       

     • 使用Lambda表达式对一个整数列表进行筛选，只保留偶数

       List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
       List<Integer> evenNumbers = numbers.stream()
                          .filter((number) -> number % 2 == 0)
                          .collect(Collectors.toList());
       System.out.println(evenNumbers);
       

       控制台输出

       [2, 4]
       

   • 实例

     public class LambdaDemo02 {
         public static void main(String[] args) {
             LambdaDemo02 demo = new LambdaDemo02();
     
             //类型声明-->加
             MathOperation add = (int x, int y) -> x+y;
     
             //不用类型声明 --> 减
             MathOperation sub = (int x, int y) -> x-y;
     
             //大括号中的返回语句
             MathOperation mul = (int x, int y) -> {return x*y;};
     
             //没有大括号及返回语句
             MathOperation div =(int x,int y) -> x/y;
     
             //打印输出
             System.out.println("10 + 5 = " + demo.operate(10, 5, add));
             System.out.println("10 - 5 = " + demo.operate(10, 5, sub));
             System.out.println("10 x 5 = " + demo.operate(10, 5, mul));
             System.out.println("10 / 5 = " + demo.operate(10, 5, div));
     
             //不有括号
             GreetingService greetingService1 = message ->
                     System.out.println("Hello " + message);
             //用括号
             GreetingService greetingService2 = (message) ->
                     System.out.println("Hello " + message);
     
             greetingService1.sayMessage("Runoob");
             greetingService2.sayMessage("Google");
         }
         //定义了一个函数式接口MathOperation，包含一个抽象方法operation，用于执行数学操作
         interface MathOperation{
             int operation(int x, int y);
         }
         //定义了一个函数式接口GreetingService，包含一个抽象方法sayMessage，用于打印问候信息。
         interface GreetingService{
             void sayMessage(String message);
         }
     
         private int operate(int x, int y,MathOperation mathOperation){
             return mathOperation.operation(x,y);
         }
     }
     

     控制台结果

     10 + 5 = 15
     10 - 5 = 5
     10 x 5 = 50
     10 / 5 = 2
     Hello Runoob
     Hello Google
     

     • Lambda 表达式主要用来定义行内执行的方法类型接口（例如，一个简单方法接口）。在上面例子中，我们使用各种类型的 Lambda 表达式来定义 MathOperation 接口的方法，然后我们定义了 operation 的执行。
     • Lambda 表达式免去了使用匿名方法的麻烦，并且给予 Java 简单但是强大的函数化的编程能力。

5. 变量作用域

   public class LambdaDemo03 {
   
       final static String salutation = "Hello !";
       public static void main(String[] args) {
           GreetingService greetingService = messaging ->
                   System.out.println(salutation + messaging);
           greetingService.sayMessage("Java");
       }
   
       interface GreetingService {
           void sayMessage(String message);
       }
   }
   

   控制台结果

   Hello !Java
   

   我们也可以直接在 lambda 表达式中访问外层的局部变量：

   public class LambdaDemo04 {
       public static void main(String[] args) {
           final int num = 1;
           Converter<Integer,String> s =(param) ->
                   System.out.println(String.valueOf(param + num));  //输出结果为3
           s.convert(2);
       }
   
       public interface Converter<T1, T2> {
           void convert(int i);
       }
   }
   

   • lambda 表达式的局部变量可以不用声明为 final，但是必须不可被后面的代码修改（即隐性的具有 final 的语义）