java8四大函数式接口

四大核心函数式接口

名称	一元接口	二元接口	方法	说明
一般函数	Function	BiFunction	apply	输入T，输出R
算子函数（继承Function）	UnaryOperator	BinaryOperator	apply	输入输出同类型
谓词函数	Predicate	BiPredicate	test	输出boolean
消费者	Consumer	BiConsumer	accept	无返回值
生产者	Supplier	-	get	无参数，只有返回值

生产者Supplier

@FunctionalInterface
public interface Supplier<T> {
    T get();
}

案例

双冒号（::）运算符在Java 8中被用作方法引用（method reference），方法引用是与lambda表达式相关的一个重要特性。它提供了一种不执行方法的方法。为此，方法引用需要由兼容的函数接口组成的目标类型上下文。

Supplier<String> str = String::new;
String a = str.get();
String b = str.get();
// false
System.out.println("生产者Supplier获取到的new String是否相等: " + (a == b));
String s = "1234";
Supplier<Integer> length = s::length;
// 4
System.out.println("字符串长度: " + length.get());

消费者Consumer

@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); };
    }
}

案例

Consumer<Integer> consumer1 = x -> System.out.println("消费者Consumer1: " + (x + 2));
Consumer<Integer> consumer2 = x -> System.out.println("消费者Consumer2: " + (x + 4));
consumer1.andThen(consumer2).accept(2);
// 消费者Consumer1: 4
// 消费者Consumer2: 6

谓词函数Predicate

@FunctionalInterface
public interface Predicate<T> {

    /**
     * 函数式接口断言，给一个参数T，返回boolean类型的结果。
     */
    boolean test(T t);

    /**
     * 接收一个Predicate类型，装传入的条件和当前条件以并且的关系过滤数据。
     */
    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方法接收一个Predicate类型，将传入的条件和当前的条件以或者的关系过滤数据。
     */
    default Predicate<T> or(Predicate<? super T> other) {
        Objects.requireNonNull(other);
        return (t) -> test(t) || other.test(t);
    }

    /**
     * 通过传入对象的equals方法进行判断。
     */
    static <T> Predicate<T> isEqual(Object targetRef) {
        return (null == targetRef)
                ? Objects::isNull
                : object -> targetRef.equals(object);
    }
}

案例

Predicate<Integer> predicate = x -> x > 2;
Predicate<Integer> predicate1 = x -> x < 9;
Predicate<Integer> predicate2 = x -> x % 2 == 0;
// false
System.out.println("Predicate: " + predicate.test(2));
// 无限流   i -> i + 1是一个算子函数
Stream<Integer> iterate = Stream.iterate(1, i -> i + 1);
// 1357
iterate.limit(10)
        .filter(predicate
                .and(predicate1)
                .and(predicate2.negate())
                .or(Predicate.isEqual(1)))
        .forEach(System.out::print);

一般函数Function

@FunctionalInterface
public interface Function<T, R> {

    /**
     * 执行函数
     */
    R apply(T t);

    /**
     * a.compose(b) b先执行，a后执行
     */
    default <V> Function<V, R> compose(Function<? super V, ? extends T> before) {
        Objects.requireNonNull(before);
        return (V v) -> apply(before.apply(v));
    }

    /**
     * a.andThen(b) a先执行，b后执行
     */
    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;
    }
}

案例

Function<Integer, Integer> function1 = i -> i + i;
Function<Integer, Integer> function2 = i -> i * i;
// Function compose: 50
System.out.println("Function compose: " + function1.compose(function2).apply(5));
// Function andThen: 100
System.out.println("Function andThen: " + function1.andThen(function2).apply(5));