有关Lambda表达式

前言

• java8推出的语法糖（也可称为闭包），简化了内部类（匿名类）的代码表达，提升了代码的可读性和简洁性
• 允许把函数作为一个参数传入另一个函数（方法作为参数传入方法）

语法

• (parameters) -> (starements;)

  • 如：

    (parameters)->{
        statemnets1;
        statements2;
        return statements1;
    }
    

• 简化版：(paramaters) -> expersion

  • 这种简化形式相比上一种，因为表达式只包含了一条语句，所以省略了大括号、return和分号;

    Integer[] integers = new Integer[]{7, 4, 6, 1, 9, 5};
    List<Integer> list = new ArrayList<>(Arrays.asList(integers));//将数组转换成集合，便于进行lambda操
    list.forEach(x->System.out.println(x))；//打印出list集合的每一项
    list.sort((e1,e2)->el.compareTo(e2));//升序排序
    //注意：Lambda表达式只用于实现函数接口
    

  • 参数如果只有一个的话，可以省略小括号：parameter -> expersion

  特征：

  1. 类型声明：无需声明参数的类型，jvm会自动识别
  2. 参数圆括号：零个或一个参数不需要写圆括号，但是多个参数需要
  3. 代码块的大括号：如果只有一个表达式，无需写大括号
  4. 返回：如果只有一个表达式，Jvm会自动返回，不需要写return关键字，但是在有大括号的时候，必须写return statementsXX，如果没有返回任何内容，则返回void

案例

需求：实现两个数字的增减乘除

package model.four_week;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class LambdaDemo {
    public static void main(String[] args) {
//        实现两数相加的lambda表达式
        Mathoperation add = (a, b) -> a + b;
//        实现两数相减的lambda表达式
        Mathoperation differ = (a, b) -> a - b;
//        实现两数相乘的lambda表达式
        Mathoperation multiple = (a, b) -> a * b;
//        实现两数相除的lambda表达式
        Mathoperation division = (a, b) -> a / b;
//        实例化LambdaDemo，使用operate方法
        LambdaDemo lambdaDemo = new LambdaDemo();
//        输出结果
        System.out.println("4+5=" + lambdaDemo.opreate(4, 5, add));
        System.out.println("11-4=" + lambdaDemo.opreate(11, 4, differ));
        System.out.println("2*9=" + lambdaDemo.opreate(2, 9, multiple));
        System.out.println("15/3=" + lambdaDemo.opreate(15, 3, division));
    }

    interface Mathoperation {
        int operation(int a, int b);
    }

    private int opreate(int a, int b, Mathoperation mathoperation) {
        return mathoperation.operation(a, b);
    }
}

输出结果

4+5=9
11-4=7
2*9=18
15/3=5

关于引用

Integer[] integers = new Integer[]{7, 4, 6, 1, 9, 5};
List<Integer> list = new ArrayList<>(Arrays.asList(integers));
list.sort((e1,e2)->el.compareTo(e2));

public class Demo{
    private int a;
    private int b;
    Demo(){}
    Demo(int a,int b){
        this.a=a;
        this.b=b;
    }
    public static boolean compare(int a,int b){
    return a.compareTo(b);
 }
    public boolean compare2(int a,int b){
    return a.compareTo(b);
 }
}

1. 引用静态方法：将一个静态方法的引用当作参数传入另一个方法中

list.sort((e1,e2)->Demo.compare(e1,e2));

还可以改写为

list.sort(Demo::compare);

2. 引用对象方法：将一个对象方法的引用当作参数传入另一个方法中

   Demo demo = new Demo();
   

   list.sort((e1,e2)->demo.compare2(e1,e2))
   

   同样可以改写为

   list.sort(demo::compare2);
   

3. 引用构造器：将一个方法的引用当作参数传入构造器中

list.sort(Demo::new)

变量作用域

• lambda表达式只能引用final标记的外层局部变量
• lambda表达式中不允许声明一个与局部变量同名的参数或者局部变量，否则编译出错