Java8 函数式接口+Lambda表达式

函数式接口（Functional interface）
就是一个且仅有一个抽象方法，但是可以有多个非抽象方法的接口。
函数式接口可以被隐式转换为lambda表达式。
如果定义一个函数式接口如下:

interface GreetingService 
{
    void sayMessage(String message);
}

那么就可以使用Lambda表达式来标识该接口的一个实现，（Java8之前一般用匿名类实现），Lambda表达式免去了使用内部匿名类的麻烦，给予Java简单强大的函数化编程能力。

GreetingService greetService1 = message -> System.out.println("Hello " + message);

lambda表达式语法：

(parameters) -> expression

(parameters) ->{ statements; }

注意：
1无需指定lambda表达式的返回类型。lambda表达式的返回类型总是会由上下文推导得出。
2 如果一个lambda表达式只在某些分支返回一个值，而在另一些分支不返回值，这是不合法的。
例如：

（int x）->{if(x>0) return 1;}//不合法

一些可以简化的写法：
可选的类型声明

(a, b) -> a - b;//不需要声明参数类型，编译器可以统一识别参数值

可选的参数圆括号

x -> 2 * x;//一个参数无需定义圆括号，但多个参数需要定义圆括号

可选的大括号

(String s) -> System.out.print(s);//如果主体包含了一个语句，就不需要使用大括号

可选的返回关键字

(int a, int b) -> { return a * b; };//如果主体只有一个表达式，编译器则自动回返回，大括号需要制定表明表达式返回了一个数值。

函数式接口+Lambda表达式：

public class Java8Tester {
   public static void main(String args[]){
      Java8Tester tester = new Java8Tester();
        
      // 类型声明
      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);
   }
}
//代码转载 LovelyBear2019的博客

变量作用域：
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);
   }
}

也可以直接在lambda表达式中访问外层的局部变量：

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);
    }
}

lambda表达式访问的局部变量可以不用声明为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表达式当中不允许声明一个与局部变量同名的参数or局部变量

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

方法引用
可能已经有现成方法可以完成你想要传递到其他代码的某个动作。

System.out::println //是一个方法引用（method reference） 它等价于lambda表达式
x->System.out.println(x);
Arrays.sort(strings,String::compareToIgnoreCase)

使用：：操作符 分割 方法名 与对象or类名
object:: instanceMethod
Class::staticMethod
Class::instanceMethod
前两种情况汇总，方法引用等价于提供方法参数的lambda表达式， 对于第三种情况，第一个参数会成为目标

String:: compareToIgnoreCase 等用于(x,y)->x.compareToIgnoreCase(y);

类似于lambda表达式，方法引用不能独立存在，总是会转换为函数式接口的实例。
可以在方法引用中使用this参数。this::equals等同于x->this.equals(x)，使用super也是合法的。

构造器引用
构造器引用于方法引用类似，只不过方法名为new

Person::new 是person构造器的一个引用。
将一个字符串列表，可以把它转换为一个Person对象数组。具体使用哪一个构造器呢，取决于上下文

ArrayList<String> names=.....;
Stream<Person> stream=name.stream().map(Person::new);
List<person> people=stream.collect(Collectors..toList())；

如果有多个Person构造器，编译器会选择有一个String参数的构造器，因为它从上下文推导出这是在对一个字符串调用构造器。

可以用数组类型建立构造器引用，例如 int[]::new 是一个构造器引用，它有一个参数：即数组的长度。等价于 lambda表达式x->new int[x];
但是有一个限制，无法构造泛型类型T的数组。数组构造器引用对于客服这个限制很用。表达式 new T[n] 会产生错误，因为这会改为new Object[n]。对于

 Person[] people=stream.toArray(Person[]::new);

处理Lambda表达式：
编写方法处理lambda表达式:
使用lambda表达式的重点是延迟执行（deferred execution）。毕竟，如果想要立即执行代码，完全可以直接执行，则无需把它包装在一个lambda表达式中。之所以希望以后执行：

1. 在一个单独的线程中运行代码
2. 多次运行代码
3. 在算法的恰当位置运行代码（例如：排序中的比较操作）
4. 发生某种情况时执行代码（如,点击了一个按钮，书记胡到达，等等）
5. 只在必要时才运行代码

public static void repeat(int n, Runnable action){
		........
}

要接受这个lambda表达式，需要选择（偶尔可能需要提供）一个函数式接口。这里使用Runnable接口。
常用Lambda接口：

基本类型的函数式接口：

Java核心技术实战 再谈Comparator没有看懂，后续再看再总结吧