Java学习 第三十章 函数式接口 /常用的函数式接口 Supplier接口、Consumer接口、Predicate接口、Function接口 /

第三十章

一、函数式接口

1.1 概念

函数式接口：有且仅有一个抽象方法的接口

1.2 函数式接口的定义

@FunctionalInterface //检查是否是函数式接口

/*
    函数式接口：有且仅有一个抽象方法的接口，成为函数式接口
    当然接口中可以包含其他的方法（默认、静态、私有）
 */
@FunctionalInterface //检查是否是函数式接口
public interface MyFunctionalInterface {
    //定义一个抽象方法
    public abstract  void mehtod();

}

1.3 函数式接口的使用

/*
    函数式接口的使用：一般可以作为方法的参数和返回值使用
 */
public class Demo {
    //定义一个方法，参数使用函数式接口MyFunctionalInterface
    public static void show(MyFunctionalInterface myInter){

    }

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

        //调用show方法，方法的参数是一个接口，所以可以传递接口匿名内部类
        show(new MyFunctionalInterface() {
            @Override
            public void mehtod() {

            }
        });

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

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


    }

}

1.4 性能浪费的日志案例

/*
    日志案例：
    发现以下代码存在的一些性能浪费的问题
    调用showLog方法，传递的第二个参数是一个拼接后的字符串
    先把字符串拼接好，然后在调用showLog方法
    showLog方法中如果传递的日志等级不是1级
    那么就不会如此拼接的字符串
    所以感觉字符产就白拼接了，存在了浪费
 */
public class Demo01Logger {
    //定义一个根据日志的级别，显示日志信息的方法
    public static  void  showLog(int level, String message){
        if(level==1){
            System.out.println(message);
        }

    }
    public static void main (String[] args){
        //定义三个日志信息
        String msg1 = "Hello";
        String msg2 ="World";
        String msg3 = "Java";

        //调用showLog方法，传递日志级别和日志信息
        showLog(2,msg1+msg2+msg3);
    }
}

1.5 使用Lambda优化日志案例

/*
    使用Lambda优化日志案例
    Lambda的特点：延迟加载
    Lambda的使用前提，必须存在函数式接口
 */
public class Demo02Lambda {
    //定义一个显示日志的方法,方法的参数传递日志的等级和MessageBuilder接口
    public static void showLog(int level,MessageBuilder mb){
        //对日志的等级进行判断，如果是1级，则调用MessageBuilder接口中的builderMessage方法
        if (level ==1){
            System.out.println(mb.builderMessage());
        }
    }
    public static void main(String[] args){
        String msg1 = "hello";
        String msg2 = "world";
        String msg3 = "Java";
        //调用showLog方法，参数MessageBuilder是一个函数式接口，所以可以传递Lambda表达式
        showLog(2,()->{
            return msg1 + msg2 + msg3;
        });
        /*
        使用Lambda表达式作为参数传递，仅仅是把参数传递到showLog中
        只有满足条件，日志的等级是1级
         才会调用接口MessageBuilder中的方法builderMessage
         才会进行字符串的拼接
        如果条件不满足，日志的等级不是1级
            那么MessageBuilder接口中的方法builderMessage也不会执行
            所以拼接字符串的代码也不会执行
         所以不会存在性能的浪费
         */
    }

}

@FunctionalInterface
public interface MessageBuilder {
    //定义一个拼接消息的抽象方法，返回被拼接的消息
    public abstract String builderMessage();
}

1.6 函数式接口作为方法的参数案例

方法的参数是函数式接口，且只有一个抽象方法，那么可以传递Lambda表达式

/*
    例如java.Runnable接口就是一个函数式接口
    假设有一个startThread方法使用该接口作为参数，那么就可以使用Lambda进行传参
    这种情况其实和Thread类的构造方法参数为Runnable没有本质区别
 */
public class Demo03Runnable {
    //定义一个方法startThread，方法的参数使用函数式接口Runnable
    public static void startThread(Runnable run){
        //开启多线程
        new Thread(run).start();
    }

    public static void main(String[] args) {
        //调用StartThread方法，方法的参数是一个接口，那么我们可以传递这个接口的匿名内部类
        startThread(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"->"+"线程启动了");
            }
        });

        //调用StartThread方法，方法的参数是一个接口，所以可以传递Lambda表达式
        startThread(()->{
            System.out.println(Thread.currentThread().getName()+"->"+"线程启动了");
        });
        
        //优化
        startThread(()->  System.out.println(Thread.currentThread().getName()+"->"+"线程启动了"));
          
     
    }

}

1.7 函数式接口作为方法的返回值类型案例

/*
    如果一个方法的返回值类型是一个函数式接口，那么就可以直接返回一个Lambda表达式
    当需要通过一个方法来获取一个java.util.Comparator接口类型的对象作为排序器时，就可以
    调用该方法获取。
 */
public class Demo04Comparator {
    //返回值类型为函数式接口的Comparator
    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();
    }

    public static void main(String[] args) {
        //创建一个字符串数组
        String[] arr = {"aaaa","b","ccccc","ddddddd"};
        //输出排序前的数组
        System.out.println(Arrays.toString(arr));//[aaaa, b, ccccc, ddddddd]
        //调用Arrays中的sort方法，对字符串数组进行排序
        Arrays.sort(arr,getComparator());
        //输出排序后的数组
        System.out.println(Arrays.toString(arr));//[ddddddd, ccccc, aaaa, b]
    }
}

二、常用的函数式接口

2.1 Supplier接口

/*
    常用的函数式接口
    java.util.function.Supplier<T>接口仅包含一个无参的方法： T get().用来获取一个泛型参数指定类型的对象数据

    Supplier<T>接口被称之为生产型接口，指定接口的泛型是什么类型，那么接口中的get方法就会产生什么类型的数据
 */
public class Demo01Supplier {
    //方法的参数传递Supplier<T>接口，泛型执行String，get方法，就会返回一个String
    public static String getString(Supplier<String> sup){
        return sup.get();
    }

    public static void main(String[] args){
        //调用String方法，方法的参数Supplier是一个函数式接口，所以可以传递Lambda表达式
        String s = getString(()->{
            //生产一个字符串并返回
            return "胡歌";

        });
        System.out.println(s);

        //优化
        String s1 = getString(()->  "胡歌"    );




    }
}

2.2 练习：求数组元素的最大值

/*
    使用Supplier接口作为方法的参数类型，通过Lambda表达式求出数组的最大值
    提示：接口的泛型请使用java.lang.Integer类
 */
public class Demo02 {
    //定义一个方法，用于获取int类型的数组中元素的最大值，方法的参数传递Suppiler接口，泛型使用Integer
    public static int getMax(Supplier<Integer> sup){
        return sup.get();

    }

    public static void main(String[] args) {
        //定义一个int类型的数组并赋值
        int[] arr = {100,0,-50,80,99,33,-30};
        //调用getMax方法，方法的参数Supplier是一个函数式接口，所以可以传递Lambda表达式
       int maxValue = getMax(()->{
            //获取数组的最大值并返回
            //定义一个变量，把数组中的第一个元素赋值给该变量，记录数组中元素的最大值
            int max = 0;
            //遍历数组
            for (int i : arr) {
                //使用其他元素和最大值比较
                if (i > max){
                    max = i;
                }
            }
            //返回最大值
            return max;
        });
        System.out.println("数组中元素的最大值是："+maxValue);
    }
}

2.3 常用的函数式接口–Consumer接口

java.util.function.Consumer接口正好与Supplier接口相反，它不是生产一个数据，而是消费一个数据，其数据类型由泛型决定

/*
    Consumer接口包含抽象方法void accept(T t),意为消费一个指定泛型的数据。

    Consumer接口是一个消费型接口，泛型执行什么类型，就可以使用accept方法消费什么类型的数据
    至于具体怎么消费(使用)，需要自定义(输出，计算...)
 */
public class Demo01Consumer {
    /*
     定义一个方法
     方法的参数传递一个字符串的姓名
     方法的参数传递Consumer接口，泛型使用String
     可以使用Consumer接口消费字符串的姓名
     */
    public static void method(String name, Consumer<String> con){
        con.accept(name);
    }

    public static void main(String[] args) {
        //调用方法，传递字符串姓名，方法的另一个参数是Consumer接口，是一个函数式接口，所以可以传递Lambda表达式
        method("赵丽颖",(String name)->{
            //对传递的字符串进行消费
            //消费方法：直接输出字符串
           // System.out.println(name);

            //消费方式：把字符串进行反转输出
            String reName = new StringBuffer(name).reverse().toString();
            System.out.println(reName);
        });
    }
}

2.4 常用的函数式接口–Consumer接口中的默认方法 andThen

Consumer方法andThen

作用： 需要两个consumer接口，可以把两个Consumer接口组合到一起，对数据进行消费

例如：
Consumer<String> con1
Consumer<String> con2
con1.accept(s);
con2.accept(s);

连接两个consumer接口
con1.andThen(con2).accept(s);谁先写前边谁先消费

/*


 */
public class Demo02AndThen {
    //定义一个方法，方法的参数传递一个字符串和两个Consumer接口，Consumer接口的泛型使用字符串
    public static void method(String s, Consumer<String> con1,Consumer<String> con2){
      /*  con1.accept(s);
        con2.accept(s);*/
      //把两个Consumer接口组合到一起，对数据进行消费
      con1.andThen(con2).accept(s);
    }

    public static void main(String[] args) {
        //调用method方法，传递一个字符串，两个Lambda表达式
        method("hello",(t)->{
            //消费方式：把字符转换为大写输出
                    System.out.println(t.toUpperCase());

                }, (t)->{
            //消费方式：把字符转换为小写输出
            System.out.println(t.toLowerCase());

        });
    }
}

2.5 练习：格式化打印信息

/*
    练习：
        字符串数组当中存有多条信息，请按照格式：姓名：xx。性别：xx的格式将信息打印出来
        要求将打印性别的动作作为第二个Consumer接口的Lambda实力
        两个Consumer接口按照顺序拼接到一起
 */
public class Demo03Test {
    //定义一个方法，参数传递String类型的数组和两个Consumer接口，泛型使用String
    public static void printInfo(String[] arr, Consumer<String> con1,Consumer<String> con2){
        //遍历字符串数组
        for (String message : arr) {
            //使用andThen方法连接两个Consumer接口，消费字符串
            con1.andThen(con2).accept(message);
        }

    }
    public static void main(String[] args) {
        //定义一个字符串类型的数组
        String[] arr = {"迪丽热巴，女","古力娜扎，女","马儿扎哈，男"};
        //调用printInfo方法，传递一个字符串数组和两个Lambda表达式
        printInfo(arr,(message)->{
            //消费方式：对message进行切割，获取姓名，按照指定的格式输出
            String name  = message.split("，")[0];// message.split("，")返回的是一个数组
            System.out.print("姓名："+ name);
        },(message)->{
            //消费方式：对message进行切割，获取姓名，按照指定的格式输出
            String sex  = message.split("，")[1];// message.split("，")返回的是一个数组
            System.out.println("。性别："+ sex +"。");

        });


    }
}

2.6 常用的函数式接口–Predicate接口

java.util.function.Predicate接口

作用：对某种数据类型的数据进行判单，结果返回一个boolean值

Predicate接口中包含一个抽象方法：
    boolean test（T t）：用来对指定数据类型进行判断的方法
        结果：
            符合条件，返回true
            不符合条件，返回false

public class Demo01Predicate {
    /*
        定义一个方法：
        参数传递一个String类型的字符串
        传递一个Predicate接口，泛型使用String
        使用Predicate中的方法test对字符串进行判断，并把判断的结果返回
     */
    public static boolean checkString(String s, Predicate<String> pre){
        return pre.test(s);
    }

    public static void main(String[] args) {
        //定义一个字符串
        String s = "abcde";
        //调用checkString方法对字符串进行校验，参数传递字符串和Lambda表达式
      /* boolean b =  checkString(s,(String str)->{
           //对参数传递的字符串进行判断，判断字符串的长度是否大于5，并把判断的结果返回
           return str.length()>5;
        });*/

       //优化Lambda表达式 //对参数传递的字符串进行判断，判断字符串的长度是否大于5，并把判断的结果返回
        boolean b =  checkString(s, str->str.length()>5 );
           
           
     
        System.out.println(b);
    }
}

2.7 常用的函数式接口–Predicate接口中的默认方法 and

/*
    需求：判断一个字符串
        1.长度是否大于5
        2.是否包含a
        同时满足用&&
     Predicate接口中有一个方法and，表示并且关系，也可以用于连接两个判断条件
     方法内部的两个判断条件也是&&连接的
 */
public class Demo02PredicateAnd {
    /*
        定义一个方法，参数传递一个字符串两个Predicate接口
        1.长度是否大于5
        2.是否包含a
        同时满足用&&
     */
    public static boolean checkString(String s, Predicate<String> pre1,Predicate<String> pre2){
        //return pre1.test(s) && pre2.test(s);
        return pre1.and(pre2).test(s);

    }

    public static void main(String[] args) {
        //定义一个字符串
        String s = "abcde";
        boolean b =checkString(s,(String str)->{
            return  str.length()>5;
        },(String str)->{
            return  str.contains("a");
        });
        System.out.println(b);
    }
}

2.8 常用的函数式接口–Predicate接口中的默认方法 or & negate(取反/非)

/*
    Predicate接口中有一个方法or，表示或者关系，也可以用于连接两个判断条件
 */
public class Demo03Or {
        /*
            定义一个方法，参数传递一个字符串两个Predicate接口
            1.长度是否大于5
            2.是否包含a
            满足一个用 or ||
         */
        public static boolean checkString(String s, Predicate<String> pre1, Predicate<String> pre2){
            //return pre1.test(s) || pre2.test(s);
            return pre1.or(pre2).test(s);

        }

        public static void main(String[] args) {
            //定义一个字符串
            String s = "abcde";
            boolean b =checkString(s,(String str)->{
                return  str.length()>5;
            },(String str)->{
                return  str.contains("a");
            });
            System.out.println(b);//true 满足一个就行
        }
    }

/*
    需求：判断一个字符串
        长度是大于5 false    不大于5 false
        所以哦我们可以使用！取反符合 对判断的结果进行取反

 */
public class Demo02PredicateNegate {
    /*
        定义一个方法，参数传递一个字符串，使用Predicate接口判断字符串长度是否大于5

     */
    public static boolean checkString(String s, Predicate<String> pre1){
       // return !pre1.test(s);
        return pre1.negate().test(s);//等效于return !pre1.test(s);

    }

    public static void main(String[] args) {
        //定义一个字符串
        String s = "abcde";
        //调用checkString方法，参数传递字符串和Lambda表达式
        boolean b = checkString(s,(String str)->{
            return str.length()>5;
        });
        System.out.println(b);

    }

}

2.9 集合信息筛选

/*
   String[] array = {"迪丽热巴，女","古力娜扎，女","马儿扎哈，男","赵丽颖",女};
   请通过Predicate接口的拼装将符合要求的字符串筛选到集合ArrayList中
   需要同时满足两个条件：
        1.必须为女生
        2.姓名为4个字
 */
public class Demo04Test {
    /*
     定义一个方法
     方法的参数传递一个包含人员信息的数组
     传递两个Predicate接口用于对数组中的信息进行过滤
     把满足条件的信息存到ArrayList集合中并返回
     */
    public static ArrayList<String> filter(String[] arr, Predicate<String> pre1,Predicate<String> pre2){
        //定义一个ArrayList接口存储过滤之后的信息
        ArrayList<String> list = new ArrayList<>();
        //遍历数组，获取数组中的每一条信息
        for (String s:arr){
            //使用Predicate接口中的方法test对获取到的字符串进行判断
            boolean b = pre1.and(pre2).test(s);
            //对得到的布尔值进行判断
            if (b){
                //条件成立，两个条件都满足，把信息存储到ArrayList集合中
                list.add(s);
            }

        }
        return list;
    }

    public static void main(String[] args) {
        //定义一个数组
        String[] array = {"迪丽热巴，女","古力娜扎，女","马儿扎哈，男","赵丽颖，女"};
        //调用filter方法，传递字符串数组和两个Lambda表达式
        ArrayList<String> list = filter(array,(String s)->{
            //获取字符串中的性别，判断是否为女
            return s.split("，")[1].equals("女");
        },(String s)->{
            //获取字符串中的名字，判断长度是否为4个字符
            return  s.split("，")[0].length()==4;

        });
        //遍历集合
        for (String s : list) {
            System.out.println(s);
        }

    }
}

2.10 常用的函数式接口–Function接口

/*
    java.util.function.Function<T,R>接口用来根据一个类型的数据得到另一个类型的数据。
        前者称为前置条件，后者称为后置条件
        Function接口中最主要的抽象方法为：R apply(T t),根据类型T的参数获取类型R的结果
         使用场景：将String类型转换为Integer类型
 */
public class Demo01Function {
    /*
    定义一个方法
    方法的参数传递一个字符串类型的整数
    方法的参数传递一个Function接口，泛型使用<String,Integer>
    使用Function接口中的方法apply，把字符串类型的整数，转换为Integer类型的整数

     */
    public static void change(String s , Function<String , Integer> fun){
      //  Integer in = fun.apply(s);
        int in =fun.apply(s);//自动拆箱 Integer->int
        System.out.println(in);
    }

    public static void main(String[] args) {
        //定义一个字符串类型的整数
        String s = "1234";
        //调用change方法，传递字符串类型的整数和Lambda表达式
       /* change(s,(String str)->{
            //把字符串类型的整数转换为Integer类型的整数返回
            return Integer.parseInt(str);
        });
*/
        //优化Lambda
        change(s,str->Integer.parseInt(str) );
            //把字符串类型的整数转换为Integer类型的整数返回



    }
}

2.11 常用的函数式接口–Function接口的默认方法andThen

/*
    Function接口中的默认方法andThen：用来进行组合操作
    需求：
        把String类型的“123”，转换为Integer类型，把转换后的结果加10
        把增加后的Integer类型转换为String类型
    分析：
        第一次把String转换为Integer类型
              可以用Function<String,Integer> fun1
              Integer i = fun1.apply("123")+10;
        第二次是吧Integer类型抓换位String类型
                可以用Function<Integer,String> fun2
              String s = fun2.apply(i);
        使用andThen方法，把两次转换组合在一起使用
          String s = fun1.andThen(fun2).apply("123");
          fun1先调用apply方法，把字符串转换为Integer
 */
public class Demo02FunctionAndThen {
    /*
       参数传递一个字符串，两个Function接口
     */
    public  static void change(String s, Function<String,Integer> fun1,Function<Integer,String> fun2){
        String ss = fun1.andThen(fun2).apply(s);
        System.out.println(ss);

    }

    public static void main(String[] args) {
        //定义一个字符串类型的整数
        String s= "123";
        //调用change方法,传递字符串和两个Lambda表达式
       /* change(s,(String str)->{
            //把字符串转换为整数
            return Integer.parseInt(str)+10;
        },(Integer i)->{
            //把整数转换为字符串
            return i + "";

        });*/
       //优化Lambda
        change(s,str->  Integer.parseInt(str)+10, i-> i + "");
        
    }

}

2.12 Function接口练习：自定义函数模型拼接

/*
 练习：自定义函数模型拼接
 题目：
    请使用Function进行函数模型的拼接，按照顺序需要执行的多个函数操作为：
        String str = "赵丽颖，20";
   分析：
    1.将字符串截取数字年龄部分，得到字符串；
    Function<String,String> "赵丽颖，20" -> "20"
    2.将上一步的字符串转换为int类型的数字
    Function<String , Integer> "20"->20
    3.将上一步的int数字加100，得到int数字
     Function<Integer , Integer> 20->120
 */
public class Demo03Test {
    /*
        参数传递 包含姓名和年龄的字符串
        再传递3个Function接口用于类型转换
     */
    public static int change(String s, Function<String,String> fun1,Function<String,Integer> fun2,
                             Function<Integer,Integer> fun3){
       //使用andThen将三个转换组合到一起
        return fun1.andThen(fun2).andThen(fun3).apply(s);
    }

    public static void main(String[] args) {
        String s = "赵丽颖，20";
        //调用change方法，参数传递字符串和三个Lambda表达式
        int in = change(s,(String str)->{
            return str.split("，")[1];
        },(String str)->{
            return Integer.parseInt(str);

        },(Integer i)->{
            return i+100;
        });
        System.out.println(in);

    }
}