JDK8新特性：函数式接口

1. 函数式接口：是仅包含一个抽象方法的接口，但可以包含一个或多个静态或默认方法。
   例如：

//仅包含一个抽象方法
public interface MyInterface {
     int add(int a, int b);
}

// 包含一个抽象方法，和一个默认方法
public interface MyInterface {
     int add(int a, int b);
     default int subtract(int a, int b) {
         return a - b;
     }
}

//默认方法：即接口可以有实现方法，不需要实现类去实现其方法。只需在方法名前面加个 default 关键字即可实现默认方法。
//一个接口中可以有多个默认方法，也可以有静态默认方法，例如：
public interface Vehicle {
   default void print(){
      System.out.println("我是一辆车!");
   }
    // 静态方法
   static void blowHorn(){
      System.out.println("按喇叭!!!");
   }
}

//当一个类实现了2个接口，两个接口中有同名默认方法时，可重写来覆盖接口的默认方法，也可以使用 super 来调用指定接口的默认方法，如下：
public interface Vehicle {
   default void print(){
      System.out.println("我是一辆车!");
   }
}

public interface FourWheeler {
   default void print(){
      System.out.println("我是一辆四轮车!");
   }
}

public class Car implements Vehicle, FourWheeler {
   default void print(){
      System.out.println("我是一辆四轮汽车!");
   }
}

public class Car implements Vehicle, FourWheeler {
   public void print(){
      Vehicle.super.print();
   }
}

2. 函数式接口的意义：允许把函数作为参数传递，比如传递Lambda、方法引用、函数式接口对应的实例对象等。

3. 函数式接口用法如下：

public class FunctionalInterfaceTest {

    // 1.写了一个方法，参数是函数式接口，你可以传递Runnable的实现，也可以使用Lambda或方法引用
    public static void execute(Runnable runnable) {
        try {
            runnable.run();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        // 2.传入匿名对象
        execute(new Runnable() {
            @Override
            public void run() {
                System.out.println("匿名对象");
            }
        });

        // 3.使用Lambda，()表示Runnable#run()的参数，println()是Runnable#run()的方法体
        execute(() -> System.out.println("使用lambda"));

        // 5.因为wrapPrintln和上面的println做的是同样的事，可以替换
        UserService userService = new UserService();
        execute(() -> userService.wrapPrintln());
        
        // 6.IDEA提示上面的代码可以优化成 方法引用
        execute(userService::wrapPrintln);
        
        // 8.你会发现上面的写法仍是对的，因为“仅有一个抽象方法”是对Runnable的约束，不要搞混
    }

    // 4.我们试着把println()移到wrapPrintln中
    static class UserService {
        public void wrapPrintln() {
            System.out.println("包装后的println");
        }

        // 7.给UserService新增一个方法
        public void anotherMethod() {
            System.out.println("另一个方法，不影响execute使用wrapPrintln");
        }
    }
}

4. JDK8内置的4大核心函数式接口：

//1.消费型接口: Consumer<T>
//抽象方法名：void accept(T t)
public void happy(double money, Consumer<Double> con){
       con.accept(money);
}

//2. 供给型接口: Supplier<T>
//抽象方法名：T get();
//例：产生一些整数，并放入集合中
public List<Integer> getNumList(int num, Supplier<Integer> sup){
      List<Integer> list = new ArrayList<>();

      for (int i = 0; i < num; i++){
          Integer n = sup.get();
          list.add(n);
      }
      return list;
}

@Test
public void test2(){
    List<Integer> numList = getNumList(10, () -> (int)(Math.random() * 100));

    for (Integer num : numList){
        System.out.println(num);
	}
}

//3.函数型接口：Function<T, R>
//抽象方法名：R apply(T t);
// 例：用于处理字符串
public String strHandler(String str, Function<String, String> fun){
    return fun.apply(str);
}

@Test
public void test3(){
    String newStr = strHandler("\t\t\t e路纵横开发团队", (str) -> str.trim());
    System.out.println(newStr);

    String subStr = strHandler("e路纵横开发团队", (str) -> str.substring(0, 4));
    System.out.println(subStr);
}

//4. 断言型接口：Predicate<T>
//抽象方法名：boolean test(T t);
//例：将满足条件的字符串，放入集合中去
public List<String> filterStr(List<String> list, Predicate<String> pre){
   List<String> strList = new ArrayList<>();

   for (String str : list){
        if (pre.test(str)){
            strList.add(str);
        }
   }
       return strList;
}

@Test
public void test4(){
   List<String> list = Arrays.asList("Hello", "e路纵横", "Lambda", "ok");
   List<String> strList = filterStr(list, (s) -> s.length() > 3);

   for (String str : strList){
       System.out.println(str);
   }
}