Supplier接口
java.util.function.Supplier接口仅包含一个无参的方法：
T get()：用来获取一个泛型参数指定类型的对象数据。
Supplier接口被称之为生产型接口，指定接口的泛型是什么类型，那么接口中的 get方法就会产生什么类型的数据。
示例
package cn.last.demo;/*
Supplier接口的使用
*/
import java.util.function.Supplier;
public class Test {
// 定义一个方法，方法的参数传递Supplier接口，泛型指定为String，get方法就返回一个String
public static String getString(Supplier sup) {
return sup.get();
}
public static void main(String[] args) {
// 调用getString方法，方法的参数是一个Supplier接口,即函数式接口，可以使用Lambda表达式
// 重写其中的 get方法
String s1 = getString(() -> {
return "hello";
});
System.out.println(s1);
// 优化Lambda表达式
String s2 = getString(() -> "hello");
System.out.println(s2);
}
}
Consumer接口
java.util.function.Consumer接口则正好与 Supplier接口相反，它不是生产一个数据，而是消费一个数据，其数据类型由泛型决定。
Comsumer接口中包含抽象方法：void accept(T t)，意为消费一个指定泛型的数据。
Comsumer接口是一个消费型接口，泛型指定什么类型，就可以使用 accept方法消费什么类型的数据，至于具体怎么消费(使用)，需要自定义(输出，计算……)
示例
package cn.last.demo;import java.util.function.Consumer;
public class Test {
/*
定义一个方法，参数：字符串和 Consumer接口，泛型指定 String
用来使用 Consumer接口消费字符串
*/
public static void consume(String name, Consumer con) {
con.accept(name);
}
public static void main(String[] args) {
consume("hello", (String name) -> {
// 消费方式 打印输出
System.out.println(name);
// 消费方法 反转
/*
StringBuilder是一个字符串缓冲区，里面有一个方法
reverse方法可以将此字符序列反转，再使用 toString方法转换成String类
*/
String rename = new StringBuilder(name).reverse().toString();
System.out.println(rename);
});
}
}
默认方法：andThen
如果一个方法参数和返回值都是Consumer类型，那么就可以实现效果：消费数据的时候，首先做一个操作，然后再做一个操作，实现组合(连接)，而这个方法就是Consumer接口中的 default方法andThen方法，下面式 JDK源码：
default Consumer andThen(Consumer super T> after) {
Objects.requireNonNull(after);
return (T t) -> { accept(t); after.accept(t); };
}
备注：java.util.Objects的requireNonNull静态方法将会在参数为 null 时主动抛出 NullPointerException异常。这省去了重复编写 if语句和抛出空指针异常的麻烦。
示例：
package cn.last.demo;import java.util.function.Consumer;
/*
Consumer接口的默认方法：andThen
作用：需要两个 Consumer接口，可以把两个Consumer接口组合到一起,对数据进行消费
注：谁写前边，谁先消费
*/
public class Test {
/*
定义一个方法，参数传递一个字符串和两个 Consumer接口，泛型都使用 String
*/
public static void method(String s, Consumer con1, Consumer con2) {
con1.andThen(con2).accept(s);
}
public static void main(String[] args) {
String s = "Hello";
method(s,
(t) -> {
// 消费方式：把字符串变成大写
System.out.println(s.toUpperCase());
},
(t) -> {
// 消费方式：把字符串变成小写
System.out.println(s.toLowerCase());
}
);
}
}
Predicate接口
java.util.function.Predicate接口
作用：对某种数据类型的数据进行判断，结果返回一个 boolean值
Predicate接口中包含一个抽象方法：
boolean test(T t)：用来对指定的数据类型进行判断
结果：
符合条件，返回 true
不符合条件，返回 false
示例：
package cn.last.demo;import java.util.function.Predicate;
public class Test {
/*
定义一个方法，参数传递一个字符串
和一个Predicate接口，泛型使用String
使用Predicate中的方法 test对字符串进行判断，并把判断的结果返回
*/
public static boolean checkString(String s, Predicate pre) {
return pre.test(s);
}
public static void main(String[] args) {
String s = new String("abcdef");
// 调用checkString方法，函数式接口，使用Lambda表达式
boolean b = checkString(s, str -> str.length() > 5);
System.out.println(b);
}
}
默认方法：and
JDK源码:
copydefault Predicate and(Predicate super T> other) {
Objects.requireNonNull(other);
return (t) -> test(t) && other.test(t);
}
示例：
package cn.last.demo;import java.util.function.Predicate;
/*
需求：
判断一个字符串，有两个判断条件
1. 字符串的长度是否大于5
2. 字符串中是否包含a
两个条件必须同时满足，我们就可以使用 && 运算符连接
*/
public class Test {
public static boolean checkString(String s, Predicate pre1, Predicate pre2) {
return pre1.and(pre2).test(s);
// 等价于 return pre1.test(s) && pre2.test(s);
}
public static void main(String[] args) {
String s = "I Love Java!";
boolean b = checkString(s, (String str) -> {
// 对字符串长度是否大于5进行判断
return str.length() > 5;
}, (String str) -> {
// 对字符串中是否包含a进行判断
return str.contains("a");
});
System.out.println(b);
}
}
默认方法：or
JDK源码：
copydefault Predicate or(Predicate super T> other) {
Objects.requireNonNull(other);
return (t) -> test(t) || other.test(t);
}
默认方法：negate
JDK源码：
copy default Predicate negate() {
return (t) -> !test(t);
}
Function接口
java.util.function.Function接口用来根据一个类型的数据，得到另一个类型的数据。前者称为前置条件，后者称为后置条件。
Function接口中最主要的抽象方法为：R apply(T t)，根据类型T的参数获取类型R的结果。
使用场景例如：将String类型转换为Integer类型。
注意事项：
Function的前置条件泛型和后置条件泛型可以相同。
示例：
package cn.last.demo;import java.util.function.Function;
public class Test {
/*
定义一个方法，
方法的参数传递一个字符串类型的整数
方法的参数传递一个Function类型的接口
使用Function接口中的方法apply，把字符串类型的整数转换为Integer类型
*/
public static Integer change(String s, Function fun) {
// 自动拆箱 Integer --> int
return fun.apply(s);
}
public static void main(String[] args) {
int in = change("123", Integer::parseInt);
System.out.println(in + 1);
}
}
默认方法：andThen
Function接口中的默认方法andThen：用来进行组合操作。
示例
package cn.last.demo;import java.util.function.Function;
/*
需求：
把String类型的"123"转换为Integer类型，再加上10
把Integer类型转换为String类型
分析：
转换了两次
1. String --> Integer
Function fun1
Integer in = fun1.apply("123") + 10;
2. Integer --> String
Function fun2
String s = fun2.apply(in);
使用andThen方法，把两次转换组合在一起使用
*/
public class Test {
public static void change(String s, Function fun1, Function fun2) {
String str = fun1.andThen(fun2).apply(s);
System.out.println(str);
}
public static void main(String[] args) {
change("1234", s -> Integer.parseInt(s) + 100, String::valueOf);
}
}