深入学习java源码之Consumer.andThen()与Predicate.test()

深入学习java源码之Consumer.andThen()与Predicate.test()

Consumer消费数据函数式接口

这个方法是用来消费数据的,如何消费,消费规则自己定义.

import java.util.function.Consumer;

/**
 * 使用Consumer函数式接口实现格式化输出
 */
public class ConsumerDemo2 {

    public static void printInfo(String[] strArr, Consumer<String> con1, Consumer<String> con2){

        for (int i = 0; i < strArr.length; i++) {
            con1.andThen(con2).accept(strArr[i]);
        }

    }

    public static void main(String[] args) {
        String[] strArr = {"迪丽热巴,女","郑爽,女","杨紫,女"};
        printInfo(strArr,(message)->{
            System.out.print("姓名:" + message.split(",")[0] + "。  ");
        },(message)->{
            System.out.println("性别:" + message.split(",")[1] + "。");

        });
    }
}

Consumer<T>

提供一个T类型的输入参数，不返回执行结果

accept(T t)

StringBuilder sb = new StringBuilder("Hello ");
Consumer<StringBuilder> consumer = (str) -> str.append("Jack!");
consumer.accept(sb);
System.out.println(sb.toString());  // Hello Jack!

andThen(Consumer<? super T> after)

Consumer<StringBuilder> consumer1 = (str) -> str.append(" Bob!");
consumer.andThen(consumer1).accept(sb);
System.out.println(sb.toString());  // Hello Jack! Bob!

BiConsumer<T,U>

提供两个自定义类型的输入参数，不返回执行结果

accept(T t, U u)

StringBuilder sb = new StringBuilder();
BiConsumer<String, String> biConsumer = (a, b) -> {
  sb.append(a);
  sb.append(b);
};
biConsumer.accept("Hello ", "Jack!");
System.out.println(sb.toString());  // Hello Jack!

andThen(BiConsumer<? super T,? super U> after)

BiConsumer<String, String> biConsumer1 = (a, b) -> {
  System.out.println(a + b);
};
biConsumer.andThen(biConsumer1).accept("Hello", " Jack!"); // Hello Jack!

DoubleConsumer

表示接受单个double值参数，但不返回结果的操作

“引用方法”(引用方法是用的冒号“::”来进行方法的调用)

accept(double value)

DoubleConsumer doubleConsumer = System.out::println;
doubleConsumer.accept(1.3); // 1.3

andThen(DoubleConsumer after)

DoubleConsumer doubleConsumer1 = System.out::println;
doubleConsumer.andThen(doubleConsumer1).accept(1.3); // 1.3  1.3

ObjDoubleConsumer<T>

表示接受object值和double值，但是不返回任何操作结果

accept(T t, double value)

ObjDoubleConsumer<String> doubleConsumer = (obj, doub)
  -> System.out.println(obj + doub);
doubleConsumer.accept("金额：", 222.66); // 金额：222.66

Predicate<T>

对给定的输入参数执行操作，返回一个boolean类型的结果（布尔值函数）

test(T t)

Predicate<Integer> predicate = number -> number != 0;
System.out.println(predicate.test(10));    //true

and(Predicate<? super T> other)

predicate = predicate.and(number -> number >= 10);
System.out.println(predicate.test(10));    //true

or(Predicate<? super T> other)

predicate = predicate.or(number -> number != 10);
System.out.println(predicate.test(10));    //true

negate()

predicate = predicate.negate();
System.out.println(predicate.test(10));    //false

BiPredicate<T,U>

对给定的两个输入参数执行操作，返回一个boolean类型的结果（布尔值函数）

test(T t, U u)

BiPredicate<Integer, Integer> biPredicate = (a, b) -> a != b;
System.out.println(biPredicate.test(1, 2)); // true

and(BiPredicate<? super T,? super U> other)

biPredicate = biPredicate.and((a, b) -> a.equals(b));
System.out.println(biPredicate.test(1, 2)); // false

or(BiPredicate<? super T,? super U> other)

biPredicate = biPredicate.or((a, b) -> a == b);
System.out.println(biPredicate.test(1, 1)); // true

negate()

biPredicate = biPredicate.negate();
System.out.println(biPredicate.test(1, 2)); // false

DoublePredicate

对给定的double参数执行操作，返回一个boolean类型的结果（布尔值函数）

test(double value)

DoublePredicate doublePredicate = doub -> doub != 0;
System.out.println(doublePredicate.test(10)); // true

and(DoublePredicate other)

doublePredicate = doublePredicate.and(doub -> doub < 2);
System.out.println(doublePredicate.test(1.7)); // true

or(DoublePredicate other)

doublePredicate = doublePredicate.or(doub -> doub > 2);
System.out.println(doublePredicate.test(1.7)); // true

negate()

doublePredicate = doublePredicate.negate();
System.out.println(doublePredicate.test(1.7)); // false

java源码

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 java.util.function;
import java.util.Objects;

@FunctionalInterface
public interface BiConsumer<T, U> {

    void accept(T t, U u);

    default BiConsumer<T, U> andThen(BiConsumer<? super T, ? super U> after) {
        Objects.requireNonNull(after);

        return (l, r) -> {
            accept(l, r);
            after.accept(l, r);
        };
    }
}

package java.util.function;
import java.util.Objects;

@FunctionalInterface
public interface DoubleConsumer {

    void accept(double value);

    default DoubleConsumer andThen(DoubleConsumer after) {
        Objects.requireNonNull(after);
        return (double t) -> { accept(t); after.accept(t); };
    }
}

package java.util.function;
import java.util.Objects;

@FunctionalInterface
public interface IntConsumer {

    void accept(int value);

    default IntConsumer andThen(IntConsumer after) {
        Objects.requireNonNull(after);
        return (int t) -> { accept(t); after.accept(t); };
    }
}

package java.util.function;
import java.util.Objects;

@FunctionalInterface
public interface LongConsumer {

    void accept(long value);

    default LongConsumer andThen(LongConsumer after) {
        Objects.requireNonNull(after);
        return (long t) -> { accept(t); after.accept(t); };
    }
}

package java.util.function;

@FunctionalInterface
public interface ObjDoubleConsumer<T> {

    void accept(T t, double value);
}

@FunctionalInterface
public interface ObjIntConsumer<T> {

    void accept(T t, int value);
}

package java.util.function;

@FunctionalInterface
public interface ObjLongConsumer<T> {

    void accept(T t, long value);
}

package java.util.function;

import java.util.Objects;


@FunctionalInterface
public interface Predicate<T> {

    boolean test(T t);

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

    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 java.util.function;

import java.util.Objects;

@FunctionalInterface
public interface BiPredicate<T, U> {

    boolean test(T t, U u);

    default BiPredicate<T, U> and(BiPredicate<? super T, ? super U> other) {
        Objects.requireNonNull(other);
        return (T t, U u) -> test(t, u) && other.test(t, u);
    }

    default BiPredicate<T, U> negate() {
        return (T t, U u) -> !test(t, u);
    }

    default BiPredicate<T, U> or(BiPredicate<? super T, ? super U> other) {
        Objects.requireNonNull(other);
        return (T t, U u) -> test(t, u) || other.test(t, u);
    }
}

package java.util.function;

import java.util.Objects;

@FunctionalInterface
public interface DoublePredicate {

    boolean test(double value);

    default DoublePredicate and(DoublePredicate other) {
        Objects.requireNonNull(other);
        return (value) -> test(value) && other.test(value);
    }

    default DoublePredicate negate() {
        return (value) -> !test(value);
    }

    default DoublePredicate or(DoublePredicate other) {
        Objects.requireNonNull(other);
        return (value) -> test(value) || other.test(value);
    }
}

package java.util.function;

import java.util.Objects;

@FunctionalInterface
public interface IntPredicate {

    boolean test(int value);

    default IntPredicate and(IntPredicate other) {
        Objects.requireNonNull(other);
        return (value) -> test(value) && other.test(value);
    }

    default IntPredicate negate() {
        return (value) -> !test(value);
    }

    default IntPredicate or(IntPredicate other) {
        Objects.requireNonNull(other);
        return (value) -> test(value) || other.test(value);
    }
}

package java.util.function;

import java.util.Objects;

@FunctionalInterface
public interface LongPredicate {

    boolean test(long value);

    default LongPredicate and(LongPredicate other) {
        Objects.requireNonNull(other);
        return (value) -> test(value) && other.test(value);
    }

    default LongPredicate negate() {
        return (value) -> !test(value);
    }

    default LongPredicate or(LongPredicate other) {
        Objects.requireNonNull(other);
        return (value) -> test(value) || other.test(value);
    }
}