函数式接口（都2020了，该学学Java8了）

一、函数式接口

• 定义：有且仅有一个抽象方法的接口
• 定义解释：
  1、为什么要求有且仅有一个抽象方法？
  只有确保接口中有且仅有一个抽象方法，Java中的Lambda才能顺利地进行推导，因为Java中的Lambda可以被当做是匿名内部类的“语法糖”（见第2点），但是二者在原理上不同。
  2、什么是语法糖？
  “语法糖"是指使用更加方便，但是原理不变的代码语法。例如在遍历集合时使用的foreach语法，其实底层的实现原理仍然是迭代器，这便是“语法糖”。从应用层面来讲，Java中的Lambda可以被当做是匿名内部类的“语法糖”，但是二者在原理上是不同的。
  3、匿名内部类？
  这里简单举个例子，如果你完全不懂什么是匿名内部类还要去查相关资料
  例如，一个方法需要一个类的对象作为参数，但是你只有这个类的接口，不想因为某个方法单独写具体的实现类，这时你可以通过”匿名内部类“来实现这个接口来实现传参，而不必单独的去实现这个类。
  匿名内部类示例：

//peolpe类
public interface People {
    public abstract String getName();
}

//car类
public class Car {
//driveCar方法需要people类的实例
    public String driveCar(People people) {
        return people.getName() + " driving car !";
    }

    public static void main(String[] args) {
        Car car = new Car();
        String whoDrivingCar = car.driveCar(
        //people的匿名内部类
        new People() {
            @Override
            public String getName() {
                return "lbw";
            }
        });
        System.out.println(whoDrivingCar);
    }
}

• 应用：一般作为方法的参数或者方法的返回值
• 函数式接口改造示例：
  给接口加上@FunctionalInterface注解保证有且仅有一个抽象方法

@FunctionalInterface
public interface People {
    public abstract String getName();
}

将匿名内部类改写成lambada的简化写法

public class Car {
    public String driveCar(People people) {
        return people.getName() + " driving car !";
    }

    public static void main(String[] args) {
        Car car = new Car();
        String whoDrivingCar = car.driveCar(
        //匿名内部类
        //()里写参数
        //->lambada符号
        //{}里写实现
        () -> {
            return "lbw";
        });
        System.out.println(whoDrivingCar);
    }

}

• 常用的函数式接口：
  1、生产型Supplier：返回泛型中指定类型的数据

public class SupplierTest {
//泛型为string
    public static String getName(Supplier<String> supplier) {
        return supplier.get();
    }

    public static void main(String[] args) {
    //返回String
        String name = getName(() -> {
            return "小明";
        });
        System.out.println(name);
    }
}

2、消费型:Consumer:消费泛型中指定类型数据

ublic class ConsumerTest {
//    反转字符串
    public static void reverseString(String name, Consumer<String> consumer) {
        consumer.accept(name);
    }

    public static void main(String[] args) {
        reverseString("1234567", (String name) -> {
            System.out.println(new StringBuffer(name).reverse().toString());
        });
    }
}

3、转换型Function:将前者类型转换为后者类型

public class FunctionTest {
    public static Integer transfer(String string, Function<String, Integer> function) {
        return function.apply(string);
    }

    public static void main(String[] args) {
        System.out.println(
                transfer("100",
                        (String string) -> {
                            return Integer.parseInt(string);
                        }));
    }
}

4、真假型Predicate：对传入数据进行判断，得到Boolean类型结果

public class PredicateTest {
    public static boolean isFlag(String string, Predicate<String> predicate) {
        return predicate.test(string);
    }

    public static void main(String[] args) {
        boolean flag = isFlag("奥利粤", (string) -> {
            return "奥利奥".equals(string);
        });
        System.out.println(flag==true?"真的奥利奥":"假的奥利奥");
    }
}