Lambda是Java8中的新特性，用来在Java中实现函数式编程。

Lambda

0.什么是Lambda

Lambda表达式是一段可以传递的代码。
将面向对象中传递数据编程传递行为。
如果原来是这样编写一个线程：

Runnable r = new Runnable() {
    @Override
    public void run() {
        System.out.println("do something");
    }
}

Runnable接口中只有一个run()方法，当把Runnable对象给Thread对象作为构造参数时创建一个线程，运行后输出"do something"，上面的例子用匿名内部类实现了这个方法。
这是一个“代码即数据”的例子，在run方法中是线程要执行的一个任务，但是上面的代码中任务内容已经被规定死了。当我们有多个任务的时候，需要多次重复编写上述代码。

用Lambda表达式实现起来是这样的，简便很多：

Runnable r = () -> System.out.println("do something");

1. 基本语法

Lambda表达式基本样式为：

expression = (variable) -> action

• variable：变量，也可以是给占位符
• action：实现的代码逻辑部分，可以是一行代码也可以是一个代码片段。
  Lambda表达式特征有：
• 可选类型说明：不需要声明类型，编译器统一识别参数值
• 可选参数小括号：一个参数无需定义小括号，但是多个参数还是需要
• 可选的大括号如果主体只包含了一个语句，就不需要使用大括号
• 可选的返回关键字（return）：如果主体只有一个表达式返回值则编译器会自动返回该值，大括号则需要指定返回值。

2.Lambda表达式实例

package com.junzerg.test;

public class LambdaTest {
    public static void main(String args[]) {
        LambdaTest tester = new LambdaTest();
        
        // 类型声明
        MathOperation addition = (int a, int b) -> a + b;
        // 不用类型声明
        MathOperation subtraction = (a, b) -> a - b;
        // 大括号中的返回语句
        MathOperation multiplication = (int a, int b) -> {return a * b;};
        // 没有大括号以及返回语句
        MathOperation division = (int a, int b) -> a / b;
        
         System.out.println("10 + 5 = " + tester.operate(10, 5, addition));
         System.out.println("10 - 5 = " + tester.operate(10, 5, subtraction));
         System.out.println("10 x 5 = " + tester.operate(10, 5, multiplication));
         System.out.println("10 / 5 = " + tester.operate(10, 5, division));
         
         // 不用括号
         GreetingService greetService1 = message -> System.out.println("Hello " + message);
         // 用括号
         GreetingService greetService2 = (message) -> System.out.println("Hello " + message);
         
         greetService1.sayMessage("Runoob");
         greetService2.sayMessage("Google");
    }

    interface MathOperation{
        int operation(int a, int b);
    }
    
    interface GreetingService{
        void sayMessage(String message);
    }
    
    private int operate(int a, int b, MathOperation mathOperation) {
        return mathOperation.operation(a, b);
    }
}

3.变量作用域

3.1 final修饰的域外局部变量

Lambda表达式只能引用标记了final的外层局部变量，也就是说不能再lambda表达式内部修改定义在域外的局部变量。
以下代码正常输出：

public class Java8Tester {
 
   final static String salutation = "Hello! ";
   
   public static void main(String args[]){
      GreetingService greetService1 = message -> 
      System.out.println(salutation + message);
      greetService1.sayMessage("Runoob");
   }
    
   interface GreetingService {
      void sayMessage(String message);
   }
}

3.2 final修饰的外部局部变量

以下代码正常输出：

public class Java8Tester {
    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);
    }
}

3.3 不用final修饰的局部变量

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

3.4 局部变量

在Lambda表达式中不允许声明一个与局部变量同名的参数或者局部变量。
以下代码不能通过编译：

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

5. lambda表达式的常见实例

5.1 函数式接口

函数式接口是只有一个方法的接口，用作lambda表达式的类型。例如之前的Runnable的例子。
下面是一个函数式接口：
@FunctionalInterface注解表明这是一个函数是接口，也就是说这个函数只有一个抽象方法。

public class FunctionalInterfaceDemo {
  @FunctionalInterface
  interface Predicate<T> {
    boolean test(T t);
  }
  /**
  * 执行Predicate判断
  * @param age       年龄
  * @param predicate Predicate函数式接口
  * @return          返回布尔类型结果
  */
  public static boolean doPredicate(int age, Predicate<Integer> predicate) {
    return predicate.test(age);
  }

  public static void main(String[] args) {
    boolean isAdult = doPredicate(20, x -> x >= 18);
    System.out.println(isAdult);
  }
}

这样可以很方便的完成判断是否是成人的动作。

5.2 Java 8中的function包

实际上在Java 8中提供了一个function包作为这种例子的使用宝典。
function包中的接口大致分为一下几类：

消费型接口示例

public static void donation(Integer money, Consumer<Integer> consumer){
    consumer.accept(money);  
}
public static void main(String[] args) {
    donation(1000, money -> System.out.println("好心的麦乐迪为Blade捐赠了"+money+"元")) ;
}

供给型接口示例

public static List<Integer> supply(Integer num, Supplier<Integer> supplier){
       List<Integer> resultList = new ArrayList<Integer>()   ;
       for(int x=0;x<num;x++)  
           resultList.add(supplier.get());
       return resultList ;
}
public static void main(String[] args) {
    List<Integer> list = supply(10,() -> (int)(Math.random()*100));
    list.forEach(System.out::println);
}

函数型接口示例

转换字符串为Integer

public static Integer convert(String str, Function<String, Integer> function) {
    return function.apply(str);
}
public static void main(String[] args) {
    Integer value = convert("28", x -> Integer.parseInt(x));
}

断言型接口示例

筛选出只有两个字的水果：

public static List<String> filter(List<String> fruit, Predicate<String> predicate){
    List<String> f = new ArrayList<>();
    for (String s : fruit) {
        if(predicate.test(s)){
            f.add(s);
        }
    }
    return f;
}
public static void main(String[] args) {
    List<String> fruit = Arrays.asList("香蕉", "哈密瓜", "榴莲", "火龙果", "水蜜桃");
    List<String> newFruit = filter(fruit, (f) -> f.length() == 2);
    System.out.println(newFruit);
}