函数式接口1

1、 函数式接口
函数式接口概念：有且仅有一个抽象方法的接口。接口中可以包含其他方法（默认，静态，私有 ）
1.1 @FunctionalInterface注解
作用：可以检测接口是否是一个函数式接口（只有一个抽象方法）
是：编译成功
否：编译失败（接口中没有抽象方法或者有多个抽象方法）
函数式接口定义代码示例：

@FunctionalInterface
public interface FunctionInterface {
    // 定义抽象方法
    public abstract void method ();
    // 私有 （从Java 9开始,接口当中允许定义私有方法。）解决多个默认/静态方法代码重复的问题
    private void method1() {
        System.out.println("我是私有方法");
    }
    // 静态 （从Java 8开始,接口当中允许定义静态方法）
    public static void method2() {
        System.out.println("我是静态方法");
    }
    /*
        默认 （jdk1.8开始，接口里允许定义默认方法） 解决接口升级的问题，当有一个接口，
        并且n多个类实现了这个接口；而当接口再次添加抽象方法的时候，n多个实现类就会报错。而出现了默认方法就解决了这个问题
    */
    public default void method3() {
        System.out.println("我是默认方法");
    }
}

1.2 函数式接口的使用场景：
一般可以作为方法的参数和返回值类型
代码示例：

    public static void main(String[] args) {
        // 方法的参数式一个接口，所以可以传递接口的实现类对象
        show(new FunctionInterfaceImpl());

        // 方法的参数式一个接口，可以传递接口的匿名内部类
        show(new FunctionInterface() {
            @Override
            public void method() {
                System.out.println("使用匿名内部类重写接口的抽象方法");
            }
        });

        // 方法的参数是一个函数式接口，可以传递Lambda表达式
        show(() -> {
            System.out.println("使用Lambda表达式重写接口的抽象方法");
        });

        // 简化版Lambda表达式
        show(() -> System.out.println("简化版Lambda表达式重写接口的抽象方法"));

    }
    // 定义方法，参数使用函数式接口
    public static void show (FunctionInterface fun) {
        fun.method();
    }

1.3 参数使用Lambda表达式
作用：可以避免性能浪费
Lambda特点：延迟加载
Lambda使用前提：必须存在函数式接口
举例：

    public static void main(String[] args) {
        String msg1 = "Hello";
        String msg2 = "World";
        String msg3 = "Java";
        // 条件不满足，传递message拼接字符串造成了性能浪费
        show(2, msg1 + msg2 + msg3);
    }

    public static void show(int level, String message) {
        if (level == 1) {
            System.out.println(message);
        }
    }

/*
	解决方法，可以定义一个函数式接口并定义字符串拼接的抽象方法，方法的形参传递此接口；
	调用方法时实参传递此接口的Lambda表达式，如果条件成立则拼接字符串返回，条件不成立不执行Lambda表达式
*/
// 定义函数式接口
@FunctionalInterface
public interface FunctionInterface {

    // 定义拼接字符串的抽象方法
    public abstract String builderMessage();
}

    public static void main(String[] args) {
        String msg1 = "Hello";
        String msg2 = "World";
        String msg3 = "Java";

        show(2, () -> {
            System.out.println("Lambda有延迟执行的特性，不满足条件不执行");
            return msg1 + msg2 + msg3;
        });
    }

    public static void show(int level, FunctionInterface myInterface) {
        if (level == 1) {
            System.out.println(myInterface.builderMessage());
        }
    }

1.4 函数式接口作为方法返回值按理

// 按照字符串的长度排序
    public static void main(String[] args) {
        String[] arr = {"aaaaa", "eeeeee", "wwwwwwwww"};
        System.out.println(Arrays.toString(arr));
        Arrays.sort(arr, getComparator());
        System.out.println(Arrays.toString(arr));
    }

    public static Comparator<String> getComparator() {
        /*
        // 匿名内部类实现
        return new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                return o2.length() - o1.length();
            }
        };
         */
        /*
        // Lambda表达式
        return ((String o1, String o2) -> {
            return o2.length() -o1.length();
        });
         */
        // 简化Lambda
        return ((o1, o2) -> o2.length() -o1.length());
    }