java.util.function包下的接口
java.util.function包中有很多函数式接口,他们分为四种类型:
- 逻辑判断接口
- 有输入输出的接口
- 无输入有输出的接口
- 有输入无输出的接口
1. 逻辑判断接口
逻辑判断接口的代表就是java.util.function.Predicate接口,这个接口的方法返回一个布尔值。
这个接口的定义如下:
package java.util.function;
import java.util.Objects;
@FunctionalInterface
public interface Predicate<T> {
/*
判断是否符合条件
*/
boolean test(T t);
/*
可以连接到一个Predicate后面,进行and判断
*/
default Predicate<T> and(Predicate<? super T> other) {
Objects.requireNonNull(other);
return (t) -> test(t) && other.test(t);
}
/*
进行串联非操作
*/
default Predicate<T> negate() {
return (t) -> !test(t);
}
/*
可以串联起来,进行or判断
*/
default Predicate<T> or(Predicate<? super T> other) {
Objects.requireNonNull(other);
return (t) -> test(t) || other.test(t);
}
static <T> Predicate<T> isEqual(Object targetRef) {
return (null == targetRef)
? Objects::isNull
: object -> targetRef.equals(object);
}
}
举例:
package javademo.lambda.function;
import java.util.function.Predicate;
public class Demo1 {
public static void main(String[] args) {
//用Lambda实现接口,判断输入s是否不等于0
Predicate<Double> isNoZero = (s) -> s.compareTo(Double.valueOf("0")) != 0;
//用Lambda实现接口,判断输入r是否大于0
Predicate<Double> isGtZero = (r) -> r.compareTo(Double.valueOf("0")) > 0;
//用Lambda实现接口,判断输入r是否大于100
Predicate<Double> isGt100 = (r) -> r.compareTo(Double.valueOf("100")) > 0;
//调用实现的方法
System.out.println(isNoZero.test(0d));
System.out.println(isNoZero.test(8d));
//两个方法进行串联判断,and关系,都为真才返回真
System.out.println(isNoZero.and(isGtZero).test(-5d));
System.out.println(isNoZero.and(isGtZero).test(8d));
//串联,前两个and,再和后面的or
System.out.println(isNoZero.and(isGtZero).or(isGt100).test(200d));
//非判断
System.out.println(isNoZero.negate().test(0d));
}
}
2. 有输入输出的接口
代表是java.util.function.Function接口,它接受一个参数,返回一个参数。还可以将多个方法串联起来。
Function接口定义如下,主要有三个方法apply、compose、andThen:
package java.util.function;
import java.util.Objects;
@FunctionalInterface
public interface Function<T, R> {
//执行方法
R apply(T t);
//串联多个函数,先执行compose函数参数的方法,再执行调用者
default <V> Function<V, R> compose(Function<? super V, ? extends T> before) {
Objects.requireNonNull(before);
return (V v) -> apply(before.apply(v));
}
//串联多个函数,先执行调用者,再执行参数
default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) {
Objects.requireNonNull(after);
return (T t) -> after.apply(apply(t));
}
static <T> Function<T, T> identity() {
return t -> t;
}
}
举例:
package javademo.lambda.function;
import java.util.function.Function;
public class FunctionDemo {
public static void main(String[] args) {
//根据半径计算圆的面积
Function<Double, Double> circularArea = (r) -> Math.PI * r * r;
//计算平方根,求正方形的边长
Function<Double, Double> squareLength = (a) -> Math.sqrt(a);
System.out.println("半径为5.5的圆,面积为:" + circularArea.apply(5.5));
System.out.println("面积为100的正方形,边长为:" + squareLength.apply(100d));
//先执行计算圆面积,再执行开方
//andThen是先执行调用者circularArea、再执行参数squareLength
System.out.println("半径为5.5的圆面积相当于边长为多少的正方形的面积:" + circularArea.andThen(squareLength).apply(5.5));
//先开方,再计算圆的面积
//compose是先执行参数squareLength,再执行调用者circularArea
System.out.println("以面积为100的正方形边长为半径,计算圆的面积:" +circularArea.compose(squareLength).apply(100d));
}
}
BiFunction接口是输入两个参数,输出一个参数。
举例:
package javademo.lambda.function;
import java.util.function.BiFunction;
public class BiFunctionDemo {
public static void main(String[] args) {
//两个输入参数,输出一个参数
BiFunction<Double, Double, Double> add = (a, b) -> a + b;
System.out.println("1+2:" + add.apply(1d, 2d));
}
}
3. 无输入有输出的接口
代表是java.util.function.Supplier接口,它比较奇怪,只有输出,没有输入。
它的定义也很简单:
package java.util.function;
@FunctionalInterface
public interface Supplier<T> {
//获取结果,没有输入参数
T get();
}
举例:
package javademo.lambda.function;
import java.text.DecimalFormat;
import java.util.function.Supplier;
public class SupplierDemo {
public static void main(String[] args) {
//只有输出,没有输入参数
Supplier<Double> pi = () -> {
DecimalFormat df = new DecimalFormat("#.00");
return Double.valueOf(df.format(Math.PI));
};
System.out.println("得到两位小数的PI值:" + pi.get());
}
}
4. 有输入无输出的接口
代表是java.util.function.Supplier接口。它只有输入,没有输出,比如IList的forEach操作。
定义如下:
package java.util.function;
import java.util.Objects;
@FunctionalInterface
public interface Consumer<T> {
//执行操作
void accept(T t);
//串联操作
default Consumer<T> andThen(Consumer<? super T> after) {
Objects.requireNonNull(after);
return (T t) -> { accept(t); after.accept(t); };
}
}
举例:
package javademo.lambda.function;
import java.util.function.Consumer;
public class ConsumerDemo {
public static void main(String[] args) {
//只有输入,没有输出
Consumer<String> myPrint = (r) -> System.out.println("计算结果是:" + r);
Consumer<String> myEnd = (input) -> System.out.println("计算结束:"+input);
myPrint.accept("2");
myPrint.andThen(myEnd).accept("1+1");
}
}
5. 其他接口
java.util.function包下的其他接口,都可以归到这四类的其中一类中。