常用函数式接口
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()
