Supplier接口
Supplier:包含一个无参的方法
- T get():获得结果
- 该方法不需要参数,他会按照某种实现逻辑(由Lambda表达式实现)返回一个数据
- Sopplier接口也被称为生产型接口,如果我们指定了接口的泛型是什么类型,那么接口中的get方法就会产生什么类型的数据给我们用
import java.util.function.Supplier;
public class Supperdame {
public static void main(String[] args) {
String s=use(()-> "张三丰");
System.out.println(s);
int i = use1(() -> 100);
System.out.println(i);
}
//返回一个字符串
private static String use(Supplier<String> sd){
return sd.get();
}
//返回一个整数
private static int use1(Supplier<Integer> sd){
return sd.get();
}
}
使用Supplier接口和Lambda表达式来设计一个方法返回数组中的最大值
public class Suppliedemo {
public static void main(String[] args) {
int[] s={1,24,435,4536,34,53234,534,2334,523,345};
int w = use(() -> {
int max = s[0];
for (int e = 0; e < s.length; e++) {
if (max< s[e]) {
max = s[e];
}
}
return max;
});
System.out.println(w);
}
private static int use(Supplier<Integer> sd){
return sd.get();
}
}
Consumer接口
Consumer:包含两个方法
- void accept(T t):对给定的参数执行此操作
- andthen:返回一个组合的Consumer,依次执行此操作,然后执行after操作
- Consumer接口也被称为消费性接口,他消费的数据的数据由泛型决定
Consumer接口的应用实例
public class Consumerdemo {
public static void main(String[] args) {
//使用Lambda表达式,输出此字符串
use("刘亦菲",(s)-> System.out.println(s));
//使用引用,输出此字符串
use("王祖贤",System.out::println);
//使用Lambda表达式将字符串反转并大写
use("abcdefghijklmn",s-> System.out.println(new StringBuilder(s).reverse().toString()));
//使用Lambda表达式实现asd方法
asd("林青霞",(s)-> System.out.println(s),(s)-> System.out.println(new StringBuilder(s).reverse().toString()));
}
//消费一个字符串
private static void use(String s, Consumer<String> a){
a.accept(s);
}
//用同一个方法消费一个字符串两次
private static void asd(String s,Consumer<String> sd,Consumer<String> ds){
sd.accept(s);
ds.accept(s);
//可以使用andthen方法改进该方法体,使其更简洁
sd.andThen(ds).accept(s);
}
}
//Consumer接口的具体应用:将一个字符串数组拆分,并按格式输出
public class Consumerdemo2 {
public static void main(String[] args) {
String [] we={"林青霞,30","张曼玉,35","王祖贤,39"};
use(we,s-> System.out.print("姓名:"+s.split(",")[0]),
s->System.out.println(",年龄:"+s.split(",")[1])
);
}
private static void use(String[] s, Consumer<String> sd,Consumer<String> ds){
for(String as:s){
sd.andThen(ds).accept(as);
}
}
}
//输出结果:
姓名:林青霞,年龄:30
姓名:张曼玉,年龄:35
姓名:王祖贤,年龄:39
Predicate接口
Predicate:常用的四个方法:
boolean test(T t):对给定的参数进行判断(判断逻辑由Lambda表达式实现)
default Predicate negate():返回一个逻辑的否定,对应逻辑非
default predicate and(Prediccate):返回一个组合判断,对应短路与
default Predicate or(Predicate):返回一个组合判断,对应短路或
Predicate:接口常用于判断参数是否满足指定的条件
Predicate接口的应用实例:
public class predicatedemo {
public static void main(String[] args) {
/* Boolean d = use("Predicate", (s) -> {
return s.length() > 7;
});
System.out.println(d);*/
Boolean d = use("helloworld", s -> s.length() > 6);
System.out.println(d);
Boolean ss = use("hello", s -> s.length() > 6);
System.out.println(ss);
//第二个方法的使用
Boolean b1 = asd("hellow", s -> s.length() > 5, s -> s.length() < 8);
System.out.println(b1);
Boolean d2 = asd("java", s -> s.startsWith("j"), s -> s.length() < 5);
System.out.println(d2);
}
//根据条件判断字符串
//返回值类型是整个Lambda表达式的返回值
private static Boolean use(String s,Predicate<String> sd){
//return sd.negate().test(s);
return sd.test(s);
}
//同一个字符串给出量的不同的判断条件,最后把这两个的结果做逻辑与运算的结果作为最终结果
private static Boolean asd(String s,Predicate<String> s1,Predicate<String> s2){
//未优化
boolean d1 = s1.test(s);
boolean d2 = s2.test(s);
boolean b = d1 && d2;
return b;
//优化
//短路与
//return s1.and(s2).test(s);
//短路或
return s1.or(s2).test(s);
}
}
Predicate的接口实战
public class Predicatedemo1 {
//String[] str ={"林青霞,30","刘岩,34","张曼玉,35","王祖贤,33",“貂蝉,31”};
//字符串数组中有多条信息,通过Predicate接口的拼装将符合要求的筛选到集合中
//要求:姓名长度大于二,年龄大于33
public static void main(String[] args) {
String[] str ={"林青霞,30","刘岩,34","张曼玉,35","王祖贤,33","貂蝉,31"};
ArrayList<String> asd = asd(str, s -> s.split(",")[0].length() > 2, s -> Integer.parseInt(s.split(",")[1]) > 33);
System.out.println(asd);
}
private static ArrayList<String> asd(String [] str, Predicate<String> p1,Predicate<String> p2){
ArrayList<String> as = new ArrayList<>();
for(String s:str){
boolean dd = p1.and(p2).test(s);
if(dd){
as.add(s);
}
}
return as;
}
}
Function接口
Function:常用的两个方法
- R apply:将此函数应用于给定的参数
- andthen:返回一个组合函数,首先将该函数应用于输入,然后将after函数应用于结果
Function<T,R>接口通常用于对于参数进行处理,转换(处理逻辑由Lambda表达式实现)然后返回一个新的值
Function接口的应用实例
public class unctiondem {
public static void main(String[] args) {
//方法一
int asd = asd("1000", s -> Integer.parseInt(s));
System.out.println(asd);
//方法二
String ss = asd(12343, s -> new String().valueOf(s + 10));
System.out.println(ss);
//方法三
int i = sa("123", s -> Integer.parseInt(s) + 234);
System.out.println(i);
}
//方法一,定义一个方法,将一个字符串转换成为一个int类型的数据然后输出
private static int asd(String s, Function<String,Integer>as){
Integer sd = as.apply(s);
return sd;
}
//方法二,定义一个方法,把一个int类型的数据加上10,然后转换成字符串
private static String asd(int e,Function<Integer,String> sd){
return sd.apply(e);
}
//方法三,定义一个方法,把一个字符串转换成int类型的数据,把int类型的数据加上一个整数后在控制台输出
private static int sa(String s,Function<String,Integer> sd){
return sd.apply(s);
}
}
Founction接口实战
public class Funcyiondemo {
/* String s="林青霞,30";
1.将字符串截取到数字年龄部分
2.将上一步的年龄字符串转换成int类型的数据
3.将上一步的int数据加70,得到一个int结果,在控制台输出
*/
public static void main(String[] args) {
String s="林青霞,30";
int i = asd(s, s1 -> Integer.parseInt(s1.split(",")[1]), s2 -> s2 + 70);
System.out.println(i);
}
private static int asd(String s, Function<String,Integer> sd,Function<Integer,Integer>as){
return sd.andThen(as).apply(s);
}
}