Java8新特性探索之Lambda表达式

为什么引入Lambda表达式？

• Lambda 表达式产生函数，而不是类。 在 JVM（Java Virtual Machine，Java 虚拟机）上，一切都是一个类，因此在幕后执行各种操作使 lambda 看起来像函数 —— 但作为程序员，你可以高兴地假装它们“只是函数”。
• Lambda 语法尽可能少，使用 Lambda 表达式可以使代码变的更加简洁紧凑， 易于编写和使用。
• Lambda 表达式通常比匿名内部类产生更易读的代码。

如何使用Lambda表达式？

首先我们先了解下Lambda表达式的重要特征：

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

任何 Lambda 表达式的基本语法是：

1. 参数
2. 接着 ->，可视为“产出”。
3. -> 之后的内容都是方法体。
   • [1] 当只用一个参数，可以不需要括号 ()。 然而，这是一个特例。
   • [2] 正常情况使用括号 () 包裹参数。 为了保持一致性，也可以使用括号 () 包裹单个参数，虽然这种情况并不常见。
   • [3] 如果没有参数，则必须使用括号 () 表示空参数列表。
   • [4] 对于多个参数，将参数列表放在括号 () 中。
   • [5] 如果在 Lambda 表达式中确实需要多行，则必须将这些行放在花括号中。 在这种情况下，就需要使用 return。到目前为止，所有 Lambda 表达式方法体都是单行。 该表达式的结果自动成为 lambda 表达式的返回值，在此处使用 return 关键字是非法的。 这是 lambda 表达式简化相应语法的另一种方式。

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)

我们在 LambdaExpressions.java 中看到了一个 Lambda 表达式，但还有其他语法变体：

interface Description {
  String brief();
}

interface Body {
  String detailed(String head);
}

interface Multi {
  String twoArg(String head, Double d);
}

public class LambdaExpressions {

  static Body bod = h -> h + " No Parens!"; // [1]

  static Body bod2 = (h) -> h + " More details"; // [2]

  static Description desc = () -> "Short info"; // [3]

  static Multi mult = (h, n) -> h + n; // [4]

  static Description moreLines = () -> { // [5]
    System.out.println("moreLines()");
    return "from moreLines()";
  };

  public static void main(String[] args) {
    System.out.println(bod.detailed("Oh!"));
    System.out.println(bod2.detailed("Hi!"));
    System.out.println(desc.brief());
    System.out.println(mult.twoArg("Pi! ", 3.14159));
    System.out.println(moreLines.brief());
  }
}

输出结果：

Oh! No Parens!
Hi! More details
Short info
Pi! 3.14159
moreLines()
from moreLines()

lambda 表达式规约

1. Lambda 表达式的参数可以通过上下文推断，如果需要显示声明一个参数的类型，则必须为所有的参数声明类型。

   @FunctionalInterface
   public interface IFunctionMod {
     boolean (int n, int d);
   }
   
   IFunctionMod function = (n, d） -> (n % d) == 0          // 合理，n 和 d 的类型通过上下文推断
   IFunctionMod function = (int n, int d) -> (n % d) == 0   // 合理，指定 n 和 d 的类型
   IFunctionMod function = (int n, d) -> (n % d) == 0       // 不合理，须显示声明所有参数类型
   

2. Lambda 表达式中抛出的异常需要与目标函数式接口的抽象方法抛出的异常类型兼容。

   以下是合理的：

   @FunctionalInterface
   public interface IFunctionMod {
     boolean (int n, int d) throw Exception;
   }
   
   IFunctionMod function = (n, d) -> {
       if (d == 0) {
         // IOException是EXception 的子类，通过类型转换，IOException 可转换为 Exception
         throw new IOException("test");
       }
       return n % d == 0;
   };
   

   如果反一下，就不行：

   @FunctionalInterface
   public interface IFunctionMod {
     boolean (int n, int d) throw IOException;
   }
   
   IFunctionMod function = (n, d) -> {
       if (d == 0) {
         // 父类不能通过自动类型转换转为子类，lambda 表达式抛出的异常类型与抽象方法抛出的异常类型不兼容
         throw new Exception("test");
       }
       return n % d == 0;
   };
   

3. Lambda 表达式中参数类型需要与目标函数式接口中抽象方法的参数类型兼容。从接口与实现的角度，可以很容易理解抛出异常兼容 和 参数类型兼容 这2点。

变量作用域

lambda 表达式只能引用标记了 final 的外层局部变量，这就是说不能在 lambda 内部修改定义在域外的局部变量，否则会编译错误。

• 在 lambda 表达式中访问外层的局部变量：

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

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

  int num = 1;
  Converter<Integer, String> s = (param) -> System.out.println(String.valueOf(param + num));
  s.convert(2);
  num = 5;
  //报错信息：Local variable num defined in an enclosing scope must be final or effectively
   final
  

• 在 lambda 表达式当中不允许声明一个与局部变量同名的参数或者局部变量。

  String first = "";
  Comparator<String> comparator = (first, second) -> Integer.compare(first.length(), second.length());  //编译会出错
  

总结

1. Lambda表达式没有命名，用来像传递数据一样传递操作。
2. 函数接口指的是只有一个抽象方法的接口，被当做是lambda表达式的类型。