常用的函数式接口——Function接口

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

抽象方法：apply：
Function 接口中最主要的抽象方法为： R apply(T t) ，根据类型T的参数获取类型R的结果。
使用的场景例如：将 String 类型转换为 Integer 类型。

使用示例：

public class Demo01Function {
    /*
        定义一个方法
        方法的参数传递一个字符串类型的整数
        方法的参数传递一个Function接口，泛型使用
        使用Function接口中的方法apply,把字符串类型的整数，转换为Integer类型的整数
    */
    public static void change(String s, Function<String, Integer> fun) {
        //Integer in = fun.apply(s);
        int in = fun.apply(s);//拆箱装箱
        System.out.println(in);
    }

    public static void main(String[] args) {
        //定义一个String类型的整数
        String a = "1234";
        //调用change方法，将String类型的整数转换为Integer类型的整数，使用Lambda接口
       /* change(a, (String str) -> {
            return Integer.parseInt(str);
        });*/

        //优化Lambda
        change(a, str ->Integer.parseInt(str));
    }
}

程序演示：

默认方法：andThen：
Function 接口中有一个默认的 andThen 方法，用来进行组合操作。JDK源代码如：

default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) {
	Objects.requireNonNull(after);
	return (T t) ‐> after.apply(apply(t));
}

该方法同样用于“先做什么，再做什么”的场景，和 Consumer 中的 andThen 差不多：

使用示例：
需求：
把String类型的“123”,转换为Integer类型，把转换后的结果加10
把增加之后的Integer类型的数据，转换为String类型

分析:
转换了两次
第一次是把String类型转换为了Integer类型
所以我们可以使用Function fun1
Integer i = fun1.apply(“123”)+10;
第二次是把Integer类型转换为了String类型
所以我们可以使用Function 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
            一个泛型使用Function
    */
    public static void change(String a, Function<String, Integer> fun1, Function<Integer, String> fun2) {
        String s = fun1.andThen(fun2).apply(a);
        System.out.println(s);
    }

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

程序演示：

练习：自定义函数模型拼接
题目
请使用Function进行函数模型的拼接按照顺序需要执行的多个函数操作为
String str = “刘亦菲,32”;

分析：
1.将字符串截取数字年龄部分，得到字符串；
Function “刘亦菲,32”->“32”
2.将上一步的字符串转换为int类型的数字；
Function “32”->32
3.将上一步的int数字累加100，得到结果int数字
Function 32->132

代码：

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 = "刘亦菲,32";
        //调用change方法，参数传递字符串和3个Lambda表达式
        /*int num = change(str, (String s) -> {
            return s.split(",")[1];
        }, (String s) -> {
            return Integer.parseInt(s);
        }, (Integer i) -> {
            return i + 100;
        });*/

        //优化Lambda
        int num = change(str, s -> s.split(",")[1], s ->Integer.parseInt(s),i-> i + 100);
        System.out.println(num);
    }
}

程序演示：