菜鸡学习day23_函数式接口

菜鸡学习day23

package day23;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
import java.util.function.Function;
import java.util.function.Consumer;
import java.util.function.Predicate;
import java.util.function.Supplier;

/*
函数式接口
有且只有一个抽象方法的接口，可以有其他方法（默认静态私有）
可以作为方法的参数和返回值类型使用
 */
public class D2301{
    public static void main(String[] args) {
        //函数式接口作为方法的参数和返回值类型使用
        //传递接口的实现类对象
        show(new shiXian());
        //传递接口的匿名内部类
        show(new Function111() {
            @Override
            public String method01() {
                System.out.println("匿名内部类。");
            return null;
            }
        });
        //lambda表达式重写方法。
        show(()->{
            System.out.println("lambda表达式重写方法。");
            return null;
        });

        //优化
        String message1 = "AAA";
        String message2 = "BBB";
        String message3 = "CCC";
        showLog(2,()->{//只有当level==1时，字符串才进行拼接，不会造成性能浪费
            return message1 + message2 + message3;
        });

        //如果方法的参数是一个接口，那么可以用lambda表达式传递这个接口的匿名内部类
        thread(()->{
            System.out.println(Thread.currentThread().getName());
        });

        //排序优化
        String[] s = {"aaa","bbbb","cccccc","d"};
        Arrays.sort(s,comparator());
        System.out.println(Arrays.toString(s));

        //Suppier,get
        getString(()->{
            return "AAAAAAA";
        });
        
        //用Suppier接口作为参数，返回数组最大值
        int[] array = {1,3,2,4,5,7,6};
        int max = getMax(()->{
            int i = 1;
            int num = array[0];
            while(i < array.length){
                if(num <= array[i])
                num = array[i];
                i++;
            }
            return num;
        });
        System.out.println(max);

        //Consumer接口，accept
        consumer01("AAA",(String str)->{
            System.out.println("消费");
        });

        //Consumer接口，andThen
        consumer02("DDFGasddw",
                (con1)->{
                    System.out.println(con1.toUpperCase());//转大写
        },(con2)->{
                    System.out.println(con2.toLowerCase());//转小写
        });

        //Consumer接口，andThen打印信息
        String[] array1 = {"小明,男","小红,女","小周,女"};
        daYin(array1,(name)->{
            String s1 = name.split(",")[0];
            System.out.print("姓名：" + s1); },
                (xingBie)->{
            String s2 = xingBie.split(",")[1];
            System.out.println(";性别：" + s2);
        });

        //Predicate接口 抽象方法test
        boolean b1 = predicate("ABCDE",(str)->{
            return str.equals("zzz");
        });
        System.out.println(b1);

        //Predicate接口 默认方法and   条件1 && 条件2
        boolean b2 = and1("ABCDEa",(str1)->{
            return str1.length() > 5;
        },(str2)->{
            return str2.contains("a");
        });
        System.out.println(b2);

        //Predicate接口 默认方法or   条件1 || 条件2
        boolean b3 = or1("ABCDEFG",(str1)->{
            return str1.length() > 5;
        },(str2)->{return str2.contains("a");
        });
        System.out.println(b3);

        //Predicate接口 默认方法negate 非   非 条件1
        boolean b4 = no1("ABCDE",(str)->{
            return str.length() < 3;
        });
        System.out.println(b4);

        //选择数据练习
        String[] array4 = {"小明,32","小小红,32","小小小周,17"};
        ArrayList<String> list = lianxi(array4,(str)->{
            return str.split(",")[0].length() == 3;
        },(str)->{
            return str.split(",")[1].equals("32");
        });
        System.out.println(list);

        //Function接口  最主要的抽象方法R apply（T t）根据类型T的参数获取类型R的结果
        apply1("AAAAA",(str)->{
            return str.length();
        });

        //
        zhuanHuan("123",(str)->{
            return Integer.parseInt(str);
        },(i)->{
            return String.valueOf(i);
        });

        //Function接口实现自定义函数模型拼接
        lianXi("小周,17",(str)->{
            return str.split(",")[1];
        },(str)->{
            return Integer.parseInt(str);
        },(i)->{
            return i + 100;
        });
    }

    
    
    //方法参数为函数式接口
    public static void show(Function111 fun){
        fun.method01();
    }

    //优化
    public static void showLog(int level,Function111 fun){
        if(level == 1){
            System.out.println(fun.method01());
        }
    }


    public static void thread(Runnable run){
        new Thread(run).start();//开启多线程
    }

    //如果方法返回值是一个函数式接口，则可返回lambda表达式
    public static Comparator<String> comparator(){
        return (String str1,String str2)->{
            System.out.println("重写。");
            return str2.length() - str1.length();
        };
    }

    //Supplier<T>接口包含一个无参的方法 T get（），用来获取一个泛型参数指定类型的对象数据
    //生产型接口，知道那个接口的泛型是什么类型，那么接口中的get方法就会产生什么类型的数据
    public static String getString(Supplier<String> sup){
        return sup.get();
    }

    //求数组元素最大值
    public static int getMax(Supplier<Integer> sup){
        return sup.get();
    }

    //Consumer<T>接口     方法accept
    //消费型接口，那个接口的泛型是什么类型，那么接口中的accept方法就会使用什么类型的数据
    public static void consumer01(String str,Consumer<String> con){
        con.accept(str);
    }

    //Consumer的方法andThen
    //需要两个接口，可以把两个接口组合到一起对数据进行消费，谁写前面就先消费
    public static void consumer02(String str, Consumer<String> con1,Consumer<String>con2){
        con1.andThen(con2).accept(str);
    }

    public static void daYin(String[] array,Consumer<String> name,Consumer<String> xingBie){
        for(String str : array){
            name.andThen(xingBie).accept(str);
        }
    }

    //predicate接口   对某种数据类型的数据进行判断，结果返回一个boolean值
    // 有一个抽象方法 boolean text（T t）用来对指定数据类型数据进行判断
    public static boolean predicate(String str,Predicate pre){
        return pre.test(str);
    }

    //predicate接口 默认方法 and
    public static boolean and1(String str,Predicate<String> pre1,Predicate<String> pre2){
        return pre1.and(pre2).test(str);
    }

    //predicate接口 默认方法 or
    public static boolean or1(String str,Predicate<String> pre1,Predicate<String> pre2){
        return pre1.or(pre2).test(str);
    }

    //predicate接口 默认方法 negate 非 取反
    public static boolean no1(String str,Predicate<String> pre1){
        return pre1.negate().test(str);
    }

    //
    public static ArrayList<String> lianxi(String[] array,Predicate<String> pre1,Predicate<String> pre2){
        ArrayList<String> list = new ArrayList<>();
        for(String str : array){
            if(pre1.and(pre2).test(str)){
                list.add(str);
            }
        }
        return list;
    }

    //Function接口 转换 用来根据一个类型的数据得到另一个类型的数据
    //前者为前置条件，后者为后置条件
    //最主要的抽象方法R apply（T t）根据类型T的参数获取类型R的结果
    public static void apply1(String str,Function<String, Integer> fun){
        Integer i = fun.apply(str);
        System.out.println(i);
    }

    //练习
    //将String类型的“123”转换为Integer类型123，然后+10，转换为String类型“133”
    public static void zhuanHuan(String str,Function<String,Integer> fun1,Function<Integer,String> fun2){
        Integer i = fun1.apply(str) + 10;
        System.out.println(i);
        String str2 = fun2.apply(i);
        System.out.println(str2.toString());
    }

    //Function接口实现自定义函数模型拼接
    //字符串截取年龄部分，得到字符串，转换为int类型数字，+100得到结果int数字
    public static void lianXi(String str,Function<String,String> fun1,Function<String,Integer> fun2,Function<Integer,Integer> fun3){
        Integer i =fun1.andThen(fun2).andThen(fun3).apply(str);
        System.out.println(i);
    }
}

package day23;

@FunctionalInterface//检测是否是函数式接口
public interface Function111 {
    //定义一个抽象方法
    public abstract String method01();
}

package day23;

public class shiXian implements Function111 {
    @Override
    public String method01(){
        System.out.println("实现类重写方法。");
        return null;
    }
}