java8之lambda表达式

目的：行为参数化

Lambda表达式是简洁地表示可传递的匿名函数的一种方式:它没有名称，但它有参数列表、函数主体、返回类型，可能还有一个可以抛出的异常列表。

Lambda的基本语法是(parameters) -> expression 或 (parameters) -> { statements; }。其中， (parameters) -> expression 的表达式中隐含了return，如 () -> 42； (parameters) -> { statements; } 的花括号内是语句。

举例：

() -> 42  //参数为空，返回一个int
(List<String> list) -> list.isEmpty() //参数为list，返回一个boolean
(int x, int y) -> x*y //参数为两个int，返回一个int
(String s) -> System.out.println(s); //参数为一个String,不返回结果
(String s) -> {System.out.println(s);} //参数为一个String，打印字符串

哪些地方使用哪些lambda

函数式接口是只定义一个抽象方法的接口，即使拥有多个默认方法。FunctionalInterface 标注一个函数式接口，会加入编译检查。函数式接口中默认方法的目的是：改变已发布的接口而不破坏已有的实现。

在接受函数式接口为参数的地方，都可以使用lambda表达式。

例子：

public void execute(Runnable r){
  r.run(); 
}
execute(() -> {}); //使用lambda，Runnable是参数为空，没有返回值的函数式接口，即() -> void 
//fetch返回一个函数式接口，() -> String
public Callable<String> fetch() { 
  return () -> "Tricky example ;-)";
}

为什么只有在函数式接口的地方使用呢？lambda表达式没有函数名，只有参数列表，函数主体和返回值，如果接口有多个方法，就不能直接匹配到正确的方法上了，所以，只有一个抽象方法的函数式接口可以满足。

Predicate

java.util.function.Predicate<T>是一个含有多个默认方法的函数式接口，抽象方法为：(T t) -> bool。看下代码，你就懂了~

FunctionalInterface
public interface Predicate<T> {
  //接口方法，入参为泛型T，返回bool。即：(T t) -> bool
  boolean test(T t);
  //默认方法，and操作
  default Predicate<T> and(Predicate<? super T> other) {
    Objects.requireNonNull(other);
    return (t) -> test(t) && other.test(t);
  }
  //默认方法，取反操作
  default Predicate<T> negate() {
    return (t) -> !test(t);
  }
  //默认方法，or 操作
  default Predicate<T> or(Predicate<? super T> other) {
    Objects.requireNonNull(other);
    return (t) -> test(t) || other.test(t);
  }
  //默认方法，判断是否相等
  static <T> Predicate<T> isEqual(Object targetRef) {
    return (null == targetRef)
        ? Objects::isNull
        : object -> targetRef.equals(object);
  }

使用

Predicate<String> nonEmptyStringPredicate = (String s) -> !s.isEmpty();

Consumer

java.util.function.Consumer<T> 是一个只含有一个默认方法的函数式接口，抽象方法为：(T t) ->void。看下代码，你就懂了~

@FunctionalInterface
public interface Consumer<T> {
  //接口方法，入参为泛型T，返回void。即：(T t) -> void
  void accept(T t);
  //默认方法，可以执行级联操作
  default Consumer<T> andThen(Consumer<? super T> after) {
    Objects.requireNonNull(after);
    return (T t) -> { accept(t); after.accept(t); };
  }