首页 > 编程笔记 > Java笔记

Java Lambda表达式的3种简写方式

使用 Lambda 表达式是为了简化程序代码，Lambda 表达式本身也提供了多种简化形式，这些简化形式虽然简化了代码，但客观上使得代码可读性变差。本节介绍 Lambda 表达式的几种简化形式。

省略参数类型

Lambda 表达式可以根据上下文环境推断出参数类型。calculate 方法中 Lambda 表达式能推断出参数 a 和 b 是 int 类型，简化形式如下： 
  1. public static Calculable calculate(char opr) {
  2.     Calculable result;
  3.     if (opr == '+') {
  4.         // Lambda表达式实现Calculable接口
  5.         result = (a, b) -> {
  6.             return a + b;
  7.         };
  8.     } else {
  9.         // Lambda表达式实现Calculable接口
  10.         result = (a, b) -> {
  11.             return a - b;
  12.         };
  13.     }
  14.     return result;
  15. }
代码第 5 行和第 10 行是《Java Lambda表达式》一节示例中result = (int a, int b) -> {代码的简化写法，其中 a 和 b 是参数。

省略参数小括号

如果 Lambda 表达式中的参数只有一个，可以省略参数小括号。修改 Calculable 接口中的 calculateInt 方法，代码如下。 
  1. // 可计算接口
  2. @FunctionalInterface
  3. public interface Calculable {
  4.     // 计算一个int数值
  5.     int calculateInt(int a);
  6. }
其中 calculateInt 方法只有一个 int 类型参数，返回值也是 int 类型。调用 calculateInt 方法代码如下： 
  1. public static void main(String[] args) {
  2.     int n1 = 10;
  3.  
  4.     // 实现二次方计算Calculable对象
  5.     Calculable f1 = calculate(2);
  6.     // 实现三次方计算Calculable对象
  7.     Calculable f2 = calculate(3);
  8.     // 调用calculateInt方法进行加法计算
  9.     System.out.printf("%d二次方 = %d \n", n1, f1.calculateInt(n1));
  10.     // 调用calculateInt方法进行减法计算
  11.     System.out.printf("%d三次方 = %d \n", n1, f2.calculateInt(n1));
  12. }
  13.  
  14. /**
  15. * 通过幂计算
  16. *
  17. * @param power 幂
  18. * @return 实现Calculable接口对象
  19. */
  20. public static Calculable calculate(int power) {
  21.     Calculable result;
  22.     if (power == 2) {
  23.         // Lambda表达式实现Calculable接口
  24.         // 标准形式
  25.         result = (int a) -> {
  26.             return a * a;
  27.         };
  28.     } else {
  29.         // Lambda表达式实现Calculable接口
  30.         // 省略形式
  31.         result = a -> {
  32.             return a * a * a;
  33.         };
  34.     }
  35.     return result;
  36. }
上述代码第 25 行和第 31 行都是实现 Calculable 接口的 Lambda 表达式。代码第 25 行是标准形式没有任何的简化。代码第 31 行省略了参数类型和小括号。

输出结果为：

10二次方 = 100
10三次方 = 1000 

省略return和大括号

如果 Lambda 表达式体中只有一条语句，那么可以省略 return 和大括号，代码如下： 
  1. public static Calculable calculate(int power) {
  2.     Calculable result;
  3.     if (power == 2) {
  4.         // Lambda表达式实现Calculable接口
  5.         // 标准形式
  6.         result = (int a) -> {
  7.             return a * a;
  8.         };
  9.     } else {
  10.         // Lambda表达式实现Calculable接口
  11.         // 省略形式
  12.         result = a -> a * a * a;
  13.     }
  14.     return result;
  15. }
上述代码第 12 行是省略了 return 和大括号，这是最简化形式的 Lambda 表达式了，代码太简洁了，但是对于初学者而言很难理解这个表达式。

所有教程

优秀文章