赞
踩
源码:
该接口为一个供给型接口,抽象方法:T get():该方法不需要参数,它会按照某种逻辑,返回一个具体的数据
注意:该接口也被称为生产型接口,如果指定了泛型是什么类型,那类中的get方法就会返回 一个该类型的一个具体数据。返回的数据,由该接口的实现类对象决定。
这里我们以一个计算数组的最大值为例,代码如下:
package com.wjf.lambda.fun;
import java.util.Arrays;
import java.util.function.Supplier;
public class SupplierTest {
public static void main(String[] args) {
fun1(()->{
int arr[]={22,33,55,66,44,88,99};
//计算出数组中的最大值
Arrays.sort(arr);
return arr[arr.length-1];
});
}
private static void fun1(Supplier<Integer> supplier){
//get()是一个无参的有返回值的
Integer max = supplier.get();
System.out.println("max="+max);
}
}
源码:
接口名称:Consumer
抽象方法:void accept(T t):消费一个参数数据
概述:该接口中的方法可以接收一个参数,接收的参数类型由泛型指定,对参数的操作 方式根据该接口的实现类决定,不需要返回值。
拓展的非抽象方法:
default Consumer andThen(Consumer<? super T> after) :
返回一个组合的 Consumer ,按顺序执行该操作,然后执行 after操作。
这里我们以一个字符串大小写转换为例:
package com.wjf.lambda.fun;
import java.util.function.Consumer;
public class ConsumerTest {
public static void main(String[] args) {
test((msg1)->{
System.out.println(msg1+"->转换为小写:"+msg1.toLowerCase());
},(msg2)->{
System.out.println(msg2+"->转换为大写:"+msg2.toUpperCase());
});
}
private static void test(Consumer<String> c1,Consumer<String> c2){
String str="Hello World";
// c1.accept(str);
// c2.accept(str);
// c1.andThen(c2).accept(str);
c2.andThen(c1).accept(str);
}
}
源码:
1、接口名:Function<T,R>
2、抽象方法:R apply(T):接收一个数据,操作数据之后,返回一个新的数据
3、概述:
该接口可以接收一个数据,数据的类型根据泛型指定,然后通过该接口的实现类对象对 该数据进行操作,操作之后返回一个新的数据。
4、拓展的非抽象方法:default Function andThen(Function f):
先通过调用者对象处理参数,将处理的结果再通过f对象处理,将两个处理的结果进行返回。
这里我以一个字符串转数字,然后数字再转数字为例:
package com.wjf.lambda.fun;
import java.util.function.Function;
public class FunctionTest {
public static void main(String[] args) {
test((msg1)->{
return Integer.parseInt(msg1);
},(msg2)->{
return msg2*10;
});
}
public static void test(Function<String,Integer> f1,Function<Integer,Integer> f2){
// Integer i1 = f1.apply("666");
// Integer i2 = f2.apply(i1);
// Integer i2 = f1.andThen(f2).apply("666");
Integer i2 = f2.compose(f1).apply("666");
System.out.println("i2="+i2);
}
}
源码:
boolean test(T t):对数据做出指定的判断
该接口是一个判断接口,接口可以接收一个指定泛型的参数,并根据该接口的实现类 对象对该参数做出对应的判断,返回只为boolean类型
and(Predicate p):先将参数通过调用者判断真假,再将参数通过p判断真假,全真 为真,否则为假
or(Predicate p):全假为假,否则为真
negate():取反
这里我们以是否包含单个字母为例:
package com.wjf.lambda.fun;
import java.util.function.Predicate;
public class PredicateTest {
public static void main(String[] args) {
test((msg1)->{
return msg1.contains("H");
},(msg2)->{
return msg2.contains("W");
});
}
private static void test(Predicate<String> p1,Predicate<String> p2){
//p1包含H p2包含W
boolean bb1 = p1.and(p2).test("Hello");
//p1包含H 或者 p2包含W
boolean bb2 = p1.or(p2).test("Hello");
//p1 不包含H
boolean bb3 = p1.negate().test("Hello");
System.out.println(bb1);
System.out.println(bb2);
System.out.println(bb3);
}
}
Copyright © 2003-2013 www.wpsshop.cn 版权所有,并保留所有权利。