1.Supplier<T>接口
- 用来获取一个泛型参数类型的对象数据。
-
Supplier<T>接口又称为生产型接口，即，接口的泛型是什么数据类型，接口中的get()方法就会产生什么数据类型的数据。
import java.util.function.Supplier;
public class DemoSupplier {
public static void main(String[] args) {
//参数为一接口，可以使用匿名内部类，重写抽象方法
String A = getString(new Supplier<String>() {
@Override
public String get() {
return "匿名内部类测试";
}
});
System.out.println(A);
//参数为一函数式接口，可以使用Lambda，重写抽象方法
String B = getString(()->"函数式接口测试");
System.out.println(B);
}
//定义一个方法，方法的参数类型为Supplier<T>类型函数式接口
// 泛型T为String,get()方法就会返回一个String
public static String getString(Supplier<String> s){
return s.get();
}
}
- 练习：求数组最大数
import java.util.function.Supplier;
public class DemoSupplier02 {
public static void main(String[] args) {
int[] array = {1,4,2,45,4,6,34,56,9,0};
int Max = getMax(()->{
int max = array[0];
for (int i = 0; i <array.length; i++) {
if (array[i]>=max){
max=array[i];
}
}
return max;
});
System.out.println(Max);
}
public static Integer getMax(Supplier<Integer> sup){
return sup.get();
}
}
2.Consumer<T>接口
2.1Consumer<T>接口中的抽象方法accept()
-
Consumer<T>接口又称为消费型接口，即，接口的泛型是什么数据类型，接口中的accept()方法就会消费（使用）什么数据类型的数据。 - 所谓“消费”，即使用
accrpt(参数)中的参数，可以使用Lambde表达式重写来决定具体如果处理。
import java.util.function.Consumer;
public class DemoConsumer {
public static void main(String[] args) {
String s = "你好";
method(s,(String a)-> System.out.println(a));
}
public static void method(String a,Consumer<String> c){
c.accept(a);
}
}
2.2Consumer<T>接口中的默认方法andThen()
- 将两个
Consumer<T>接口组合到一起，再进行“消费”
import java.util.Arrays;
import java.util.function.Consumer;
public class Demo03 {
public static void main(String[] args) {
consumer02("Hellow",
(str)->{
System.out.println(Arrays.toString(str.getBytes()));//消费1：将字符串转化为字符数组，再打印输出其ASCII码
},
(str)->{
System.out.println(str.toUpperCase());//消费2：打印字符串大写
});
}
//使用两个Consumer<T>，对字符串str进行两次”消费“
public static void consumer02(String str, Consumer<String> con01, Consumer<String> con02) {
con01.andThen(con02).accept(str);
}
}
- 练习：
import java.util.function.Consumer;
public class Demo04 {
public static void main(String[] args) {
String[] array = {"迪丽热巴,女", "古力娜扎,女", "马尔扎哈,男"};
for (int i = 0; i < array.length; i++) {//遍历字符串数组，其中元素一个一个“消费”
printArray(array[i],
(str) -> {//消费1：元素根据“，”切两段，取出姓名部分
String[] strs = str.split(",");
System.out.print("姓名：" + strs[0] + "。");
},
(str) -> {//消费2：元素根据“，”切两段，取出性别部分
String[] strs = str.split(",");
System.out.println("性别：" + strs[1] + "。");
}
);
}
}
public static void printArray(String a, Consumer<String> name, Consumer<String> sex) {
name.andThen(sex).accept(a);
}
}
3.Predicate<T>接口
3.1Predicate<T>接口中的抽象方法test()
- 对某种类型的数据进行判断，从而得到一个boolean值结果
import java.util.function.Predicate;
public class DemoPredicate {
public static void main(String[] args) {
boolean b = checkString("a", (s) -> {
return s.equals("a");
});
System.out.println(b);
}
public static boolean checkString(String s, Predicate<String> pre) {
return pre.test(s);
}
}
3.2Predicate<T>接口中的三个默认方法
-
and()，表示“与” -
or()，表示“或” -
negate()，表示“非”
import java.util.Arrays;
import java.util.function.Predicate;
public class Demo06 {
public static void main(String[] args) {
boolean[] booleans = check("asd", //传入字符串“asd”
(str) -> str.equals("asdf"),//pre01判断字符串是否为“asdf”
(str) -> str.length() == 3 //pre02判断字符串长度是否为3
);
System.out.println(Arrays.toString(booleans));
}
public static boolean[] check(String str, Predicate<String> pre01, Predicate<String> pre02) {
return new boolean[]{
pre01.and(pre02).test(str),//pre01与pre02
pre01.or(pre02).test(str),//pre01或pre02
pre01.negate().test(str)//pre01取反
};
}
}
- 练习
import java.util.ArrayList;
import java.util.function.Predicate;
public class Demo05 {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
String[] array = {"迪丽热巴,女", "古力娜扎,女", "马尔扎哈,男", "赵丽颖,女"};
for (String i : array) {
boolean b = check(i,
(str) -> {
String[] arr = i.split(",");
return arr[0].length() == 4;
},
(str) -> {
String[] arr = i.split(",");
return arr[1].equals("女");
}
);
if (b) {
list.add(i);
}
}
for (String i : list) {
System.out.println(i);
}
}
public static boolean check(String str, Predicate<String> pre01, Predicate<String> pre02) {
return pre01.and(pre02).test(str);
}
}
4.Function<T,R>接口
4.1Function<T,R>接口中的抽象方法apply()
- 根据一个类型的数据得到另一个类型的数据，根据类型T的参数获取类型R的结果。
import java.util.function.Function;
public class Demo07 {
public static void main(String[] args) {
int a = change("1234", (str) -> {
return Integer.parseInt(str);
});
System.out.println(a);
}
public static Integer change(String s, Function<String, Integer> fun) {
return fun.apply(s);
}
}
4.2Function<T,R>接口中的默认方法andThen()
- 将两个
Function<T,R>接口组合到一起
import java.util.function.Function;
public class Demo {
public static void main(String[] args) {
changes("1234",
str -> Integer.parseInt(str) + 10,//简化版Lambda表达式
str -> {
return str + "";
});
}
public static void changes(String str, Function<String, Integer> fun01, Function<Integer, String> fun02) {
String A = fun01.andThen(fun02).apply(str); //先执行fun01.apply(str)将结果返回，fun02.apply()将结果接收再继续执行
System.out.println(A);
}
}
import java.util.function.Function;
public class DemoFunction {
public static void main(String[] args) {
String str = "赵丽颖,20";
change(str,
(s) -> {//1. 将字符串截取数字年龄部分，得到字符串；
String[] array = s.split(",");
return array[1];
},
s -> Integer.parseInt(s),//2. 将上一步的字符串转换成为int类型的数字；
s -> s + 100//3. 将上一步的int数字累加100，得到结果int数字。
);
}
public static void change(String str, Function<String, String> one//1. 将字符串截取数字年龄部分，得到字符串；
, Function<String, Integer> two//2. 将上一步的字符串转换成为int类型的数字；
, Function<Integer, Integer> three) {//3. 将上一步的int数字累加100，得到结果int数字。
int out = one.andThen(two).andThen(three).apply(str);
System.out.println(out);
}
}
