函数式接口

1.函数式接口

MyInterface

@FunctionalInterface
public interface MyInterface {
    void show();

//    void method();
}

MyInterfaceDemo

/*
    函数式接口：有且仅有一个抽象方法的接口
 */
public class MyInterfaceDemo {
    public static void main(String[] args) {
        MyInterface my = () -> System.out.println("函数式接口");
        my.show();
    }
}

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

/*
    定义一个类(RunnableDemo)，在类中提供两个方法
        一个方法是：startThread(Runnable r)   方法参数Runnable是一个函数式接口
        一个方法是主方法，在主方法中调用startThread方法
 */
public class RunnableDemo {
    public static void main(String[] args) {
        //在主方法中调用startThread方法

        //匿名内部类的方式
        startThread(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"线程启动了");
            }
        });

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

    }

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

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

/*
    定义一个类(ComparatorDemo)，在类中提供两个方法
            一个方法是：Comparator<String> getComparator()   方法返回值Comparator是一个函数式接口
            一个方法是主方法，在主方法中调用getComparator方法
*/
public class ComparatorDemo {
    public static void main(String[] args) {
        //构造使用场景

        //定义集合，存储字符串元素
        ArrayList<String> array = new ArrayList<String>();

        array.add("cccc");
        array.add("aa");
        array.add("b");
        array.add("ddd");

        System.out.println("排序前：" + array);
        
        System.out.print("自然排序：" );
        Collections.sort(array);
        System.out.println(array);

        System.out.print("排序器排序：" );
        Collections.sort(array, getComparator());
        System.out.println( array);

    }

    private 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 new Comparator<String>() {
//            @Override
//            public int compare(String s1, String s2) {
//                return s1.length()-s2.length();
//            }
//        };

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

        //最简洁方式
        return (s1, s2) -> s1.length() - s2.length();
    }
}

1.3 常用函数式接口之Supplier

/*
    Supplier<T>：包含一个无参的方法
        T get​()：获得结果
        该方法不需要参数，它会按照某种实现逻辑(由Lambda表达式实现)返回一个数据
        Supplier<T>接口也被称为生产型接口，如果我们指定了接口的泛型是什么类型，那么接口中的get方法就会生产什么类型的数据供我们使用
 */
public class SupplierDemo {
    public static void main(String[] args) {
//        String s = getString(() -> {
//            return "林青霞";
//        });

        String s = getString(() -> "林青霞");
        System.out.println(s);

        //匿名内部类
        getString(new Supplier<String>() {
            @Override
            public String get() {
                String ss="gfshhgg";
                System.out.println(ss);
                return ss;
            }
        });

        Integer i = getInteger(() -> 30);
        System.out.println(i);
    }

    //定义一个方法，返回一个整数数据
    private static Integer getInteger(Supplier<Integer> sup) {
        return sup.get();
    }

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

}

1.3.1 Supplier接口练习之获取最大值

/*
    定义一个类(SupplierTest)，在类中提供两个方法
            一个方法是：int getMax(Supplier<Integer> sup)   用于返回一个int数组中的最大值
            一个方法是主方法，在主方法中调用getMax方法
*/
public class SupplierTest {
    public static void main(String[] args) {
        //定义一个int数组
        int[] arr = {19, 50, 28, 37, 46};

        int maxValue = getMax(()-> {
           int max = arr[0];

           for(int i=1; i<arr.length; i++) {
               if(arr[i] > max) {
                   max = arr[i];
               }
           }

           return max;
        });

        System.out.println(maxValue);

    }

    //返回一个int数组中的最大值
    private static int getMax(Supplier<Integer> sup) {
        return sup.get();
    }
}

1.4 常用函数式接口之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("林青霞",(String s) -> {
//            System.out.println(s);
//        });

        operatorString("林青霞", s -> System.out.println(s));
//        operatorString("林青霞",System.out::println);

//        operatorString("林青霞", s -> {
//            System.out.println(new StringBuilder(s).reverse().toString());
//        });

        operatorString("林青霞", s -> System.out.println(new StringBuilder(s).reverse().toString()));
        System.out.println("--------");

        operatorString("林青霞", s -> System.out.println(s), s -> System.out.println(new StringBuilder(s).reverse().toString()));
    }

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

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

1.4.1 Consumer接口练习之按要求打印信息

public class ConsumerTest {
    public static void main(String[] args) {
        String[] strArray = {"林青霞,30", "张曼玉,35", "王祖贤,33"};

        printInfo(strArray, (String str) -> {
            String name = str.split(",")[0];
            System.out.print("姓名：" + name);
        }, (String str) -> {
            int age = Integer.parseInt(str.split(",")[1]);
            System.out.println(",年龄：" + age);
        });
        System.out.println("--------------");
        printInfo(strArray, str -> System.out.print("姓名：" + str.split(",")[0]),
                str -> System.out.println(",年龄：" + Integer.parseInt(str.split(",")[1])));
    }

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

1.5 常用函数式接口之Predicate

/*
    Predicate<T>：常用的四个方法
        boolean test​(T t)：对给定的参数进行判断(判断逻辑由Lambda表达式实现)，返回一个布尔值
        default Predicate<T> negate​()：返回一个逻辑的否定，对应逻辑非
        Predicate<T>接口通常用于判断参数是否满足指定的条件
 */
public class PredicateDemo01 {
    public static void main(String[] args) {
//        boolean b1 = checkString("hello",(String s) -> {
//            return s.length()>8;
//        });

        boolean b1 = checkString("hello", s -> s.length() > 8);
        System.out.println(b1);

        boolean b2 = checkString("helloworld",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);//negate()逻辑非
    }
}

/*
    Predicate<T>：
        default Predicate<T> and​(Predicate other)：返回一个组合判断，对应短路与
        default Predicate<T> or​(Predicate other)：返回一个组合判断，对应短路或
 */
public class PredicateDemo02 {
    public static void main(String[] args) {
        boolean b1 = checkString("hello", s -> s.length() > 8);
        System.out.println(b1);
        boolean b2 = checkString("helloworld", s -> s.length() > 8);
        System.out.println(b2);

        boolean b3 = checkString("hello",s -> s.length() > 8, s -> s.length() < 15);
        System.out.println(b3);

        boolean b4 = checkString("helloworld",s -> s.length() > 8, s -> s.length() < 15);
        System.out.println(b4);
    }

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

//        return pre1.and(pre2).test(s);
        return pre1.or(pre2).test(s);
    }

    //判断给定的字符串是否满足要求
    private static boolean checkString(String s, Predicate<String> pre) {
        return pre.test(s);
    }
}

1.5.1 Predicate接口练习之筛选满足条件数据

/*
    String[] strArray = {"林青霞,30", "柳岩,34", "张曼玉,35", "貂蝉,31", "王祖贤,33"};
    字符串数组中有多条信息，请通过Predicate接口的拼装将符合要求的字符串筛选到集合ArrayList中，并遍历ArrayList集合
    要求：同时满足如下要求
        1:姓名长度大于2
        2:年龄大于33
    分析:
        1:有两个判断条件,所以需要使用两个Predicate接口,对条件进行判断
        2:必须同时满足两个条件,所以可以使用and方法连接两个判断条件
 */
public class PredicateTest {
    public static void main(String[] args) {
        String[] strArray = {"林青霞,30", "柳岩,34", "张曼玉,35", "貂蝉,31", "王祖贤,33"};

        ArrayList<String> array = myFilter(strArray, s -> s.split(",")[0].length() > 2,
                s -> Integer.parseInt(s.split(",")[1]) > 33);

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

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

        //遍历数组
        for (String str : strArray) {
//            if (pre1.and(pre2).test(str)) {
////                array.add(str);
////            }
            if (pre1.and(pre2).test(str)){
                array.add(str);
            }
        }

        return array;
    }
}

1.6 常用函数式接口之Function

/*
    Function<T,R>：常用的两个方法
        R apply​(T t)：将此函数应用于给定的参数
        default <V> Function andThen​(Function after)：返回一个组合函数，首先将该函数应用于输入，然后将after函数应用于结果
        Function<T,R>接口通常用于对参数进行处理，转换(处理逻辑由Lambda表达式实现)，然后返回一个新的值
 */
public class FunctionDemo {
    public static void main(String[] args) {
//        convert("100",(String s) -> {
//            return Integer.parseInt(s);
//        });

        convert("100",s -> Integer.parseInt(s));//Integer.parseInt()将字符串转换成整数
//        convert("100",Integer::parseInt);

        convert(100,i -> String.valueOf(i + 566));//String.valueOf()将整数转换成字符串

        convert("100", s -> Integer.parseInt(s), i -> String.valueOf(i + 566));
    }

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


    //定义一个方法，把一个int类型的数据加上一个整数之后，转为字符串在控制台输出
    private static void convert(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 ss = fun2.apply(i);
//        System.out.println(ss);

        String ss = fun1.andThen(fun2).apply(s);
        System.out.println(ss);
    }

}

1.6.1 Function接口练习之按照指定要求操作数据

/*
    String s = "林青霞,30";
    请按照我指定的要求进行操作：
        1:将字符串截取得到数字年龄部分
        2:将上一步的年龄字符串转换成为int类型的数据
        3:将上一步的int数据加70，得到一个int结果，在控制台输出
    请通过Function接口来实现函数拼接
*/
public class FunctionTest {
    public static void main(String[] args) {
        String s = "林青霞,30";

//        convert(s, (String ss) -> {
//            return s.split(",")[1];
//        },(String ss) -> {
//            return Integer.parseInt(ss);
//        },(Integer i) -> {
//            return i + 70;
//        });

//        convert(s, ss -> ss.split(",")[1], ss -> Integer.parseInt(ss), i -> i + 70);
        convert(s, ss -> ss.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) {
//        Integer i = fun1.andThen(fun2).andThen(fun3).apply(s);
        int i = fun1.andThen(fun2).andThen(fun3).apply(s);
        System.out.println(i);
    }
}