深入学习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源码

Modifier and TypeMethod and Description
voidaccept(T t)

对给定的参数执行此操作。

default Consumer<T>andThen(Consumer<? super T> after)

返回一个组合的 Consumer ,按顺序执行该操作,然后执行 after操作。

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

 

Modifier and TypeMethod and Description
voidaccept(T t, U u)

对给定的参数执行此操作。

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

返回一个组合的 BiConsumer ,按顺序执行此操作,后跟 after操作。

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

 

Modifier and TypeMethod and Description
voidaccept(double value)

对给定的参数执行此操作。

default DoubleConsumerandThen(DoubleConsumer after)

返回一个组合的 DoubleConsumer ,按顺序执行该操作,然后执行 after操作。

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

 

Modifier and TypeMethod and Description
voidaccept(int value)

对给定的参数执行此操作。

default IntConsumerandThen(IntConsumer after)

返回一个组合的 IntConsumerIntConsumer执行该操作,后跟 after操作。

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

 

Modifier and TypeMethod and Description
voidaccept(long value)

对给定的参数执行此操作。

default LongConsumerandThen(LongConsumer after)

返回一个组合的 LongConsumerLongConsumer执行该操作,后跟 after操作。

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

 

Modifier and TypeMethod and Description
voidaccept(T t, double value)

对给定的参数执行此操作。

package java.util.function;

@FunctionalInterface
public interface ObjDoubleConsumer<T> {

    void accept(T t, double value);
}

 

Modifier and TypeMethod and Description
voidaccept(T t, int value)

对给定的参数执行此操作。

@FunctionalInterface
public interface ObjIntConsumer<T> {

    void accept(T t, int value);
}

 

Modifier and TypeMethod and Description
voidaccept(T t, long value)

对给定的参数执行此操作。

package java.util.function;

@FunctionalInterface
public interface ObjLongConsumer<T> {

    void accept(T t, long value);
}

 

Modifier and TypeMethod and Description
default Predicate<T>and(Predicate<? super T> other)

返回一个组合的谓词,表示该谓词与另一个谓词的短路逻辑AND。

static <T> Predicate<T>isEqual(Object targetRef)

返回根据 Objects.equals(Object, Object)测试两个参数是否相等的 谓词

default Predicate<T>negate()

返回表示此谓词的逻辑否定的谓词。

default Predicate<T>or(Predicate<? super T> other)

返回一个组合的谓词,表示该谓词与另一个谓词的短路逻辑或。

booleantest(T t)

在给定的参数上评估这个谓词。

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

 

Modifier and TypeMethod and Description
default BiPredicate<T,U>and(BiPredicate<? super T,? super U> other)

返回一个组合的谓词,表示该谓词与另一个谓词的短路逻辑AND。

default BiPredicate<T,U>negate()

返回表示此谓词的逻辑否定的谓词。

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

返回一个组合的谓词,表示该谓词与另一个谓词的短路逻辑或。

booleantest(T t, U u)

根据给定的参数来评估这个谓词。

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

 

 

Modifier and TypeMethod and Description
default DoublePredicateand(DoublePredicate other)

返回一个组合的谓词,表示该谓词与另一个谓词的短路逻辑AND。

default DoublePredicatenegate()

返回表示此谓词的逻辑否定的谓词。

default DoublePredicateor(DoublePredicate other)

返回一个组合的谓词,表示该谓词与另一个谓词的短路逻辑或。

booleantest(double value)

在给定的参数上评估这个谓词。

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

 

Modifier and TypeMethod and Description
default IntPredicateand(IntPredicate other)

返回一个组合的谓词,表示该谓词与另一个谓词的短路逻辑AND。

default IntPredicatenegate()

返回表示此谓词的逻辑否定的谓词。

default IntPredicateor(IntPredicate other)

返回一个组合的谓词,表示该谓词与另一个谓词的短路逻辑或。

booleantest(int 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);
    }
}

 

Modifier and TypeMethod and Description
default LongPredicateand(LongPredicate other)

返回一个组合的谓词,表示该谓词与另一个谓词的短路逻辑AND。

default LongPredicatenegate()

返回表示此谓词的逻辑否定的谓词。

default LongPredicateor(LongPredicate other)

返回一个组合的谓词,表示该谓词与另一个谓词的短路逻辑或。

booleantest(long 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);
    }
}

 

 

 

 

 

 

 

 

评论 2
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

wespten

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值