常用函数式接口

常用函数式接口

JDK 8 中重要的函数接口

接口      参数          返回          中文          示例
Supplier None T 提供者 工厂方法创建对象
​
Consumer T void 消费者 输出一个值
​
Predicate T boolean 谓语，顾名思义，中文中的‘是’与‘不是’是中文语法的谓语
​
Function T R 函数 获得某个对象的名字
​
BinaryOperator (T, T) T 二元操作符，二元（就是数学里二元一次方程那个二元,代表 2 个的意思）,双重的。
                即有两个操作数 例如求两个数的乘积(*)
    
UnaryOperator T T 一元操作符，只有一个操作数 逻辑非(!)

Supplier 接口

Supplier 接口代表一个结果的提供者。
​
Supplier 接口是用来生成数据的，数据的类型通过泛型参数给定。
​
使用 get()方法获得返回值，不要求每次调用时都返回新的或不同的结果。

接口的源码如下：

@FunctionalInterface
public interface Supplier {
 /**
得到一个结果，返回 T 对象
 */
   T get();
  }

Supplier 接口中的方法

T get() 获得指定类型的数据

将 Supplier 直接使用

 案例需求get()方法的基本使用，在 Supplier 接口中 get 方法返回一个字符串。 案例步骤：1) 使用 Lambda 创建 Supplier 对象，泛型类型为 String，方法体返回一个字符串，return 可以省略。2) 调用 Supplier 的 get()方法得到字符串，并打印输出

public class DemoSupplier {
​
 public static void main(String[] args) {
​
 //使用 Lambda 创建 Supplier 对象
​
 Supplier supplier = () -> "Hello Java!";
​
 //输出它的值
​
 System.out.println(supplier.get());
​
 }
}

将 Supplier 使用生成对象

 案例需求：

下面的例子演示了如何通过调用一个静态方法，生成一个员工对象返回。

使用构造方法做为 Supplier 参数的引用。

 案例步骤：1) 在主类内部创建一个私有的静态 Employee 对象，重写 toString()方法，返回一个字符串："我是员工"。

2) 在 main 函数中创建一个 Supplier 对象，泛型类型是 Employee。使用 Lambda 传入 Supplier 对象，方法体实例化员工对象，省略 return 方法。

3) 使用 supplier 对象的 get()方法得到员工对象

4) 打印输出员工对象

因为 Employee 对象是私有的，外部类无法直接实例化员工对象。

调用 Supplier 的 get()方法来生成员工对象，这样做的目的是可以控制员工对象的生成方式，类似于工厂模式。

//主类
public class DemoSupplier {
​
 //员工类
 private static class Employee {//注意static
​
 @Override
​
 public String toString() {
​
 return "我是员工";
​
 }
​
 }
​
 public static void main(String[] args) {
​
 //使用 Lambda 传入 Supplier 对象，将生成一个员工对象//此时仅仅是实例化了接口并未执行里面代码
​
 Supplier supplier = ()->new Employee();
​
 //输出员工对象
​
 System.out.println(supplier.get());
​
 }
}

将 Supplier 做为方法的参数

 需求说明求数组中的最大值，使用 Supplier 接口作为方法参数类型，通过 Lambda 表达式求出 int 数组中的最大值。 需求分析1) 定义整型数组 int[] arr = {12,68,10,2,99,313,46};2) 创建静态方法 getMax()：返回 int 类型，将 Supplier 做为参数，泛型类型为 Integer，方法体调用 get()方法返回值。3) 在 main 函数中调用 getMax()方法，使用 Lambda 传入 Supplier 对象，并且实现查找最大值的功能。4) 在 Lambda 表达式相当于方法体：遍历每个元素，比较大小，找出最大值。

public class DemoSupplier {
 public static void main(String[] args) {
 int[] arr = {12, 68, 10, 2, 99, 313, 46};
 // 调用 getMax 方法获得最大值，Lambda 相当于方法体
 int num = getMax(() -> {
 int max = arr[0];
 for (int i = 1; i < arr.length; i++) {
 if (max < arr[i]) {
 max = arr[i];
 }
 }
 return max;
 });
 //输出最大值
 System.out.println("最大值是：" + num);
 }
 //使用 Supplier 做为参数
 public static int getMax(Supplier<Integer> supplier) {
 return supplier.get();
 }
}

Consumer 接口

Consumer 接口代表接受单一的输入变量而且没有返回值的一类操作。
​
它的作用和 Supplier 相反，是消费一个数据的，消费的数据类型需要通过泛型指定。

它的源代码如下：

​
@FunctionalInterface
public interface Consumer<T>{
 //接受 t 对象，无返回值
 void accept(T t);
    
//默认的组合方法，参数和返回值都是 Consumer 类型，先调用自己的 accept()方法，再调用参数的 accept()方法
 default Consumer<T>  andThen(Consumer<T>  after) {
 Objects.requireNonNull(after);
 return (T t) -> { accept(t); after.accept(t); };
 }
}
​

Consumer 接口中的方法

void accept(T t) 接受对给定的参数进行操作。

Consumer 接口中的默认方法：

default Consumer<T>  andThen(Consumer<T>  after)然后
​
如果一个方法的参数和返回值全都是 Consumer<T>  类型，那么就可以实现效果：
​
消费一个数据的时候，首先做一个操作，然后再做另一个操作，两个操作依次执行，实现一种组合操作。
​
而这个方法就是 Consumer 接口中的默认方法 andThen。

直接使用 Consumer 对象

 实现步骤：1) 使用 Lambda 创建 Consumer 对象，直接打印传入的字符串数据。2) 调用 Consumer 的 accept()方法，在 accept()方法中传入一个字符串数据。

public class DemoConsumer {
 public static void main(String[] args) {
 //创建 Consumer 对象，打印传入的变量 t
 Consumer consumer = t -> System.out.println(t);
 //调用 Consumer 中的方法
 consumer.accept("Hello Lambda");
 }
}

Consumer 做为参数

List 和 Set 集合中遍历的 forEach 方法它的参数就是 Consumer，

请看下面的代码： 案例需求：1) 创建一个数组，使用 Arrays.asList("孙悟空", "猪八戒", "白骨精", "嫦娥") 转成 List 对象。2) 使用 forEach 方法打印每一个元素，forEach 中使用 Lamba 表达式输出传入的字符串

public class DemoForEach {
 public static void main(String[] args) {
 //将数组转成 List 对象
 List names = Arrays.asList("孙悟空", "猪八戒", "白骨精", "嫦娥");
 //打印每一个字符串，forEach 的参数就是 Consumer
 names.forEach(t -> System.out.println(t));
 }
}

分析 forEach()方法的源代码

default void forEach(Consumer<T> action) {
 Objects.requireNonNull(action);//判断某一对象是否不为null
 for (T t : this) {
 action.accept(t);
 }
}
​
这是定义在 java.lang.Iterable 接口中的默认方法，
​
参数就是 Consumer 对象，方法体内对当前集合使用 for遍历，this 就是集合对象。
​
每次对一个元素调用 accept()方法。
​
而我们外部调用的代码中对 accept()方法进行了实现，输出了每个元素。
​
​
public static  T requireNonNull(T obj) 静态方法，JDK7 中新增的方法，判断传入的对象是否为 NULL，
​
如果是 NULL 则抛出异常，不为 NULL 则返回对象本身。常用于方法或构造方法中传入对象参数的校验。

default Consumer<T>  andThen(Consumer super T>  after) {
 Objects.requireNonNull(after); //判断 after 是否为 null
    
//先调用自己的 accept()方法，再调用参数的 accept()方法
 return (T t) -> { accept(t); after.accept(t); };
}
​
要想实现组合，需要两个或多个 Lambda 表达式，而 andThen 的语义正是执行“一步接一步”操作。

andThen 方法演示示例 案例需求：将字符串 Hello 首先打印大写的 HELLO，然后打印小写的 hello 实现步骤：1) 创建 Consumer 对象 c1，使用 Lambda 打印 s 对象的大写2) 创建 Consumer 对象 c2，使用 Lambda 打印 s 对象的小写3) c1 调用 andThen(c2)方法，再调用 accept("字符串")，完成依次的操作。

public class DemoConsumer {
    public static void main(String[] args) {
        //打印大写
        Consumer<String> c1 = s -> System.out.println(s.toUpperCase());
        //打印小写
        Consumer<String> c2 = s-> System.out.println(s.toLowerCase());
        //调用方法
        c1.andThen(c2).accept("Hello Consumer");
    }
}

使用 Consumer 做为参数

 需求说明格式化打印信息，下面的字符串数组当中存有多条信息，

请按照格式“姓名：XX。性别：XX。”的格式将信息打印出来。

要求将打印姓名的动作作为第一个 Consumer 接口的 Lambda 实例，

将打印性别的动作作为第二个Consumer 接口的 Lambda 实例，将两个 Consumer 接口按照顺序“拼接”到一起。以下数组共 5 个元素，每个元素包含 2 项信息用逗号分隔。String[] arr = { "张飞,男", "貂蝉,女", "曹操,男","孙尚香,女","小乔,女" };

 实现步骤1) 创建静态方法 printInfo()，有 3 个参数，

第 1 个是需要打印的字符串数组，

第 2 个是 Consumer用于打印姓名 name，

第 3 个是 Consumer用于打印性别 gender。

2) 在 printInfo 方法中遍历数组中每个元素，再调用 name.andThen(gender).accept(单个元素)

3) 每调用一次 andThen()方法，在下面输出一行横线

4) 在 main 函数中创建上面要遍历的数组

5) 调用 printInfo 方法，传入 3 个参数，

第 1 个参数是数组，

第 2 个参数使用 Lambda 打印姓名，参数 s 表示数组中的每个元素。

第 3 个参数使用 Lambda 打印性别。

public class DemoConsumerPrint {
    public static void main(String[] args) {
        String[] arr = { "张飞,男", "貂蝉,女", "曹操,男","孙尚香,女"};
​
        //这里的 s 表示数组中的每个元素
        printInfo(arr, s ->{
            System.out.println("姓名：" + s.split(",")[0]);
        },s ->{
            System.out.println("性别：" + s.split(",")[1]);
        });
    }
​
    public static void printInfo(String[] arr, Consumer<String> name, Consumer<String> gender) {
        for (String s : arr) {
            name.andThen(gender).accept(s);
            System.out.println("------------------");
        }
    }
}

Predicate 接口

Predicate 中文意思为谓语，"我是一个程序员"，"是"或"不是"就是谓语。
它代表只有一个变量的函数，返回 boolean 类型。
​
有时候我们需要进行某种判断，从而得到一个 boolean 值的结果。
​
可以使用 java.util.function.Predicate接口。

Predicate 的源码：

@FunctionalInterface
public interface Predicate<T> {
 boolean test(T t); //抽象方法，对 t 进行测试，返回 boolean 类型
​
/**
- 组合方法，将当前的谓语与另一个谓语进行短路的与操作，返回一个谓语对象
  */
   default Predicate<T> and(Predicate super T>  other) {
   Objects.requireNonNull(other); //判断 other 是否为空
   return (t) -> test(t) && other.test(t);
   }
    
   /**
- 对当前的谓语进行逻辑非操作，返回一个谓语对象
  */
   default Predicate<T> negate() {
   return (t) -> !test(t);
   }
    
   /**
- 组合方法，将当前的谓语与另一个谓语进行短路的或操作，返回一个谓语对象
  */
   default Predicate<T> or(Predicate super T> other) {
   Objects.requireNonNull(other);
   return (t) -> test(t) || other.test(t);
   }
    
   /**
- 静态方法，判断 test(object)方法传入的对象是否与参数 targetRef 对象相等
  */
   static  Predicate<T> isEqual(Object targetRef) {
   return (null == targetRef)
   ? Objects::isNull
   : object -> targetRef.equals(object); /
   }
  }
​

Predicate 接口中的方法

boolean test(T t) 对 t 进行指定条件的测试，返回 boolean 类型

test()方法演示

 案例需求：判断 test("字符串")方法给定的参数长度是否大于 5 案例步骤：1) 创建一个 Predicate 谓语对象，使用 Lambda 实现 boolean test(T t)方法2) 方法体的参数是 s，返回字符串的长度大于 5，省略 return 关键字。3) 两次调用 test()方法看运行结果，第 1 次使用字符串 Hello，第 2 次使用字符串 Predicate

public class DemoPredicateTest {
​
 public static void main(String[] args) {
​
 //创建一个 Predicate 谓语对象，boolean test(T t)方法接收字符串类型，返回 boolean 类型
​
 Predicate<String> predicate = s -> s.length() > 5;
​
 //两次调用 test 方法看运行结果
​
 System.out.println("Hello 的长度是否大于 5：" + predicate.test("Hello"));
​
 System.out.println("Predicate 的长度是否大于 5：" + predicate.test("Predicate"));
​
 }
}

默认方法 and()

既然是条件判断，就会存在与、或、非三种常见的逻辑关系。
​
其中将两个 Predicate 条件使用“与”逻辑连接起来实现“并且”的效果时，可以使用 default 方法 and。
​
这个默认方法接收一个 Predicate 参数，返回一个 Predicate参数。

其 JDK 源码为：

/**
组合方法，将当前的谓语与另一个谓语进行短路的与操作，返回一个谓语对象
*/
​
default Predicate<T> and(Predicate super T> other) {
    Objects.requireNonNull(other);
    return (t) -> test(t) && other.test(t);
}

and 方法演示示例：

 案例需求：判断一个字符串是否包含指定的字符串：既包含大写“H”，又要包含大写“W” 案例步骤：1) 创建 2 个需要判断的字符串：s1="Hello world"和 s2="Hello World"2) 使用 Lambda 表达式，创建两个 Predicate 对象3) 判断字符串 s 是否包含 H4) 判断字符串 s 是否包含 W5) 调用 and 方法和 test 方法，分别输出 s1 和 s2 的结果

public class DemoPredicateAnd {
​
 public static void main(String[] args){
​
 //创建 2 个需要判断的字符串
​
 String s1 = "Hello world";
​
 String s2 = "Hello World";
​
 // 使用 Lambda 表达式，创建两个 Predicate 对象
​
 //判断 s 是否包含 H
​
 Predicate<String> p1 = s -> s.contains("H");
​
 //判断 s 是否包含 W
​
 Predicate<String> p2 = s -> s.contains("W");
​
 //调用 and 方法
​
 System.out.println(s1 + "是否包含 H 和 W：" + p1.and(p2).test(s1));
​
 System.out.println(s2 + "是否包含 H 和 W：" + p1.and(p2).test(s2));
​
 }
}

默认方法 or()

与 and 的“与”类似，默认方法 or 实现逻辑关系中的“或”操作。
​
这个默认方法接收一个 Predicate 参数，返回一个 Predicate 参数。

JDK 源码为：

/**
*组合方法，将当前的谓语与另一个谓语进行短路的或操作，返回一个谓语对象
*/
default Predicate<T> or(Predicate super T> other) {
    Objects.requireNonNull(other);
    return (t) -> test(t) || other.test(t);
}
​

or 方法演示示例：

 案例需求：判断一个字符串的长度大于 10 或者小于 5 案例步骤：1) 创建三个字符串 s1,s2,s3 内容如下图2) 使用 Lambda 创建 2 个 Predicate 接口对象，第 1 个判断长度是否大于 10，每 2 个判断长度是否小于 53) 调用 or 和 test 方法输出每个字符串的测试结果

public class DemoPredicateOr {
​
 public static void main(String[] args) {
​
 //创建三个字符串
​
 String s1 = "Hello World"; //大于 10
​
 String s2 = "Java"; //小于 5
​
 String s3 = "I am boy"; //既不大于 10，又不小于 5
​
 //使用 Lambda 创建 2 个 Predicate 接口对象
​
 Predicate<String> p1 = s -> s.length() > 10;
​
 Predicate<String> p2 = s -> s.length() < 5;
​
 //输出每个字符串的测试结果
​
 System.out.println(s1 + "=" + p1.or(p2).test(s1));
​
 System.out.println(s2 + "=" + p1.or(p2).test(s2));
​
 System.out.println(s3 + "=" + p1.or(p2).test(s3));
​
 }
}

默认方法 negate()

“与”、“或”已经了解了，剩下的“非”（取反）也会简单。方法没有参数，返回值为 Predicate。

默认方法 negate的 JDK 源代码为：

/**
*对当前的谓语进行逻辑非操作，返回一个谓语对象
*/
​
default Predicate<T> negate() {
​
 return (t) -> !test(t);
}
​
从实现中很容易看出，它是执行了 test 方法之后，对结果 boolean 值进行“!”取反而已。
​
要在 test 方法调用之前调用 negate 方法，正如 and 和 or 方法一样。

 案例需求：判断年龄是否小于 18 岁，将判断的结果取反。 案例步骤1) 创建 2 个整数类型的年龄，一个 25，一个 15 岁。2) 使用 Lambda 创建 1 个 Predicate，判断年龄小于 18 岁。3) 使用 nagate()取反以后再调用 test()方法，输出两个年龄的结果

public class DemoPredicateNegate {
​
 public static void main(String[] args) {
​
 int age1 = 25; //25 岁
​
 int age2 = 15; //15 岁
​
 Predicate<Integer> predicate = (a) -> a < 18; //判断是否小于 18 岁
​
 System.out.println(age1 + "小于 18 岁，取反：" + predicate.negate().test(age1));
​
 System.out.println(age2 + "小于 18 岁，取反：" + predicate.negate().test(age2));
​
 }
}

静态方法 isEqual ()

Predicate 中唯一的静态方法，方法的参数是两个 Object 类型，返回一个 Predicate 类型。
​
作用：根据 Objects.equals(Object, Object)方法比较两个参数是否相等，
一个对象通过 isEqual()传入，另一个对象通过 test()传入。
​
​
java.util.Objects 类中的方法 说明
public static boolean equals(Object a,Object b)
​
作用：用于比较两个对象是否相等
​
参数：a 和 b 是要比较的两个对象
​
返回：如果两个对象相等，则返回 true，否则返回 false

JDK 源代码为：

/**
*静态方法，判断 test(object)方法传入的对象是否与参数 targetRef 对象相等
*/
static <T> Predicate<T> isEqual(Object targetRef) {
    return (null == targetRef)
            ? Objects::isNull
            : object -> targetRef.equals(object);
}

 案例需求：比较两个字符串是否相等 案例步骤：1) 通过静态方法 isEqual("newboy")，直接返回 Predicate 对象2) 调用 Predicate 中的 test()方法传入另两个字符串分别比较

public class DemoPredicateIsEqual {
​
 public static void main(String[] args) {
​
 //通过静态方法直接返回 Predicate 对象
​
 Predicate predicate = Predicate.isEqual("newboy");
​
 //调用 test()方法传入另两个字符串分别比较
​
 System.out.println("两个字符串是否相等：" + predicate.test("newboy"));
​
 System.out.println("两个字符串是否相等：" + predicate.test("NewBoy"));
​
 }
​
}

Predicate 的应用示例

 需求说明集合当中有多条“姓名+性别”的信息如下："张飞,男", "貂蝉,女", "曹操,男","孙尚香,女","小乔,女"

请通过 Predicate 接口的 and 组合方法，将符合要求的字符串筛选到集合 ArrayList 中，

需要同时满足两个条件：1) 必须为女生 2) 姓名为两个字

 开发步骤：1) 创建第 1 个 Predicate 判断条件：使用逗号分隔的第 0 个元素姓名长度是 2

2) 创建第 2 个 Predicate 判断条件：使用逗号分隔的第 1 个元素性别等于女

3) 创建一个新的 List 集合，用于存储过滤以后符合条件的字符串

4) 使用 List 中的 forEach(Lambda)遍历上面的原始 List 集合，

使用 Predicate 中的 and 和 test 方法判断每个元素

5) 两个条件都为真才添加到新的 List 集合中

6) 创建第 1 个 Consumer 接口，输出使用逗号分隔的第 0 个元素姓名

7) 创建第 2 个 Consumer 接口，输出使用逗号分隔的第 1 个元素性别

8) 使用 List 中的 forEach(Lambda)遍历，输出过滤后的新的集合

9) 使用 Consumer 接口中的 andThen 和 accept 方法，输出每一个元素

public static void main(String[] args) {
​
    //从数组中创建一个 List 集合
​
    List<String> list = Arrays.asList("张飞,男", "貂蝉,女", "曹操,男","孙尚香,女","小乔,女");
​
    //创建第 1 个 Predicate 判断条件：使用逗号分隔的第 0 个元素姓名长度是 2
​
    Predicate<String> pname = s -> s.split(",")[0].length() ==2;
​
    //创建第 2 个 Predicate 判断条件：使用逗号分隔的第 1 个元素性别等于女
​
    Predicate<String> pgender = s-> s.split(",")[1].equals("女");
​
    //创建一个新的 List 集合
​
    List<String> infos = new ArrayList<>();
​
    //使用 Lamba 中的 forEach()遍历上面的 List 集合，使用 Predicate 中的 and 和 test 方法判断每个元素
​
    list.forEach(s -> {
​
        //两个都为真才添加到集合中
​
        if (pname.and(pgender).test(s)) {
​
            infos.add(s);
​
        }
​
    });
​
    //创建第 1 个 Consumer 接口，输出使用逗号分隔的第 0 个元素姓名
​
    Consumer<String> cname = s -> System.out.println("姓名：" + s.split(",")[0]);
​
    //创建第 2 个 Consumer 接口，输出使用逗号分隔的第 1 个元素性别
​
    Consumer<String> cgender = s -> System.out.println("性别：" + s.split(",")[1]);
​
    //使用 Lamba 中的 forEach()遍历，输出过滤后的集合
​
    infos.forEach(s -> {
        //使用 Consumer 接口中的 andThen 和 accept 方法，每输出一个元素隔一条线
        cname.andThen(cgender).accept(s);
        System.out.println("---------------");
​
    });
}

Function 接口

Function接口：
        根据一个参数得到另一个参数值，前面称为计算的参数，后面称为计算的结果。
        有进有出，所以称为“函数 Function”。
        
类似于数学中的函数，通过一个变量求出另一个变量的值。如：f(x) = 2x+3

以下是它的 Java 源代码

import java.util.Objects;
​
/**
代表通过一个变量求出另一个变量的结果的函数
​
@param  输入给函数的变量
​
@param  函数输出的结果
*/
@FunctionalInterface
public interface Function<T, R> {
​
 /**
对给定的变量 t 进行计算，得到返回的结果 R
*/
 R apply(T t);
  
    
 /**
默认组合方法，先计算当前函数，再计算传入的函数
*/
default <V> Function<T, V> andThen(Function super R, ? extends V> after) {
    Objects.requireNonNull(after);
    return (T t) -> after.apply(apply(t));
}
    
 /**
默认组合方法，先计算传入的函数，再计算当前函数
*/
default <V> Function<V, R> compose(Function super V, ? extends T> before) {
    Objects.requireNonNull(before);
    return (V v) -> apply(before.apply(v));
}
​
 /**
静态方法：总是返回它的输入变量
*/
static <T> Function<T, T> identity() {
    return t -> t;
}
}

抽象方法：apply()

是java.util.function.Function 接口中的方法 
​
R apply(T t); 对给定的变量 t 进行计算，得到返回的结果 R

apply 方法演示示例： 案例需求将 Integer 类型转换为 String 类型，并且输出转换以后字符串的长度。1) 创建一个 Function 对象，输入类型是整数，输出类型是字符串2) Lambda 表达式将一个整数 i 转成字符串3) 调用 apply(数字)方法得到转换后的字符串，再调用字符串的 length()方法得到长度，打印输出。4) 第 1 次转换 99 这个数字，第 2 次转换 1000 这个数字。

public class DemoFunction {
​
 public static void main(String[] args) {
​
    //创建一个 Function 对象
​
    Function<Integer,String> converter = i -> Integer.toString(i);
​
    System.out.println("99 转成字符串的长度是：" + converter.apply(99).length());
​
    System.out.println("1000 转成字符串的长度是：" + converter.apply(1000).length());
 }
}

默认方法：andThen()

Function 接口中有一个默认的 andThen 方法，用来进行组合操作。
​
先计算当前函数，再计算传入的函数。两个函数依次执行。
​
andThen 方法的参数是 Function 对象，返回一个 Function 对象。

JDK 源代码如：

/**
默认组合方法，先计算当前函数，再计算传入的函数
*/
​
default <V> Function<T, V> andThen(Function super R, ? extends V> after) {
    Objects.requireNonNull(after);
    return (T t) -> after.apply(apply(t));
}

andThen 方法演示示例： 案例需求：连续进行两个操作：第 1 个操作是将字符串转换成为 int 数字，第 2 个操作将转换好的数字乘以 10。两个操作按照前后顺序组合到一起。1) 让用户从键盘输入 1 个数字，使用字符串接收。2) 创建第 1 个 Function 函数将字符串转成整数3) 创建第 2 个函数将整数乘以 10 返回4) 调用 andThen 方法和 apply，并且输出结果

public class DemoFunctionAndThen {
    public static void main(String[] args) {
        //用户输入一个字符串
        System.out.println("请输入数字：");
        Scanner input = new Scanner(System.in);
        String str = input.nextLine();
        //第 1 个函数将字符串转成整数
        Function<String,Integer> f1 = s -> Integer.parseInt(s);
        //第 2 个函数将整数乘以 10 返回
        Function<Integer,Integer>  f2 = i -> i * 10;
        //调用 andThen 方法，并且输出结果
        System.out.println("转成整数并乘以 10 以后的结果是：" + f1.andThen(f2).apply(str));
    }
}

默认方法：compose()

Function 中有一个与 andThen 非常类似的 compose 方法。
​
中文是"组成"的意思，方法参数是 Function，返回值是 Function，
​
先运行参数的 apply 方法，再调用自己的 apply 方法。

其 JDK 源代码为：

/**
默认组合方法，先计算传入的函数，再计算当前函数
*/
default <V> Function<V, R> compose(Function super V, ? extends T> before) {
    Objects.requireNonNull(before);
    return (V v) -> apply(before.apply(v));
}
​
结合 andThen 方法的 JDK 源码实现进行对比，会发现 compose 方法的参数 Lamda 将会先执行。
​
所以二者只是先后顺序的不同而已。

compose 方法的演示

 案例需求：创建两个函数对象：1 个将字符串转成大写，1 个将字符串转成小写。分别使用 andThen 和 compose 方法组合调用，查看不同的计算结果。 开发步骤：1) 创建第 1 个 Function，输入输出都是 String 类型，将字符串转成大写。2) 创建第 2 个 Function，输入输出都是 String 类型，将字符串转成小写。3) 调用第 1 个函数的 apply 方法，并且输出值4) 调用第 2 个函数的 apply 方法，并且输出值5) 调用 andThen 方法和 apply 方法查看运行结果6) 调用 compose 方法和 apply 方法查看运行结果

public class DemoFunctionCompose {
    public static void main(String[] args) {
        Function<String,String> f1=s -> s.toUpperCase();
        Function<String,String> f2 = s -> s.toLowerCase();
        System.out.println("转成大写：" + f1.apply("Hello"));
        System.out.println("转成小写：" + f2.apply("Hello"));
        System.out.println("先转成大写，再转成小写：" + f1.andThen(f2).apply("Hello"));
        
        System.out.println("先转成小写，再转成大写：" + f1.compose(f2).apply("Hello"));
    }
}

Function 的应用示例 需求说明请使用 Function 进行函数拼接，按照顺序执行多个函数。操作依次为：1) 将字符串"赵丽颖,20"截取数字年龄部分，得到字符串；2) 将上一步的字符串转换成为 int 类型的数字；3) 将上一步的 int 数字累加 100，得到结果 int 数字。 开发步骤：1) 创建第 1 个 Function 对象，将字符串 20 取出，返回一个字符串2) 创建第 2 个 Function 对象，将字符串转成整数，返回整数3) 创建第 3 个 Function 对象，将整数加 100，返回计算结果4) 调用 andThen 方法 2 次，apply 方法应用字符串："赵丽颖,20"，输出结果 代码实现

public class DemoFunctionApp {
    public static void main(String[] args) {
        //创建第 1 个 Function 对象，将字符串 20 取出，返回一个字符串
        Function<String,String> fun1 = s -> s.split(",")[1];
        //创建第 2 个 Function 对象，将字符串转成整数，返回整数
        Function<String,Integer> fun2 = s -> Integer.parseInt(s);
        //创建第 3 个 Function 对象，将整数加 100，返回计算结果
        Function<Integer,Integer> fun3 = num -> num + 100;
        //调用 andThen 方法 2 次，apply 方法应用字符串，输出结果
        System.out.println("计算结果：" + fun1.andThen(fun2).andThen(fun3).apply("赵丽颖,20"));
    }
}

BinaryOperator 接口

BinaryOperator 表示对两个相同类型的操作数进行操作，产生相同类型的结果。

接口中的方法

static <T> BinaryOperator<T> maxBy(Comparator super T> comparator) 
返回一个BinaryOperator ，它根据指定的Comparator返回两个元素中的较大Comparator 。  
​
static <T> BinaryOperator<T> minBy(Comparator super T> comparator) 
返回BinaryOperator返回根据指定的两个元件的较小的Comparator 。  
​
这个接口中定义了两个静态方法，
BiFunction 是用于定义两个操作符的函数接口。

BinaryOperator 接口中的方法

T apply(T t, T u); 从父接口 BiFunction 中继承下来的抽象方法，
传入两个参数 t 和 u 进行函数计算，返回计算的结果。
​
两个参数和返回值都是同一种类型。
​
​
default <V> BiFunction<T,U,V> andThen(Function super R,? extends V> after)
返回一个组合函数，首先将该函数应用于其输入，然后将after函数应用于结果。 
如果任一函数的评估引发异常，则将其转发给组合函数的调用者。 
​
参数类型 
V - after函数的输出类型，以及组合函数 
参数 
after - 应用此函数后应用的功能 
结果 
一个组合函数首先应用此函数，然后应用 after函数 
​

方法的演示：apply()

 案例需求：使用 BinaryOperator 接口的 apply()方法，计算 2 个整数的和，并且输出结果。 案例步骤：1) 创建类 Demo25BinaryOperator2) 创建 BinaryOperator 接口，使用 Lambda 实现方法，方法有两个参数，返回方法的计算结果。3) 调用 apply()方法传入实际的参数，打印计算结果。 案例代码：

public class DemoBinaryOperator {
    public static void main(String[] args) {
​
        BinaryOperator<Integer> operator = (m, n) -> m + n;
​
        System.out.println("计算结果是：" + operator.apply(3, 5));
    }
}

静态方法

​
public static  BinaryOperator minBy(Comparator comparator)
通过后面的 Comparator 比较器判断，返回两个元素中较小的元素
​
public static  BinaryOperator maxBy(Comparator comparator)
通过后面的 Comparator 比较器判断，返回两个元素中较大的元素
​
Comparator 接口中的静态方法说明
naturalOrder() 按元素的自然排序的大小进行比较，返回一个 Comparator 对象
reverseOrder() 按元素的倒序大小进行比较，返回一个 Comparator 对象

BinaryOperator 接口做为方法参数

 案例需求有如下数组{2,1,3,5}，对数组中的每个元素进行替换。替换算法如下：1) 第 0 个元素不变2) 第 0 个+第 1 个元素的结果代替第 1 个元素3) 第 1 个新元素+第 2 个元素的结果代替 2 个4) 第 2 个新元素+第 3 个元素的结果代替第 3 个5) 依次类推，直到所有的元素替换完成为止。

 案例步骤

Arrays 类中的方法 说明
void parallelPrefix(T[] array, BinaryOperator op)
并行累积
​
作用：对数组中每个元素使用指定的二元操作函数进行替换操作
​
参数 1：要替换的数组
​
参数 2：指定二元操作函数

1) 创建 BinaryOperator对象，指定 2 个数的算法是 m+n2) 创建 Integer 类型的数组：{2,1,3,5}3) 输出操作前的数组4) 调用上面的 parallelPrefix()方法，将 BinaryOperator 做为参数传入5) 输出操作后的数组6) 如果使用不同的算法，则每个元素的替换的结果不同。如：换成两个数相乘。 案例代码

public static void main(String[] args) {
    BinaryOperator<Integer> operator = (m,n) -> m+n;
    Integer [] arr = {2,1,3,5};
    System.out.println("操作前的数组：" + Arrays.toString(arr)) ;
    Arrays.parallelPrefix(arr,operator);
    System.out.println("操作后的数组：" + Arrays.toString(arr)) ;
}

静态方法的演示 案例需求比较两个整数，使用 minBy 静态方法找出最小值比较两个字符串，使用 maxBy 静态方法找出最大值 案例步骤1) 创建 BinaryOperator对象，使用 minBy()静态方法，按数字的正常大小进行比较。2) 输出最小值，调用 apply()方法，传入 2 个整数。3) 创建 BinaryOperator对象，使用 maxBy()静态方法，按字符串的大小进行比较。4) 输出最大值，调用 apply()方法，传入 2 个字符串："ABCD","xyz" 案例代码

 public static void main(String[] args) {
 //naturalOrder()是 Comparator 中的静态方法，即按数字的正常大小进行比较
 BinaryOperator oper1 = BinaryOperator.minBy(Comparator.naturalOrder());
 System.out.println("最小值是：" + oper1.apply(3,5));
     
 //naturalOrder()是 Comparator 中的静态方法，即按字符串的正常大小进行比较
 BinaryOperator oper2 = BinaryOperator.maxBy(Comparator.naturalOrder());
 System.out.println("最大值是：" + oper2.apply("ABCD","xyz"));
}

UnaryOperator 接口

UnaryOperator 表示对单个操作数的操作，该操作数生成与其操作数类型相同的结果。
​
UnaryOperator 接口继承于 Function 接口，
​
所以有 T apply(T t)抽象方法，与前面的 Function 接口中的 apply()方法相同。
​
它的输入类型和返回类型是相同的类型。

UnaryOperator 接口的源码

package java.util.function;
@FunctionalInterface
public interface UnaryOperator extends Function {
 /**
始终返回其输入参数的一元运算符
*/
 static  UnaryOperator identity() {
 return t -> t;
 }
}

方法的演示

UnaryOperator 接口中的方法 说明
​
T apply(T t); 
    从 Function 接口中继承下来的抽象方法，使用给定的参数应用此一元运算函数，返回另一个值。
    参数和返回值是同一种类型。
​
static  UnaryOperator identity() 
    始终返回其输入参数的一元运算符也就是后续 apply()输入的是什么，就返回什么。

 案例步骤1) 使用 UnaryOperator.identity()静态方法创建 UnaryOperator对象2) 应用 apply()方法，输入字符串 abc，得到结果也是 abc。 案例代码

 public static void main(String[] args) {
 //创建一个 UnaryOperator对象，
 UnaryOperator operator = UnaryOperator.identity();
     
 //调用 apply()方法，输出参数的值
 System.out.println("输出与输出一样：" + operator.apply("abc"));
}

UnaryOperator 使用方法的参数

 案例需求：有一个整数的列表集合，将集合中每个元素乘以 2，再替换这个元素，输出替换前后的列表集合有一个字符串的列表集合，将集合中每个元素用它的大写进行替换。 案例步骤：

ArrayList 中的方法 说明
replaceAll(UnaryOperator operator) 使用一元操作函数的结果，替换列表中的每个元素

1) 使用 Arrays.asList()创建一个整数列表2) 创建 UnaryOperator一元运算函数，指定运算表达式是 x*23) 调用 ArrayList 的 replaceAll()方法，把上面创建的一元运算函数做为参数传入4) 输出替换前后的列表5) 使用 Arrays.asList()创建一个字符串列表6) 这次直接在 replaceAll()方法中传入 Lambda 表达式，s.toUpperCase()7) 输出替换前后的列表 案例代码：

 public static void main(String[] args) {
 List nums = Arrays.asList(3, 10, 8, 2);
 System.out.println("替换前：" + nums);
 UnaryOperator oper = x -> x * 2;
 nums.replaceAll(oper);
 System.out.println("替换后：" + nums);
     
 List names = Arrays.asList("Jack","Rose","Tom","NewBoy");
 System.out.println("替换前：" + names);
 names.replaceAll(s -> s.toUpperCase());
 System.out.println("替换后：" + names);
}

常用的函数式接口小结

Supplier 提供数据者 
    T get();没有传入参数，有结果。
​
Consumer 消费数据者 
    void accept(T t); 传入数据，没有结果。 
    andThen()
    
Predicate 谓语 
    boolean test(T t); 对传入的数据逻辑判断 
    and()
    or()
    negate()
    isEqual()
    
Function 函数 
    R apply(T t); 传入一个变量返回计算结果 
    andThen()
    compose()
    identity()
    
    
BinaryOperator 二元操作符 
    T apply(T t,T u); 传入两个参数返回一个结果 
    andThen()
    继承于 BiFunction
    
UnaryOperator
    继承于 Function
    一元操作符 
    T apply(T t); 传入一个参数返回一个结果 
    andThen()
    compose()
    identity()