Java8 Lambda java.util.function下的接口

java.util.function包下的接口

java.util.function包中有很多函数式接口，他们分为四种类型：

1. 逻辑判断接口
2. 有输入输出的接口
3. 无输入有输出的接口
4. 有输入无输出的接口

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包下的其他接口，都可以归到这四类的其中一类中。