Java学习与复习笔记--常用函数接口（2）

最新推荐文章于 2022-07-08 13:07:37 发布

gokx

最新推荐文章于 2022-07-08 13:07:37 发布

阅读量121

点赞数

分类专栏： JDK8新特性文章标签： java lambda

本文链接：https://blog.csdn.net/gkx826/article/details/108395455

版权

JDK8新特性专栏收录该内容

4 篇文章 0 订阅

订阅专栏

常用的函数式接口_Consumer接口：

/*
* java.util.function.Consumer<T>接口则正好与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) {
        //调用method方法，传递字符串姓名，方法的另一个参数是Consumer接口，是一个函数式接口，所以可以传递Lambda表达式
        method("赵丽颖",(String name)->{
            //对传递的字符串进行消费
            //消费方式：直接输出字符串
            //System.out.println(name);
            //消费方法：把字符串进行翻转输出
            String reName=new StringBuffer(name).reverse().toString();
            System.out.println(reName);
        });
    }
}

默认方法：andThen：

/*
* Consumer接口的默认方法andThem
* 作用：需要两个Consumer接口，可以吧两个Consumer接口组合在一起，再对数据进行消费
* 例如：
*  Consumer<String> con1
*  Consumer<String> con2
*  String s="Hello";
*  con1.accept(s);
*  con2.accept(s);
*  连接两个Consumer接口 再进行消费
*  con1.andThen(con2).accept(s);//谁写前面，谁先消费
*  */
public class Demo02AndThen {
    //定义一个方法，方法的参数传递一个字符串和两个Consumer接口，Consumer接口的泛型使用字符串
    public static void method(String name, Consumer<String> con1,Consumer<String> con2){
        /*con1.accept(name);
        con2.accept(name);*/
        //使用andThen方法，把两个Consumer接口连接在一起，再消费数据
        con1.andThen(con2).accept(name);//con1连接con2,先执行con1消费数据，再执行con2消费数据
    }

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

练习：格式化打印信息：

/*
* 练习：
*    字符串数组当中存在多条信息，请按照“姓名：XX。性别：XX。”的格式将信息打印出来。
*    要求将打印姓名的动作作为第一个Consumer接口的Lambda实例，
*    将打印性别的动作作为第二个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){
            //使用andThem方法连接两个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];
            System.out.print("姓名:"+name);
        },(message)->{
            //消费方式：对Message进行切割，获取年龄，按照指定的格式输出
            String age = message.split("，")[1];
            System.out.println("。年龄："+age+"。");
        });
    }
}

常用的函数式接口_Predicate接口：

/*
* java.util.function.Predicate<T>接口
* 作用：对某种数据类型的数据进行判断，结果返回一个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="abcdef";
        //调用checkString方法对字符串进行校验，参数传递字符串和Lambda表达式
        /*boolean b=checkString(s,(String str)->{
            //对参数传递的字符串进行判断，判断字符串的长度是否大于5，并把判断的结果返回
            return str.length()>5;
        });*/
        //优化Lambda表达式
        //调用checkString方法对字符串进行校验，参数传递字符串和Lambda表达式
        boolean b=checkString(s,(str)-> str.length()>5);
        System.out.println(b);
    }
}

Predicate接口默认方法：and：

/*
* 逻辑表达式：可以连接多个判断的条件
* &&:与运算符，有false则false
* ||：或运算符，有true则true
* ！：非（取反）运算符：非真则假，非假则真
* 需求：
*   判断一个字符串，有两个判断的条件
*   1.字符串的长度是否大于5
*   2.判断字符串中是否包含a
*  两个条件必须同时满足，我们就可以使用与运算符连接两个条件
*  Predicate接口中有一个方法and，表示并且关系，也可以用于连接两个判断
*  Predicate接口中有一个方法and，表示并且关系，也可以用于连接两个判断条件
*  default Predicate<T> and(Predicate<? super T> other){
*       Objects.requireNonNull(other);
*       return (t)->this.test(t)&&other.test(t);
*   }
*   方法内部的两个判断条件，也是使用&&运算符连接起来的
*  */
public class Demo02Predicate_and {
    /*
    * 定义一个方法，方法的参数，传递一个字符串
    * 传递两个Predicate接口
    *   一个用于判断字符串的长度是否大于5
    *   一个用于判断字符串中是否包含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);//等价于return pre1.test(s) && pre2.test(s);
    }

    public static void main(String[] args) {
        //定义一个字符串
        String s="abcdef";
        //调用checkString方法，参数传递字符串和两个Lambda表达式
        boolean b=checkString(s,(String str)->{
            //判断字符串的长度是否大于5
            return str.length()>5;
        },(String str)->{
            return str.contains("a");
        });
        System.out.println(b);
    }
}

Predicate接口默认方法：or：

/*
 * 需求：
 *   判断一个字符串，有两个判断的条件
 *   1.字符串的长度是否大于5
 *   2.判断字符串中是否包含a
 *  满足一个条件即可，我们就可以使用||运算符连接两个条件
 *  Predicate接口中有一个方法or，表示或者关系，也可以用于连接两个判断
 *  default Predicate<T> and(Predicate<? super T> other){
 *       Objects.requireNonNull(other);
 *       return (t)->this.test(t)||other.test(t);
 *   }
 *   方法内部的两个判断条件，也是使用&&运算符连接起来的
 *   */
public class Demo03Predicate_or {
    /*
     * 定义一个方法，方法的参数，传递一个字符串
     * 传递两个Predicate接口
     *   一个用于判断字符串的长度是否大于5
     *   一个用于判断字符串中是否包含a
     *   满足一个条件即可
     *   */
    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);//等价于//return pre1.test(s) || pre2.test(s);
    }

    public static void main(String[] args) {
        //定义一个字符串
        String s="acdef";
        //调用checkString方法，参数传递字符串和两个Lambda表达式
        boolean b=checkString(s,(String str)->{
            //判断字符串的长度是否大于5
            return str.length()>5;
        },(String str)->{
            return str.contains("a");
        });
        System.out.println(b);
    }
}

Predicate接口默认方法：negate：

/*
* 需求：判断一个字符串的长度是否大于5
*      如果字符串的长度大于5，那返回false
*      如果字符串的长度不大于5，返回true
*   所以我们可以使用取反符号！对判断的结果进行取反
*  Predicate接口中有一个方法negate，也表示取反的意思
*  default Predicate<T> negate(){
*       return (t)->!test(t);
*  }
*  */
public class Demo04Predicate_negate {
    /*
    *定义一个方法，方法的参数，传递一个字符串
    * 使用Predicate接口判断字符串的长度是否大于5
    */
    public static boolean checkString(String s, Predicate<String> pre){
        //return !pre.test(s);
        return pre.negate().test(s);//等效于//return !pre.test(s);
    }

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

Predicate接口练习：

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

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

常用的函数式接口_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));
    }
}

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
*           fun2再调用apply方法，把Integer转换为字符串
* */
public class Demo02Function_andThen {
    /*
    * 定义一个方法
    * 参数传递一个字符串类型的整数
    * 参数再传递两个Function接口
    * 一个泛型使用Function<String,Integer>
    * 一个泛型使用Function<Integer,String>
    *  */
    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)->{
            //把字符串转换为整数加10
            return Integer.parseInt(str)+10;
        },(Integer i)->{
            //把整数转换为字符串
            return i+"";
        });*/
        //优化Lambda表达式
        change(s,str-> Integer.parseInt(str)+10,i-> i+"");
    }
}

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 Demo03FunctionTest {
    /*
    * 定义一个方法
    * 参数传递包含姓名和年龄的字符串
    * 参数再传递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 str="赵丽颖，20";
        //调用change方法，参数传递字符串和3个Lambda表达式
        int num=change(str,(String s)->{
            //"赵丽颖，20"->"20"
            return s.split("，")[1];
        },(String s)->{
            return Integer.parseInt(s);
        },(Integer i)->{
            //20->120
            return i+100;
        });
        System.out.println(num);
    }
}