函数式编程

Posted 2022-12-13 timetellu

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了函数式编程相关的知识，希望对你有一定的参考价值。

第一章函数式接口入门

1.1 概念

　　函数式接口在Java中是指：有且仅有一个抽象方法的接口，适用于函数式编程场景的接口。

　　Java中的函数式编程体现就是Lambda，所以函数式接口就是可以适用于Lambda使用的接口。只有确保接口中有且仅有一个抽象方法，Java中的Lambda才能顺利地进行推导。

1.2 格式

　　只要确保接口中有且仅有一个抽象方法即可：（public abstract可省略）

public interface MyFunctionalInterface 
　　　　void myMethod();

1.3 @FunctionalInterface注解

@FunctionalInterface
public interface MyFunctionalInterface 
    void myMethod();

　　使用该注解来定义接口，编译器将会强制检查该接口是否确实有且仅有一个抽象方法，否则将会报错。需要注意的是，即使不使用该注解，只要满足函数式接口的定义，这仍然是一个函数式接口，使用起来都一样

1.4 体验函数式接口

（1）定义一个函数式接口

/*
    函数式接口:有且只有一个抽象方法的接口,称之为函数式接口
    当然接口中可以包含其他的方法(默认,静态,私有)

    @FunctionalInterface注解
    作用:可以检测接口是否是一个函数式接口
        是:编译成功
        否:编译失败(接口中没有抽象方法或者抽象方法的个数多余1个)
 */
@FunctionalInterface
public interface MyFunctionalInterface 
    //定义一个抽象方法
    public abstract void method();

（2）使用函数式接口编程

/*
    函数式接口的使用:一般可以作为方法的参数和返回值类型
 */
public class Demo 
    //定义一个方法,参数使用函数式接口MyFunctionalInterface
    public static void show(MyFunctionalInterface myInter)
        myInter.method();
    

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

        //调用show方法,方法的参数是一个接口,所以可以传递接口的匿名内部类，重写抽象方法
        show(new MyFunctionalInterface() 
            @Override
            public void method() 
                System.out.println("使用匿名内部类重写接口中的抽象方法");
            
        );

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

        //简化Lambda表达式：
　　　　 //函数体只有一句，可以省略花括号、分号、return
        show(()-> System.out.println("使用Lambda表达式重写接口中的抽象方法"));

第二章函数式编程思想

　　面向对象编程思想：先找到谁来做，怎么做，最后再决定做什么

　　函数式编程思想：不需要管谁来做、怎么做，只需关注做什么就可以了

2.1 Lambda的延迟执行

　　有些场景的代码执行后，结果不一定会被使用，从而造成性能浪费。而Lambda表达式是延迟执行的，这正好可以作为解决方案，提升性能。

（1）性能浪费的日志案例

/*
    日志案例

    发现以下代码存在的一些性能浪费的问题：
    　　调用showLog方法,传递的第二个参数是一个拼接后的字符串：需要先把字符串拼接好,然后再调用showLog方法
    如果showLog方法中如果传递的日志等级不是1级，也会先拼接字符串 -> 再进行判断
    　　所以感觉字符串就白拼接了,存在了浪费
 */
public class Demo01Logger 
    //定义一个根据日志的级别,显示日志信息的方法
    public static void showLog(int level, String message)
        //对日志的等级进行判断,如果是1级别,那么输出日志信息
        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);

（2）使用Lambda延迟执行解决

　　① 先定义一个函数式接口

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

　　② 使用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表达式
　　　　　//lambda表达式是先判断后执行：

        /*
            使用Lambda表达式作为参数传递,仅仅是把参数传递到showLog方法中
            只有满足条件,日志的等级是1级
                才会调用接口MessageBuilder中的方法builderMessage
                才会进行字符串的拼接
            如果条件不满足,日志的等级不是1级
                那么MessageBuilder接口中的方法builderMessage也不会执行
                所以拼接字符串的代码也不会执行
            所以不会存在性能的浪费
         */
        showLog(1,()->
            System.out.println("不满足条件不执行");
            //返回一个拼接好的字符串
            return  msg1+msg2+msg3;
        );

2.2 使用Lambda作为参数和返回值

　　Java中的Lambda表达式可以被当作是匿名内部类的替代品。

　　如果方法的参数是一个函数式接口类型，那么就可以使用Lambda表达式进行替代。

【例1】：作为参数

/*
    java.lang.Runnable接口就是一个函数式接口，直接可以使用
    假设有一个startThread方法使用该接口作为参数，那么就可以使用Lambda进行传参。
    这种情况其实和Thread类的构造方法参数为Runnable没有本质区别。
 */
public class Demo01Runnable 
    //定义一个方法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()+"-->"+"线程启动了");
        );

        //优化Lambda表达式
        startThread(()->System.out.println(Thread.currentThread().getName()+"-->"+"线程启动了"));

【例2】：作为返回值

import java.util.Arrays;
import java.util.Comparator;
/*
    如果一个方法的返回值类型是一个函数式接口，那么就可以直接返回一个Lambda表达式。
    当需要通过一个方法来获取一个java.util.Comparator接口类型的对象作为排序器时,就可以调该方法获取。
 */
public class Demo02Comparator 
    //定义一个方法,方法的返回值类型使用函数式接口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和花括号可以省略）
        return (o1, o2)->o2.length()-o1.length();
    

    public static void main(String[] args) 
        //创建一个字符串数组
        String[] arr = "aaa","b","cccccc","dddddddddddd";
        //输出排序前的数组
        System.out.println(Arrays.toString(arr));//[aaa, b, cccccc, dddddddddddd]
        //调用Arrays中的sort方法（通过实现Comparator接口）,对字符串数组进行排序
        Arrays.sort(arr,getComparator());
        //输出排序后的数组
        System.out.println(Arrays.toString(arr));//[dddddddddddd, cccccc, aaa, b]

第三章常用函数式接口

　　JDK提供了大量常用的函数式接口以丰富Lambda的典型使用场景，它们主要在 java.util.function 包中被提供。下面是常用的几个接口及使用示例。

3.1 Supplier接口 —— 生产型

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

　　由于这是一个函数式接口，这也就意味着对应的Lambda表达式需要“对外提供”一个符合泛型类型的对象数据。

import java.util.function.Supplier;

/*
　　 示例
    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) 
        //调用getString方法,方法的参数Supplier是一个函数式接口,所以可以传递Lambda表达式
        String s = getString(()->
            //生产一个字符串,并返回
            return "胡歌";
        );
        System.out.println(s);

        //优化Lambda表达式
        String s2 = getString(()->"胡歌");
        System.out.println(s2);

import java.util.function.Supplier;

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

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

Supplier练习

3.2 Consumer接口 —— 消费型

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

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

　　Consumer接口的默认方法andThen：可以把两个Consumer接口组合到一起,再对数据进行消费

　（1）accept方法

import java.util.function.Consumer;
/*
   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);
        );

　　(2) andThen方法

import java.util.function.Consumer;

/*
   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.andThen(con2).accept(s);//con1连接con2,先执行con1消费数据,在执行con2消费数据
    
    public static void main(String[] args) 
        //调用method方法,传递一个字符串,两个Lambda表达式
        method("Hello",
                (t)->      //accept(T t):可以用泛型t来指代前边传入的字符串
                    //消费方式:把字符串转换为大写输出
                    System.out.println(t.toUpperCase());
                ,
                (t)->
                    //消费方式:把字符串转换为小写输出
                    System.out.println(t.toLowerCase());
                );

import java.util.function.Consumer;

/*
    练习:
        字符串数组当中存有多条信息，请按照格式“姓名：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+"。");
        );

Consumer练习

3.3 Predicate接口 —— 判断型

　　有时候我们需要对某种类型的数据进行判断，从而得到一个boolean值结果。这时可以使用java.util.function.Predicate<T> 接口。

boolean test(T t）：用来对指定数据类型数据进行判断的方法
Predicate接口中有一个方法and：表示并且关系,也可以用于连接两个判断条件
Predicate接口中有一个方法or,表示或者关系,也可以用于连接两个判断条件
Predicate接口中有一个方法negate,也表示取反的意思

　　（1）test方法

import java.util.function.Predicate;

/*
    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);

逻辑表达式: 可以连接多个判断的条件

　&&: 与运算符,有false则false
　||: 或运算符,有true则true
　! : 非(取反)运算符,非真则假,非假则真

　　（2）and方法

import java.util.function.Predicate;

/*
    需求:判断一个字符串,有两个判断的条件
        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);

　　（3）or方法

import java.util.function.Predicate;

/*
     需求:判断一个字符串,有两个判断的条件
        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);

　　（4）negate方法

import java.util.function.Predicate;

/*
    需求:判断一个字符串长度是否大于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);

import java.util.ArrayList;
import java.util.function.Predicate;

/*
    练习：集合信息筛选
    数组当中有多条“姓名+性别”的信息如下，
    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);

Predicate练习

3.4 Function接口 —— 转换型

　　 java.util.function.Function<T,R> 接口用来根据一个类型的数据得到另一个类型的数据，前者称为前置条件，后者称为后置条件。

　抽象方法 R apply(T t)：根据类型T的参数获取类型R的结果。
　默认方法andThen: 用来进行组合操作

　　（1）apply方法

import java.util.function.Function;
/*
    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));

　　（2）andThen方法

import java.util.function.Function;

/*
    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+"");

import java.util.function.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 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);

Function练习

以上是关于函数式编程的主要内容，如果未能解决你的问题，请参考以下文章

前端学习之函数式编程—函数式编程概念+头等函数

函数式编程

第一章 函数式接口入门

1.1 概念

1.2 格式

1.3 @FunctionalInterface注解

1.4 体验函数式接口

（1）定义一个函数式接口

（2）使用函数式接口编程

第二章 函数式编程思想

2.1 Lambda的延迟执行

（1）性能浪费的日志案例

（2）使用Lambda延迟执行解决

① 先定义一个函数式接口

② 使用lambda

2.2 使用Lambda作为参数和返回值

【例1】：作为参数

【例2】：作为返回值

第三章 常用函数式接口

3.1 Supplier接口 —— 生产型

3.2 Consumer接口 —— 消费型

（1）accept方法

(2) andThen方法

3.3 Predicate接口 —— 判断型

（1）test方法

（2）and方法

（3）or方法

（4）negate方法

3.4 Function接口 —— 转换型

（1）apply方法

（2）andThen方法

第一章函数式接口入门

第二章函数式编程思想

　　① 先定义一个函数式接口

　　② 使用lambda

第三章常用函数式接口

　（1）accept方法

　　(2) andThen方法

　　（1）test方法

　　（2）and方法

　　（3）or方法

　　（4）negate方法

　　（1）apply方法

　　（2）andThen方法