函数式编程

最新推荐文章于 2023-09-15 17:03:28 发布
最新推荐文章于 2023-09-15 17:03:28 发布
阅读量186 收藏
点赞数
分类专栏： # 4.java基础知识
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/u014736082/article/details/88677327
版权

Consumer接口

ava.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接口的默认方法andThen
作用:需要两个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 s, Consumer<String> con1 ,Consumer<String> con2){
       //con1.accept(s);
       //con2.accept(s);
       //使用andThen方法,把两个Consumer接口连接到一起,在消费数据
       con1.andThen(con2).accept(s);//con1连接con2,先执行con1消费数据,在执行con2消费数据
   }

   public static void main(String[] args) {
       //调用method方法,传递一个字符串,两个Lambda表达式
       method("Hello",
               (t)->{
                   //消费方式:把字符串转换为大写输出
                   System.out.println(t.toUpperCase());
               },
               (t)->{
                   //消费方式:把字符串转换为小写输出
                   System.out.println(t.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) {
            //使用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];
            System.out.print("姓名: "+name);
        },(message)->{
            //消费方式:对message进行切割,获取年龄,按照指定的格式输出
            String age = message.split(",")[1];
            System.out.println("。年龄: "+age+"。");
        });


    }

}

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 = "abcdef";

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

        //优化Lambda表达式
        boolean b = checkString(s,str->str.length()>5);
        System.out.println(b);
    }
}

一、and方法

逻辑表达式:可以连接多个判断的条件
&&:与运算符,有false则false
||:或运算符,有true则true
!:非(取反)运算符,非真则假,非假则真

**需求:**判断一个字符串,有两个判断的条件
​ 1.判断字符串的长度是否大于5
​ 2.判断字符串中是否包含a
两个条件必须同时满足,我们就可以使用&&运算符连接两个条件

//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)->{
            //判断字符串中是否包含a
            return str.contains("a");
        });
        System.out.println(b);
    }
}

二、or方法

**需求:**判断一个字符串,有两个判断的条件
​ 1.判断字符串的长度是否大于5
​ 2.判断字符串中是否包含a
​ 满足一个条件即可,我们就可以使用||运算符连接两个条件

Predicate接口中有一个方法or,表示或者关系,也可以用于连接两个判断条件
default Predicate<T> or(Predicate<? super T> other) {
    Objects.requireNonNull(other);
    return (t) -> 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 = "bc";
        //调用checkString方法,参数传递字符串和两个Lambda表达式
        boolean b = checkString(s,(String str)->{
            //判断字符串的长度是否大于5
            return str.length()>5;
        },(String str)->{
            //判断字符串中是否包含a
            return str.contains("a");
        });
        System.out.println(b);
    }
}

四、取反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);
    }
}

五、练习集合信息筛选

​ 数组当中有多条“姓名+性别”的信息如下，
​ String[] array = { “迪丽热巴,女”, “古力娜扎,女”, “马尔扎哈,男”, “赵丽颖,女” };
​ 请通过Predicate接口的拼装将符合要求的字符串筛选到集合ArrayList中，
​ 需要同时满足两个条件：
​ 1. 必须为女生；
​ 2. 姓名为4个字。
分析:
​ 1.有两个判断条件,所以需要使用两个Predicate接口,对条件进行判断
​ 2.必须同时满足两个条件,所以可以使用and方法连接两个判断条件

public class Demo05Test {
    /*
        定义一个方法
        方法的参数传递一个包含人员信息的数组
        传递两个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);
        }
    }
}

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));
    }
}

一、andThen

Function接口中的默认方法andThen用来进行组合操作。

需求:
​ 把String类型的"123",转换为Inteter类型,把转换后的结果加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进行函数模型的拼接，按照顺序需要执行的多个函数操作为：
    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 str = "赵丽颖,20";
        //调用change方法,参数传递字符串和3个Lambda表达式
        int num = change(str,(String s)->{
            //"赵丽颖,20"->"20"
           return s.split(",")[1];
        },(String s)->{
            //"20"->20
            return Integer.parseInt(s);
        },(Integer i)->{
            //20->120
            return i+100;
        });
        System.out.println(num);
    }
}
函数式编程(functional programming)学习总结
BananaTree
12-27 2618
梳理一下函数式编程中的各个概念，会不定期更新。大部分是转载别人的文章，加一些感想，所以也不能算作原创。之所以会写这个是看到了分享的一个ppt： https://docs.google.com/presentation/d/1SwrUqNVVsHxmwmnT7QYsnf3b7gDi9lTZRD-4-wPLA28/edit#slide=id.p，我以前也接触过FP，但很少实际写，用FP比如scala写
函数式接口与Lambda表达式
guqing's blog
07-22 271
概念 函数式接口在Java中是指：有且仅有一个抽象方法的接口。 函数式接口，即适用于函数式变成场景的接口。而Java中函数式变成体现就是Lambda,所以函数式接口就是适用于Lambda使用的接口。只有确保接口中有且仅有一个抽象方法，Java中的Lambda才能被顺利的进行推导。 语法糖是指使用更加方便，但是原理不变的代码语法。例如在遍历集合时使用的forEach语法，其实底层实现原理仍然是迭代...
函数式编程总结
lf2048372的博客
06-21 387
Java函数式编程（一函数式编程入门什么是函数式编程功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 函数式编程入门 本文为理解函数式编程相关概念，以及java函数试编程的入门概念及应用。 什么是函数式编程 function可以翻译
函数式编程学习之路(四)
aibo110110的博客
04-14 169
知识点理解一: 函数: 函数（function）表示每个输入值对应唯一输出值的一种对应关系。函数f中对应输入值的输出值x的标准符号为f(x)。包含某个函数所有的输入值的集合被称作这个函数的定义域，包含所有的输出值的集合被称作值域。若先定义映射的概念，可以简单定义函数为，定义在非空数集之间的映射称为函数。 高阶函数: 在数学和计算机科学中，高阶函数是至少满足下列一个条件的函数: ...
java.util.function 中的 Function、Predicate、Consumer
weixin_34015860的博客
08-21 268
函数式接口： 函数式接口（Functional Interface）就是一个有且仅有一个抽象方法，但可以有多个非抽象方法的接口。 函数式接口可以被隐式转换为 Lambda 表达式。 Function 函数 Function 与 BiFunction 输入一个或多个参数，也可以规定返回值类型，并执行一段逻辑 Function&lt;Integer, Integer&gt; fun...
java.util.function_Java 8 java.util.function.Function示例
u011250186的博客
09-15 399
java.util.function_Java 8 java.util.function.Function示例
函数式编程思维.pdf_函数式编程_函数式编程思维_
10-03
函数式编程是一种编程范式，它强调将计算视为数学函数的评估，并避免可变状态和副作用。这种编程风格鼓励使用纯函数，即那些输入相同输出始终一致且不改变外部状态的函数。函数式编程有着深厚的理论基础，源于λ演算...
Java-Java函数式编程教程
11-14
Java函数式编程是一种编程范式，它强调使用函数作为程序的基本构建块，将计算视为函数的组合，并且尽可能避免改变状态和可变数据。在Java 8及更高版本中，函数式编程得到了官方的大力支持，引入了Lambda表达式、...
黑马程序员Java函数式编程全套视频教程，Lambda表达式、Stream流、函数式编程一套全通关1
最新发布
05-16
Java函数式编程是一种高效、简洁的编程范式，它在Java 8中得到了全面支持，大大改变了Java开发人员编写代码的方式。本套黑马程序员的Java函数式编程视频教程涵盖了Lambda表达式、Stream流以及函数式编程的核心概念，...
Python函数式编程（第2版）1
08-03
《Python函数式编程（第2版）》是一本面向Python开发者深入探讨函数式编程的书籍。函数式编程是一种编程范式，它强调使用函数作为基本的构建块，以减少副作用和状态变化，从而提高代码的可读性和可维护性。Python虽...
Python函数式编程实例详解
12-23
本文实例讲述了Python函数式编程。分享给大家供大家参考，具体如下： 函数式编程就是一种抽象程度很高的编程范式，从计算机硬件->汇编语言->C语言->Python抽象程度越高、越贴近于计算，但执行效率也越低。纯粹的函数...
JAVA8的java.util.function包
小花生编程
03-10 420
一 概述 name type description Consumer Consumer< T > 接收T对象，不返回值 Predicate Predicate< T > 接收T对象并返回boolean Function Function< T, R > 接收T对象，返回R对象 Supplier ...
Java——函数式接口(java.util.function)
少歌的博客
11-22 7326
定义 一个接口里有且仅有一个抽象方法，但是可以有多个非抽象方法，这样的接口称之为——函数式接口 引入 常见的函数式接口：Runnable 只有一个抽象方法——run(); 四大基本函数式接口 是 java.util.function 包下最基本的四个函数式接口。 Function Function 接口的 apply 方法，就是让你传入一个参数，返回一个值。 并且在泛型中体现了 传入 和 返回 的参数类型。 实例： import java.util.function.Function;
关于函数式编程的思考（1）
weixin_33738982的博客
08-25 153
作者：李英杰，美团金融前端团队成员。欢迎大家一起来探讨FP 题外话：只是单纯地谈谈个人对函数式编程的理解，欢迎大家来一起探讨。也不会提及高阶函数与范畴学的内容，只聊一些很入门的问题。函数式编程的优点这里也不做过多说明，会推荐大家看几篇文章，里面有很好的阐述。 斜体灰字部分是一些个人的吐槽和私货 目录 为什么函数式编程在前端复兴？ 什么是函数式编程？ 函数式编程如何思考问题？ 函数式编程...
2021-06-14 java.util.function.Consumer简单用法
xuyuchen928的博客
06-14 1634
public class ConsumerSample { public static void main(String[] args) { outPut(s-> System.out.println("向控制台打印:山东菏泽曹县" + s)); outPut(s -> { System.out.println("向XXX网站打印:山东菏泽曹县" + s); }); } public static .
java.util.function包
demon7552003的小本本
06-18 732
目录 Supplier 参数个数扩展 参数类型扩展 特殊变形 Function,r> 参数个数扩展 参数类型扩展 特殊变形 Consumer 参数个数扩展 参数类型扩展 特殊变形 Predicate 参数个数扩展 参数类型扩展 特殊变形 java.util.function包下主要为函数接口，主要包含4类函数接口： Supplier<T>: 数...
java中function_java.util.function.Function的用法
weixin_39905624的博客
02-18 612
JDK 1.8 API包含了很多内建的函数式接口，在老Java中常用到的比如Comparator或者Runnable接口，这些接口都增加了@FunctionalInterface注解以便能用在lambda上。现如今，我们则从Function常用函数入口，真正了解一下。nametypedescriptionConsumerConsumer< T >接收T对象，不返回值PredicateP...
常用函数接口
LZ804526270的博客
03-25 666
函数式接口：有且只有一个抽象方法的接口称之为函数式接口 当然接口中可以包含其他的方法（默认，静态，私有） @FunctionalInterface注解 作用：可以检测接口是否是一个函数式接口 是：编译成功 否：编译失败（接口中没有抽象方法或者抽象方法的个数多余一个） 函数式接口的使用：一般可以作为方法的参数和返回值类型 创建一个main方法类： public class demo01 {//定义一个方法，参数使用函数式接口MyFunctionalInterface public static voi
java consumer 使用_java.util.function.Consumer的用法
weixin_36402316的博客
02-28 1064
Consumer类包含两个方法，一个accept方法用来对输入的参数进行自定义操作，因为是个抽象方法，所以需要实例化对象的时候进行Override，另一个andThen方法跟Function的方法一样是一个default方法，已经有内部实现所以不需要用户重写，并且具体功能也跟Function差不多。Consumer的中文意思是消费者，意即通过传递进一个参数来对参数进行操作。例：class Foo ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值