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

最新推荐文章于 2024-09-23 08:30:00 发布
最新推荐文章于 2024-09-23 08:30:00 发布
阅读量7.5k 收藏 8
点赞数 1
分类专栏： Java源码 文章标签： 深入学习java源码之Consumer.andThen()与
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_35029061/article/details/86747074
版权

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

返回一个组合的 IntConsumer ， IntConsumer执行该操作，后跟 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)

返回一个组合的 LongConsumer ， LongConsumer执行该操作，后跟 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);
    }
}

 

 

 

 

 

 

 

 

wespten
关注
专栏目录
Java：Consumer、Supplier、Predicate、Function详解
東辰的博客
08-05 2075
前言 在JDK1.8+的环境中，我们会经常使用到Lambda表达式进行编程，会发现Lambda表达式很多参数都需要用到Consumer、Supplier、Predicate与Function这些接口参数，比如我们经常用到的循环写法，中间就用到了这些类型参数，看一下下面这段代码 List<String> list = Arrays.asList("jack", "rose", "zhangsan", "wangwu"); list.forEach(System.out::println); 可以
【睡JDK】Java函数式编程接口详解之Consumer、Function
学而时习之
06-29 2537
今天将介绍Java另外两个函数编程接口Consumer、Function，这两个函数是干嘛的呢？先看看官方的定义： Consumer：表示接受单个输入参数但不返回结果的操作。 Function：表示接受一个参数并生成结果的函数。 一、Consumer 1.1 源代码 @FunctionalInterface public interface Consumer<T> { void accept(T t); default Consumer<T> andThen(C
Java 8：使用compose和andThen组合函数
12-22
在这篇文章中，我将讨论利用 Function 接口提供的两个组合函数—— compose 和 andThen 来实现函数的组合。 　　什么是函数组合？ 　　首先需要创建一些小的可重用函数，然后将这些小函数组合为新函数。 　　现在，我们怎么利用 compose 和 andThen 方法来完成函数的组合？ 　　首先，定义两个简单的函数—— times2 和 squared。 　　Function<Integer> times2 = e -> e * 2; 　　Function<Integer> squared = e -> e * e; 　　接下来
java函数式接口Consumer接口类中andThen方法详解
王轩的博客
03-10 1727
【代码】java函数式接口Consumer接口类中andThen方法详解。
Java函数式BiPredicate接口介绍、应用场景和示例代码
最新发布
a_beiyo的博客
09-23 716
在 Java 中，是包中的一个函数式接口。它代表一个接受两个输入参数并返回布尔值的谓词函数。简单来说，接受两个参数并对它们进行测试，返回一个boolean值。是 Java 8 引入的函数式接口，能够高效地处理两个输入的布尔值测试，并支持条件组合操作。它在流处理、条件验证和复杂逻辑组合中都可以发挥作用。通过使用，你可以编写更简洁、更易读的代码，利用函数式编程的优势来简化逻辑判断。
Predicate和Consumer接口– Java 8中java.util.function包下的接口
weixin_33739541的博客
04-05 174
原文链接 作者:MohamedSanaulla译者:李璟(jlee381344197@gmail.com) 早先我写了一篇《函数式接口》，探讨了部分Java8中函数式接口的用法。我也提及了Predicate接口属于java.util.function包，在这篇文章中，我将展示如何应用Predicate接口和Consumer接口。 一起看...
java consumer 用法,Java 8-Consumer andThen的用法
weixin_33309048的博客
02-19 747
I have below POC to use Java 8 feature.I want to update DB after accept method. Is it good to go with andThen()? When is this method called? Who calls it?What is the basic use of andThen() method? Lo...
Consummer＜T＞函数式接口中的andThen方法
soldier_jw的博客
08-05 705
也可以理解为：c1.andThen(c2)是将c1和c2合成一个新的c3然再执行accept()， c3的方法逻辑是先执行c1.accept(t)逻辑，然后再执行c2.accept(t)。
Java函数式编程接口入门及三大核心接口（Consumer、Function、Predicate）
Dylan Lin的博客
03-23 1239
文章目录一、简介二、函数式编程接口入门三、Java函数式接口（一）Consumer（二）Function（三）Predicate 一、简介 在Java中我们普遍采用面向对象编程（Object-oriented Programming，缩写：OOP），其是一种传统的命令式编程，而函数式编程（Functional Programming）是Java8新引入的一种编程范式，初次之外还有过程式编程（Pro...
JDK1.8函数式接口Function、Consumer、Predicate、Supplier
Agger的博客
11-27 946
JDK1.8函数式接口Function、Consumer、Predicate、Supplier 1. 函数式接口定义 函数式接口（Functional Interface）：有且仅有一个抽象方法的接口，但可以有多个非抽象方法的接口 函数式接口，即适用于函数式编程场景的接口，可以被隐式转换为Lambda表达式来表示接口的一个实现；jdk8以前是使用匿名类实现的。 示例：jdk1.8 使用注解@...
Java基础：JDK8新特性(1)
2401_84408217的博客
04-18 973
外链图片转存中…(img-sa9tuGne-1713438208857)][外链图片转存中…(img-pW48VjJK-1713438208858)][外链图片转存中…(img-g0pB2bgt-1713438208858)]
Predicate使用方法
01-09
Predicate的简单实用，and 和or 以及其他方法的简单运用
java consumer_Java Predicate及Consumer接口函数代码实现解析
weixin_29104059的博客
02-16 355
Predicate函数编程Predicate功能判断输入的对象是否符合某个条件。官方文档解释到：Determines if the input object matches some criteria.了解Predicate接口作用后，在学习Predicate函数编程前，先看一下Java 8关于Predicate的源码：@FunctionalInterfacepublic interface Pr...
被内置函数接口Consumer的andThen方法惊艳到了
qq_33994014的博客
08-16 1126
被内置函数接口Consumer的andThen方法惊艳到了
145-Predicate接口-用来判断，里面有个test方法
shwjakak的博客
11-07 548
1.
常用的函数式接口_Consumer接口的默认方法andThen
Leon_Jinhai_Sun的博客
03-08 1753
默认方法：andThen 如果一个方法的参数和返回值全都是Consumer 类型，那么就可以实现效果：消费数据的时候，首先做一个操作，然后再做一个操作，实现组合。而这个方法就是Consumer 接口中的default方法andThen 。下面是JDK的源代码： default Consumer<T> andThen(Consumer<? super T> after)...
Lambda-Consumer-andThen
qq_26471769的博客
06-22 332
andThen的用法。 @Test public void lambdaFc(){ Consumer <Student>con1=(Student s)->{ out.println(s.getName()); s.setName("李四"); out.println(s.getName()); }; Consumer <Student>c
笔记--关于Predicate中test方法的简单使用
weixin_43103583的博客
05-08 472
Predicate中test使用笔记
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

wespten

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

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

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

打赏作者

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

抵扣说明：

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

余额充值