Supplier<T>接口
- java.util.function.Supplier
<T>接口仅包含一个无参的方法：T get()：用来获取一个泛型参数指定类型的对象数据。
- Supplier
<T>接口被称之为生产型接口，指定接口的泛型是什么类型，那么接口中的 get方法就会产生什么类型的数据。 - 示例
package cn.last.demo;
/*
Supplier<T>接口的使用
*/
import java.util.function.Supplier;
public class Test {
// 定义一个方法，方法的参数传递Supplier<T>接口，泛型指定为String，get方法就返回一个String
public static String getString(Supplier<String> sup) {
return sup.get();
}
public static void main(String[] args) {
// 调用getString方法，方法的参数是一个Supplier<T>接口,即函数式接口，可以使用Lambda表达式
// 重写其中的 get方法
String s1 = getString(() -> {
return "hello";
});
System.out.println(s1);
// 优化Lambda表达式
String s2 = getString(() -> "hello");
System.out.println(s2);
}
}
Consumer<T>接口
- java.util.function.Consumer
<T>接口则正好与 Supplier<T>接口相反，它不是生产一个数据，而是消费一个数据，其数据类型由泛型决定。 - Comsumer接口中包含抽象方法：
void accept(T t)，意为消费一个指定泛型的数据。 - Comsumer接口是一个消费型接口，泛型指定什么类型，就可以使用 accept方法消费什么类型的数据，至于具体怎么消费（使用），需要自定义（输出，计算……）
- 示例
package cn.last.demo;
import java.util.function.Consumer;
public class Test {
/*
定义一个方法，参数：字符串和 Consumer<T>接口，泛型指定 String
用来使用 Consumer接口消费字符串
*/
public static void consume(String name, Consumer<String> 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<T> 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<String> con1, Consumer<String> 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<T>接口
- java.util.function.Predicate
<T>接口 - 作用：对某种数据类型的数据进行判断，结果返回一个 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<String> 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<T> 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<String> pre1, Predicate<String> 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<T> or(Predicate<? super T> other) {
Objects.requireNonNull(other);
return (t) -> test(t) || other.test(t);
}
默认方法：negate
- JDK源码：
copy default Predicate<T> negate() {
return (t) -> !test(t);
}
Function<T, R>接口
java.util.function.Function<T,R>接口用来根据一个类型的数据，得到另一个类型的数据。前者称为前置条件，后者称为后置条件。
Function接口中最主要的抽象方法为：R apply(T t)，根据类型T的参数获取类型R的结果。
使用场景例如：将String类型转换为Integer类型。
注意事项：
Function的前置条件泛型和后置条件泛型可以相同。
- 示例：
package cn.last.demo;
import java.util.function.Function;
public class Test {
/*
定义一个方法，
方法的参数传递一个字符串类型的整数
方法的参数传递一个Function<String, Integer>类型的接口
使用Function接口中的方法apply，把字符串类型的整数转换为Integer类型
*/
public static Integer change(String s, Function<String, Integer> 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<String, Integer> fun1
Integer in = fun1.apply("123") + 10;
2. Integer --> String
Function<Integer, String> fun2
String s = fun2.apply(in);
使用andThen方法，把两次转换组合在一起使用
*/
public class Test {
public static void change(String s, Function<String, Integer> fun1, Function<Integer, String> 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);
}
}