Java Lambda表达式笔记

Lambda 表达式

概述

使用 Lambda 表达式的前提是必须有相应的函数接口。函数接口是指内部仅有一个抽象方法的接口。

Lambda 表达式语法形式：

(参数列表)->{
	//表达式语句
}

常见用法

无参函数简写

如果需要新建一个线程，匿名内部类写法:

new Thread(new Runnable(){// 接口名
	@Override
	public void run(){// 方法名
		System.out.println("Thread run()");
	}
}).start();

Lambda 表达式写法：

//单行语句
new Thread(() -> System.out.println("Thread run()")).start();

//多行语句使用{}
new Thread(() -> {
    System.out.println("Hello")
    System.out.println("Thread run()")
}).start();

带参数函数的简写

单参函数简写

单参函数匿名内部类可以简写为：

([类名] 变量名) -> {
    执行语句;
}

//类名可以省略，括号也可以省略
变量名 -> {
    执行语句;
}

//只有一条语句时，可以去掉{}
变量名 -> 表达式

定义一个 Calculable 接口：

public interface Calculable {
    int calculate(int a);
}

匿名内部类实现：

public class LambdaDemo02 {
    public static Calculable calc(){
        Calculable result = new Calculable() {
            @Override
            public int calculate(int a) {
                return a*a;
            }
        };

        return result;
    }

    public static void main(String[] args) {
        int n = 10;
        System.out.println(n+"^2 = " + calc().calculate(n));
    }
}

// 运行结果
// 10^2 = 100

Lambda 表达式实现：

public class LambdaDemo02 {
    public static Calculable calc(){
        return a -> a*a;
    }

    public static void main(String[] args) {
        int n = 10;
        System.out.println(n+"^2 = " + calc().calculate(n));
    }
}

// 运行结果
// 10^2 = 100

多参函数简写

定义一个 Calculable 接口，提供 caculate() 方法：

public interface Calculable {
    int calculate(int a, int b);
}

使用匿名内部类实现：

public static Calculable calculate(){
    Calculable result = new Calculable() {
        @Override
        public int calculateInt(int a, int b) {
            return a+b;
        }
    };
    return result;
}

Lambda 表达式写法：

public static Calculable calculate(){
    Calculable result = (a, b) -> a+b;
    return result;
}

Lambda 表达式的使用

作为参数使用 Lambda 表达式

将Lambda 表达式作为参数传递给方法，需要参数的类型声明为函数式接口类型，示例代码：

public class LambdaDemo01 {

    public static void main(String[] args) {
        int n1 = 10;
        int n2 = 5;

        //打印加法计算
        display((a, b) -> a+b,n1,n2);
        //打印减法计算
        display((a, b) -> a-b,n1,n2);
    }

    public static void display(Calculable calc, int a, int b){
        System.out.println(calc.calculateInt(a,b));
    }
}

display() 的参数 calc 类型为 Calculable，可以接收 Calculable 接口的对象，也可以接受 Lambda 表达式。

访问变量

Lambda 表达式可以访问所在地的外层作用域定义的变量，包括成员变量和局部变量。

• 访问成员变量

  成员变量包括实例成员变量和静态成员变量。Lambda表达式可以读取成员变量，也可以修改成员变量。

  public class LambdaDemo03 {
      private int value = 10;
      private static int staticValue = 5;
  
      public static Calculable add(){
          Calculable result = (a, b) -> {
              staticValue++;
  //            this.value++;	静态方法不能访问实例成员变量
              int c = a + b + staticValue;
              return c;
          };
          return result;
      }
  
      public Calculable sub(){
          Calculable result = (a, b) -> {
              staticValue++;
              this.value++;
              return a-b-staticValue-this.value;
          };
          return result;
      }
  
      public static void main(String[] args) {
          System.out.println("调用静态方法add(): "+add().calculateInt(10,20));
          System.out.println("staticValue = "+ staticValue);
          System.out.println("调用实例方法: "+new LambdaDemo03().sub().calculateInt(20,10));
      }
  }
  

  运行结果：

  调用静态方法add(): 36
  staticValue = 6
  调用实例方法sub(): -8
  

  add 方法是静态方法，静态方法中不能访问实例成员变量，所以代码第 8 行的 Lambda 表达式中不能访问实例成员变量，也不能访问实例成员方法。

  sub 方法是实例方法，实例方法中能够访问静态成员变量和实例成员变量。

• 访问局部变量

  访问局部变量时，变量必须是 final 类型。不管这个变量是否显式地使用 final 修饰，它都不能在 Lambda 表达式中修改变量.

  public class LambdaDemo04 {
      private int value = 10;
      private static int staticValue = 5;
  
      public static Calculable add(){
          int localValue = 10;
          Calculable result = (a, b) -> {
              staticValue++;
  //            localValue++;
              //报错 localValue必须不可修改
              return a + b + localValue;
          };
          return result;
      }
  
      public Calculable sub(){
          final int localValue = 5;
          Calculable result = (a, b) -> {
              int c = a - b - localValue;
              return c;
          };
          return result;
      }
  
      public static void main(String[] args) {
          System.out.println("调用静态方法add(): "+add().calculateInt(10,20));
          System.out.println("调用实例方法sub(): "+new LambdaDemo04().sub().calculateInt(30,10));
      }
  }
  

Lambda 表达式对于局部变量只可读，但是对静态变量和成员变量可以读写。

方法引用

方法引用语法：

ObjectRef::methodName

ObjectRef 是类名或者实例名，methodName 是相应的方法名。

被引用方法的参数列表和返回值类型，必须与函数式接口方法参数列表和方法返回值类型一致。

引用静态方法和实例方法

示例代码如下：

public class LambdaDemo05 {
    // 静态方法，进行加法运算
    // 参数列表要与函数式接口方法calculateInt(int a, int b)兼容
    public static int add(int a, int b){
        return a+b;
    }
    // 实例方法，进行减法运算
    // 参数列表要与函数式接口方法calculateInt(int a, int b)兼容
    public int sub(int a, int b){
        return a-b;
    }

    public static void display(Calculable calc, int a, int b){
        System.out.println(calc.calculateInt(a, b));
    }

    public static void main(String[] args) {
        int a = 20;
        int b = 10;

        display(LambdaDemo05::add,a,b);
        display(new LambdaDemo05()::sub,a,b);
    }
}

参数 calc 是 Calculable 类型，它可以接受三种对象：Calculable 实现对象、Lambda 表达式和方法引用。

LambdaDemo05::add 和 new LambdaDemo05::sub 并没有调用方法，只是方法引用传递给 display() 在 display() 中才调用方法。

引用构造方法

构造方法的参数列表和接口里函数的参数列表一致时，可以引用构造方法：ClassName::new。

Function 接口，它是一个函数接口，部分代码如下：

@FunctionalInterface
public interface Function<T, R> {
    /**
     * Applies this function to the given argument.
     *
     * @param t the function argument
     * @return the function result
     */
    R apply(T t);
		// 省略部分代码
}

匿名内部类创建一个 ArrayList：

Function<Integer, ArrayList> function = new Function<Integer, ArrayList>() {
        @Override
        public ArrayList apply(Integer integer) {
            return new ArrayList(integer);
        }
};
List list = function.apply(10);

Lambda 表达式创建 ArrayList：

Function<Integer,ArrayList> function1 = n -> new ArrayList(n);

//引用构造方法
Function<Integer,ArrayList> function2 = ArrayList::new;

参考

Java 8：一文掌握 Lambda 表达式