参考文章：https://blog.csdn.net/qq_29411737/article/details/80835658

一、Lambda
1.1、表达式

 //匿名内部类
  Comparator<Integer> cpt = new Comparator<Integer>() {
      @Override
      public int compare(Integer o1, Integer o2) {
          return Integer.compare(o1,o2);
      }
  };
  TreeSet<Integer> set = new TreeSet<>(cpt);
  //使用lambda表达式
  Comparator<Integer> cpt2 = (x,y) -> Integer.compare(x,y);
  TreeSet<Integer> set2 = new TreeSet<>(cpt2);

1.2、Lambda语法
Lmabda表达式的语法总结： () -> ();

image.png

口诀：左右遇一省括号，左侧推断类型省

二、函数式接口
提供了注解：@FunctionalInterface，判断是否是函数式接口
2.1、常见的四大函数式接口

Consumer 《T》：消费型接口，有参无返回值

@Test
    public void test(){
        changeStr("hello",(str) -> System.out.println(str));
    }
    // Consumer<T> 消费型接口
    public void changeStr(String str, Consumer<String> con){
        con.accept(str);
    }

Supplier 《T》：供给型接口，无参有返回值

 @Test
    public void test2(){
        String value = getValue(() -> "hello");
        System.out.println(value);
    }
    //  Supplier<T> 供给型接口
    public String getValue(Supplier<String> sup){
        return sup.get();
    }

Function <T,R>：:函数式接口，有参有返回值

  @Test
    public void test3(){
        Long result = changeNum(100L, (x) -> x + 200L);
        System.out.println(result);
    }
    //  Function<T,R> 函数式接口
    public Long changeNum(Long num, Function<Long, Long> fun){
        return fun.apply(num);
    }

Predicate《T》： 断言型接口，有参有返回值，返回值是boolean类型

public void test4(){
        boolean result = changeBoolean("hello", (str) -> str.length() > 5);
        System.out.println(result);
    }
    // Predicate<T> 断言型接口
    public boolean changeBoolean(String str, Predicate<String> pre){
        return pre.test(str);
    }

三、方法引用
3、1三种表现形式：
1. 对象::实例方法名
2. 类::静态方法名
3. 类::实例方法名 （lambda参数列表中第一个参数是实例方法的调用 者，第二个参数是实例方法的参数时可用）

例子

 public void test() {
        /**
        *注意：
        *   1.lambda体中调用方法的参数列表与返回值类型，要与函数式接口中抽象方法的函数列表和返回值类型保持一致！
        *   2.若lambda参数列表中的第一个参数是实例方法的调用者，而第二个参数是实例方法的参数时，可以使用ClassName::method
        *
        */
        Consumer<Integer> con = (x) -> System.out.println(x);
        con.accept(100);

        // 方法引用-对象::实例方法
        Consumer<Integer> con2 = System.out::println;
        con2.accept(200);

        // 方法引用-类名::静态方法名
        BiFunction<Integer, Integer, Integer> biFun = (x, y) -> Integer.compare(x, y);
        BiFunction<Integer, Integer, Integer> biFun2 = Integer::compare;
        Integer result = biFun2.apply(100, 200);

        // 方法引用-类名::实例方法名
        BiFunction<String, String, Boolean> fun1 = (str1, str2) -> str1.equals(str2);
        BiFunction<String, String, Boolean> fun2 = String::equals;
        Boolean result2 = fun2.apply("hello", "world");
        System.out.println(result2);
    }