24.函数式接口

1.函数式接口

1.1 函数式接口概述

函数式接口：有且仅有一个抽象方法的接口
Java中函数式编程体现的就是Lambda表达式，所以函数式接口就是可以适用于Lambda使用的接口
只有确保接口中有且仅有一个抽象方法，Java中的Lambda才能顺利地进行推导

如何检测一个接口是不是函数式接口呢？

@FunctionalInterface
放在接口定义的上方：如果接口是函数式接口，编译通过；如果不是，编译失败

注意：
    我们自己定义函数式接口的时候，@FunctionalInterface是可选的，就算不写这个注解，只要保证满足函数式接口定义的条件，也照样是函数式接口。
    但是，建议加上该注解

1.2 函数式接口作为方法的参数

需求
    定义一个类(RunnableDemo)，在类中提供两个方法
        一个方法是：startThread(Runnable r) 方法参数Runnable是一个函数式接口
        一个方法是主方法，在主方法中调用startThread方法

如果方法的参数是一个函数式接口，我们可以使用Lambda表达式作为参数传递
    startThread(() -> System.out.println(Thread.currentThread().getName() + “线程启动”));

public class RunnableDemo {
    public static void main(String[] args) {
        startThread(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + "线程启动");
            }
        });

        startThread(()-> System.out.println(Thread.currentThread().getName() + "线程启动"));
    }

    public static void startThread(Runnable r){
        Thread t = new Thread(r);
        t.start();
    }
}

1.3 函数式接口作为方法的返回值

需求
    定义一个类(ComparatorDemo)，在类中提供两个方法
        一个方法是：Comparator< String > getComparator() 方法返回值Comparartor是一个函数式接口
        一个方法是主方法，在主方法中调用getComparator方法

在此处仍有疑问，为什么Comparator接口里有两个抽象方法：int compara、boolean equals，但仍然是一个FunctionalInterface

public class ComparatorDemo {
    public static void main(String[] args) {
        ArrayList<String> array = new ArrayList<String>();
        array.add("aaaa");
        array.add("bbb");
        array.add("cc");
        array.add("d");

        Collections.sort(array,getComparator());

        System.out.println(array);
    }
    public static Comparator<String> getComparator(){
/*
        Comparator<String> comp = new Comparator<String>() {
            @Override
            public int compare(String s1, String s2) {
                return s1.length()-s2.length();
            }
        };
        return comp;
        */

        return (s1,s2) -> s1.length()-s2.length();
    }
}

1.4 常用的函数式接口

Java 8 在java.util.function包下预定义了大量的函数式接口供我们使用
我们来重点学习下面的4个接口
① Supplier接口
② Consumer接口
③ Predicate接口
④ Function接口

1.5 Supplier接口

Supplier< T >：包含一个无参的方法

    T get()：获得结果
    该方法不需要参数，他会按照某种实现逻辑(由Lambda表达式实现)返回一个数据
    Supplier< T >接口也被称为生产型接口，如果我们指定了接口的泛型是什么类型，那么接口中的get方法就会产生什么类型的数据供我们使用

public class SupplierDemo {
    public static void main(String[] args) {
        String s = getString(() -> "Rarity");
        System.out.println(s);

        int i = getInt(() -> 3);
        System.out.println(i);

    }

    //定义一个方法，返回一个字符串数据
    public static String getString(Supplier<String> s){
        return s.get();
    }

    //定义一个方法，返回一个整数数据
    public static int getInt(Supplier<Integer> i){
        return i.get();
    }
}

练习
    定义一个类(SupplierTest)，在类中提供两个方法
        一个方法是：int getMax(Supplier< Integer> sup) 用于返回一个int数组中的最大值
        一个方法是主方法，在主方法中调用getMax方法

public class SupplierTest {
    public static void main(String[] args) {
        int[] arr = {19, 58, 28, 27, 36};
        int maxValue = getMax(() -> {
            int max = arr[0];
            for (int i : arr) {
                max = Math.max(max, i);
            }
            return max;
        });
        System.out.println(maxValue);
    }

    public static int getMax(Supplier<Integer> sup) {
        return sup.get();
    }
}

1.6 Consumer接口

Consumer< T>：包含两个方法
① void accept(T t)：对给定的参数执行此操作
② default Consumer< T> andThen(Consumer after)：返回一个组合的Consumer，依次执行此操作，然后执行after操作

        Consumer< T> 接口也被称为消费型接口，它消费的数据的数据类型由泛型指定

public class ConsumerDemo {
    public static void main(String[] args) {

        operatorString("Rarity",(String s)->{
            System.out.println(s);
        });

        operatorString("rarity",s -> System.out.println(s));

        operatorString("Twilight",System.out::println);

        operatorString("Twilight", s->{
            System.out.println(new StringBuilder(s).append(" Sparkle").toString());
        });

        operatorString("Starlight",s -> {
            StringBuilder sb = new StringBuilder(s).append(" Glimmer");
            System.out.println(sb);
        },s -> {
            System.out.println(new StringBuilder(s).append(" is a Pony"));
        });
    }

    //定义一个方法，消费一个字符串数据
    private static void operatorString(String name, Consumer<String> con){
        con.accept(name);
    }

    //定义一个方法，用不同的方式消费同一个字符串数据两次
    private static void operatorString(String name,Consumer<String> con1,Consumer<String> con2){
/*        con1.accept(name);
        con2.accept(name);*/
        //改进
        con1.andThen(con2).accept(name);
    }
}

练习
    String[] strArray = {“Rarity,15”,“Twilight,14”,“FlutterShy,16”};
    字符串数组中有多条信息，请按照格式："姓名：XX，年龄：XX"的格式将信息打印出来
    要求：
        把打印姓名的动作作为第一个Consumer接口的Lambda实例
        把打印年龄的动作作为第二个Consumer接口的Lambda实例
        将两个Consumer接口按照顺序组合到一起使用

public class ConsumerTest {
    public static void main(String[] args) {
        String[] strArray = {"Rarity,15", "Twilight,14", "FlutterShy,16"};
        printInfo(strArray, (String s) -> {
            String[] info = s.split(",");
            String name = info[0];
            System.out.print("姓名：" + name);
        }, (String s) -> {
            String[] info = s.split(",");
            int age = Integer.parseInt(info[1]);
            System.out.println("年龄：" + age);
        });
    }

    private static void printInfo(String[] strArray, Consumer<String> con1, Consumer<String> con2) {
        for (String str : strArray) {
            con1.andThen(con2).accept(str);
        }
    }
}

1.7 Predicate接口

Predicate< T>：常用的四个方法
① boolean test(T t)：对给定的参数进行判断(判断逻辑由Lambda表达式实现)，返回一个布尔值
② default Predicate< T> negate()：返回一个逻辑的否定，对应逻辑非
③ default Predicate< T> and(Predicate other)：返回一个组合判断，对应短路与
④ default Predicate< T> or(Predicate other)：返回一个组合判断，对应短路或

    Predicate< T>接口通常用于判断参数是否满足指定的条件

public class PredicateDemo1 {
    public static void main(String[] args) {
        boolean b1 = checkString("Rarity", (String s) -> {
            return s.length() > 8;
        });
        System.out.println(b1);

        boolean b2 = checkString("Rarity",s -> s.length()>8);
        System.out.println(b2);
    }

    private static boolean checkString(String s, Predicate<String> pre) {
//        return pre.test(s);
//        return !pre.test(s);
        return pre.negate().test(s);
    }
}

public class PredicateDemo2 {
    public static void main(String[] args) {
        boolean b1 = checkString("Rarity", s -> s.length() > 8);
        System.out.println(b1);

        boolean b2 = checkString("TwilightSparkle", s -> s.length() > 6, s -> s.length() < 16);
        System.out.println(b2);

    }

    private static boolean checkString(String s, Predicate<String> pre) {
        return pre.test(s);
    }

    //同一个字符串给出两个不同的判断条件，最后把着两个判断的结果做逻辑与运算的结果作为最终的结果
    private static boolean checkString(String s, Predicate<String> pre1, Predicate<String> pre2) {
        return pre1.and(pre2).test(s);
    }

}

练习
    String[] strArray = {“Rarity,15”,“TwilightSparkle,14”,“FlutterShy,16”,“RainbowDash,14”,“AppleJack,16”,“PinkiePie,15”};

    字符串数组中有多条信息，请通过Predicate接口的拼装将符合要求的字符串筛选到集合ArrayList中，并遍历ArrayList集合
    同时满足如下要求：姓名长度大于2；年龄大于14
    分析
        有两个判断条件，所以需要使用两个Predicate接口，对条件进行判断
        必须同时满足两个条件，所以可以使用and方法连接两个判断条件

public class Practice {
    public static void main(String[] args) {
        String[] strArray = {"Rarity,15","TwilightSparkle,14","FlutterShy,16","RainbowDash,14","AppleJack,16","PinkiePie,15"};

        ArrayList<String> arrayList = checkString(strArray, (s) -> {
            String name = s.split(",")[0];
            return name.length() > 7;
        }, (s -> {
            int age = Integer.parseInt(s.split(",")[1]);
            return age > 14;
        }));
        System.out.println(arrayList);
    }

    //通过Predicate接口的拼装将符合要求的字符串筛选到集合ArrayList中
    private static ArrayList<String> checkString(String[] strArray, Predicate<String> pre1, Predicate<String> pre2){
        ArrayList<String> array = new ArrayList<>();

        for(String s : strArray){
            if(pre1.and(pre2).test(s)){
                array.add(s);
            }
        }
        return array;
    }
}

1.8 Function接口

Function<T,R>：常用的两个方法
① R appy(T t)：将此函数应用于给定的参数
② default < V> Function andThen(Function after)：返回一个组合函数，首先将该函数应用于输入，然后将after函数应用于结果

    Function<T,R>接口通常用于对参数进行处理，转换(处理逻辑由Lambda表达式实现)，然后返回一个新的值

public class FunctionDemo {
    public static void main(String[] args) {
        StringToInt("123456", s -> Integer.parseInt(s));
        StringToInt("654321", Integer::parseInt);
        System.out.println("--------");
        IntToString(456789, i -> String.valueOf(i + 1));
        System.out.println("--------");
        convert("750", s -> Integer.parseInt(s),i -> String.valueOf(i + 250));
    }

    //定义一个方法，把一个字符串转换int类型，在控制台输出
    private static void StringToInt(String s, Function<String, Integer> fun) {
        int i = fun.apply(s);
        System.out.println(i);
    }

    //定义一个方法，把一个int类型的数据加上一个整数后，转为字符串在控制台输出
    private static void IntToString(int i, Function<Integer, String> fun) {
        String s = fun.apply(i);
        System.out.println(s);
    }

    //定义一个方法，把一个字符串转换int类型，把int类型的数据加上一个整数之后，转为字符串在控制台输出
    private static void convert(String s, Function<String, Integer> fun1, Function<Integer, String> fun2){
/*        Integer i = fun1.apply(s) ;
        String str = fun2.apply(i);
        System.out.println(str);*/
        String ss = fun1.andThen(fun2).apply(s);
        System.out.println(ss);
    }
}

练习
    String s = “Rarity,15”;
    按照指定的要求进行操作：
        1.将字符串截取得到数字年龄部分
        2.将上一步的年龄字符串转换为int类型的数据
        3.将上一步的i那天数据加70，得到一个int结果，在控制台输出
    通过Function接口来实现函数拼接

public class FunctionDemo1 {
    public static void main(String[] args) {
        convert("Rarity,15",s -> s.split(",")[1],age -> Integer.parseInt(age), i -> i+70);
        convert("Rarity,15",s -> s.split(",")[1],Integer::parseInt, i -> i+70);
    }

    private static void convert(String s, Function<String, String> fun1, Function<String, Integer> fun2, Function<Integer, Integer> fun3) {
/*        String age = fun1.apply(s);
        Integer i = fun2.apply(age);
        Integer result = fun3.apply(i);
        System.out.println(result);*/
        Integer result = fun1.andThen(fun2).andThen(fun3).apply(s);
        System.out.println(result);
    }
}