Supplier:
Suppler是一个生产型接口,此接口指定什么泛型,那么接口中的get方法就返回什么类型的数据
import java.util.function.Supplier;
public class Demo05SupplierTest {
private static int getMax(Supplier<Integer> sup) {
return sup.get();
}
public static void main(String[] args) {
int[]arr = {100,50,200,66,38,88};
int Max = getMax(()->{
int max = arr[0];
for (int i : arr) {
if (max < i)
max = i;
}
return max;
});
System.out.println("最大值:"+Max);
}
}Consumer:
Consumer是一个消费型接口,此接口指定什么泛型,那么接口中的accept方法就返回什么类型的数据
import java.util.function.Consumer;
public class Demo02Consumer_Test {
private static void getMessage(String[]arr, Consumer<String> con1 ,Consumer<String> con2){
for (String s : arr) {
con1.andThen(con2).accept(s);
}
}
public static void main(String[] args) {
String[]arr = {"hahaha,nv","xixixi,nv","dadada,nan"};
getMessage(arr,(massage)->{
String s1 = massage.split(",")[0];
System.out.print("name:"+s1);
},(messge)->{
String s2 = messge.split(",")[1];
System.out.println(",sex:"+s2);
});
}
}Predicate
用于判断的方法,返回值是布尔值,有三种默认方法and(与), or(或), negate(非)
import java.util.function.Predicate;
public class Demo01Predicate {
private static boolean chickStringLength(String s, Predicate<String> pre){
return pre.test(s);
}
public static void main(String[] args) {
String s1 = "sa;fasf";
String s2 = "1fdfsa";
boolean b = chickStringLength(s1,s -> s.contains("a"));
boolean b1 = chickStringLength(s2,s -> s.length()>6);
System.out.println(b+","+b1);
}
}Predicate的默认方法之and,把判断结果进行相与运算:
import java.util.function.Predicate;
public class Demo02Predicate_and {
private static boolean chickString_and(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 = "adfghjd";
//lambda表达式
boolean b = chickString_and(s,
//判断长度是否大于6
s1 -> s1.length()>6,
//判断是否包括"a"
s1 -> s1.contains("a") );
System.out.println(b); //输出两个判断结果的"与".
}
}另一个使用案例:
import java.util.ArrayList;
import java.util.function.Predicate;
//对给定的数组中的元素进行筛选,选出名字是4个字的女生
public class Predicate_test {
private static ArrayList<String> filter(String[]arr, Predicate<String>pre1, Predicate<String> pre2){
//创建一个新集合
ArrayList<String> list = new ArrayList<>();
//进行判断是否满足条件
for (String s : arr) {
boolean b = pre1.and(pre2).test(s);
//如果满足条件
if (b){
list.add(s);
}
}
//返回集合
return list;
}
public static void main(String[] args) {
//被筛选的字符串数组
String[] arr = {"古力娜扎,女","迪丽热巴,女","ydaiq,女"};
//调用Predicate_test方法
ArrayList<String> list = filter(arr,
//判断名字长度
s -> s.split(",")[0].length() == 4,
//判断性别
s -> s.split(",")[1].equals("女"));
//遍历list集合
for (String s : list) {
System.out.println(s);
}
}
}
//结果: 古力娜扎,女
// 迪丽热巴,女Predicate的默认方法之or,把判断结果进行"或"运算:
import java.util.function.Predicate;
public class Demo03Predicate_or {
private static boolean chinckString_or(String s, Predicate<String> pre1, Predicate<String> pre2){
return pre1.or(pre2).test(s); //等效于return pre1.test(s) || pre2.test(s);
}
public static void main(String[] args) {
String s = "aadfghfsd";
boolean b = chinckString_or(s,
//判断是否长于6,
s1 -> s1.length()>6, //成立
//判断是否包含"j"
s1 -> s1.contains("j")); //不成立
//只有一条成立,进行或运算结果为true所以输出true
System.out.println(b);
}
}Predicate的默认方法之negate,把判断结果取"非":
import java.util.function.Predicate;
public class Demo04Predicate_negate {
private static boolean chinckString_negate(String s, Predicate<String> pre) {
return pre.negate().test(s); //等效于return !pre1.test(s);
}
public static void main(String[] args) {
String s = "aaaaaa";
//对判断结果进行取反
boolean b = chinckString_negate(s, s1 -> s1.contains("a"));
//判断结果是true,所以输出false
System.out.println(b);
}
}Function:
用于一个类型的数据转换为另一个类型,前者是前置条件,后者是后置条件.Function接口中主要的抽象方法是" apply ",使用场景,例如:将 String 类型转换为 Integer 类型.
import java.util.function.Function;
//Function的作用是数据类型的转换
public class Demo01Function {
private static Integer change(String s , Function<String,Integer>fun){
return fun.apply(s);
}
public static void main(String[] args) {
String s = "123456";
//调用change方法
int in = change(s,s1 -> Integer.parseInt(s));
System.out.println(in);
//结果:123456
}
}Function接口的另一个抽象方法 andthen ,该抽象方法用于拼接两个Function接口
import java.util.function.Function;
public class demo02Funcation_two_change {
private static String change(String s, Function<String,Integer> fun1, Function<Integer,String> fun2){
String ss = fun1.andThen(fun2).apply(s);
return ss;
}
public static void main(String[] args) {
String s = "123";
String ss = change(s, (s1)->{return Integer.parseInt(s1) + 10;} ,(s2) -> { return s2+"";});
System.out.println(ss);
//简化lambda表达式
String ss1 = change(s, s1 -> Integer.parseInt(s) + 20, s2 -> s2+"");
System.out.println("简化的Lambda表达式:" + ss1);
//输出结果: 133
// 简化的Lambda表达式:143
}
}Function接口的抽象方法 andthen ,还能用于更多的接口的连接,下面给一个三个接口的例子:
import java.util.function.Function;
//先截取字符串的数字部分,后转换为Integer类型,然后把Integer类型的数字加100,最后定型为Integer.
public class demo03Function_three_change {
private static Integer change(String s, Function<String,String> fun1,
Function<String, Integer> fun2, Function<Integer,Integer> fun3){
return fun1.andThen(fun2).andThen(fun3).apply(s);
}
public static void main(String[] args) {
String s = "ydaiq,19";
int in = change(s, s1 -> s.split(",")[1], s1 -> Integer.parseInt(s1), s1 -> s1 + 100);
System.out.println(in);
}
}
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
