常用函数式接口_Function

1.Function<T,R>接口

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

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

package com.FunctionalInterface.Function;

import java.util.function.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){
        int in = fun.apply(s); //自动拆箱 Integer-->int
        System.out.println(in);
    }

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

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

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

2.1需求：

• 把String类型的"123"，转换为Integer类型，把转换后的结果加10
  把增加之后的Integer类型的数据，转换为String类型

2.2 分析：转换了两次

• 第一次把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转换为字符串

package com.FunctionalInterface.Function;

import java.util.function.Function;

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

3.练习：自定义函数模型拼接

3.1题目

• 请使用Function进行函数模型的拼接，按照顺序需要执行的多个函数操作为：
  String str = “赵丽颖,20”;

3.1 分析：

• 1.将字符串截取数字年龄部分，得到字符串；
  Function<String,String> “赵丽颖,22”->“22”

• 2.将上一步的字符串转换称为int类型的数字
  Function<String,Integer> “22”->22

• 3.将上一步的int数字累加100,得到结果int数字。
  Function<Integer,Integer> 22->122

package com.FunctionalInterface.Function;

import java.util.function.Function;

/*
     练习：自定义函数模型拼接
     题目
     请使用Function进行函数模型的拼接，按照顺序需要执行的多个函数操作为：
         String str = "赵丽颖,20";

     分析：
     1.将字符串截取数字年龄部分，得到字符串；
           Function<String,String> "赵丽颖,22"->"22"
     2.将上一步的字符串转换称为int类型的数字
           Function<String,Integer> "22"->20
     3.将上一步的int数字累加100,得到结果int数字。
           Function<Integer,Integer>  20->120
   */
public class Demo03Test {
    /*
      定义一个方法
      参数传递包含姓名和年龄的字符串
      参数再传递3个Function接口用于类型转换
     */
    public static Integer 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 = "赵丽颖,22";
        //调用change方法，参数传递字符串和Lambda表达式
        Integer num = change(str, (String s) -> {
            //"赵丽颖,22"->"22"
            return s.split(",")[1];
        }, (String s) -> {
            // "22"->22
            return Integer.parseInt(s);
        }, (Integer i) -> {
            //22->122
            return i + 100;
        });
        System.out.println(num);
    }
}