java Consumer接口与示例

目录一、consumer使用示例代码1：示例代码2：示例代码3：示例代码4：二、Consumer相关的接口Java 8 中的 Consumer 是一个函数接口，它可以接受一个泛型 <T> 类型参数，进行处理后无任何返回值。accept(T) 方法是 Consumer 函数式接口的函数方法，传入一个任意类型，无返回值，可以用于 Lambda 表达式和方法引用。andThen(Consum

西凉的悲伤

11249人浏览 · 2022-04-21 19:19:40

西凉的悲伤 · 2022-04-21 19:19:40 发布

accept(T) 方法：是 Consumer 函数式接口的函数方法，传入一个任意类型，无返回值，可以用于 Lambda 表达式和方法引用。
andThen(Consumer) 方法：可以传入一个 Consumer ，返回组合了两个 Consumer 后的 Consumer ，传入的 Consumer 不能为 null，否则会得到 NullPointerException 。

通俗的来说：
Consumer 相当于一个放东西的容器，你可以在这个容器里定义一个带有入参的代码块，然后返回 T 类型，当调用 accept(T) 方法的时候才会去执行容器里的代码。

一、consumer使用

示例代码1：

import java.util.function.Consumer;

public class MainServer {
    public static void main(String[] args) throws InterruptedException {
        Consumer<String> first = x -> System.out.println("1."+x.toLowerCase());
        Consumer<String> second = y -> System.out.println("2." + y);
        System.out.println("开始");
        Consumer<String> result = first.andThen(second);
        //调用了accept 后，会先执行 first 容器里的代码，再执行 second 容器里的代码
        result.accept("A");
    }
}

输出：

开始
1.a
2.A

示例代码2：

筛选出学生名叫 aa 的学生。

import com.alibaba.fastjson.JSON;
import com.Student;

import java.util.ArrayList;
import java.util.List;
import java.util.function.Consumer;
import java.util.stream.Stream;

public class MainServer {
    public static void main(String[] args)  {
       List<Student> lisiList = new ArrayList<>();
        Consumer <Student> consumer  = x -> {
            if (x.name.equals("aa")){
                lisiList.add(x);
            }
        };
        Stream.of(
                new  Student("aa",99),
                new  Student("bb",98),
                new  Student("cc",85),
                new  Student("dd",69),
                new  Student("ee",77),
                new  Student("ff",83),
                new  Student("aa",82)
        ).forEach(consumer);

        System.out.println(JSON.toJSONString(lisiList));
    }
}

输出：

[{"name":"aa","score":99},{"name":"aa","score":82}]

示例代码3：

筛选出学生名叫 aa 并且分数大于 90 的学生。下面代码 forEach 里每个学生都会被当做参数传到 consumer 容器里执行一遍起到过滤作用。

import com.alibaba.fastjson.JSON;
import com.xu.tao.model.Student;

import java.util.ArrayList;
import java.util.List;
import java.util.function.Consumer;
import java.util.stream.Stream;

public class MainServer {
    public static void main(String[] args) {
        List<Student> lisiList = new ArrayList<>();
        Consumer <Student> consumer  = x -> {
            if (x.name.equals("aa")){
                lisiList.add(x);
            }
        };

        consumer = consumer.andThen(
                x -> lisiList.removeIf(y -> y.score > 90)
        );
        //forEach 本身就接收 Consumer类型，所以不用调用 accept 方法
        Stream.of(
                new  Student("aa",99),
                new  Student("bb",98),
                new  Student("cc",85),
                new  Student("dd",69),
                new  Student("ee",77),
                new  Student("ff",83),
                new  Student("aa",82)
        ).forEach(consumer);

        System.out.println(JSON.toJSONString(lisiList));
        }
    }

输出：

[{"name":"aa","score":82}]

示例代码4：

public class Student  {
    public String name;
    public int score;

    public Student (String name ,int score){
        this.name=name;
        this.score=score;
    }

    public Student (){}

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getScore() {
        return score;
    }

    public void setScore(int score) {
        this.score = score;
    }

    @Override
    public String toString() {
        return   name + ": " + score;
    }
}

import com.xu.tao.model.Student;

import java.util.Arrays;
import java.util.List;
import java.util.function.Consumer;

public class MainServer {
    public static void main(String[] args) {
        List<Student> students = Arrays.asList(
                new Student( "John",5),
                new Student("Jane",2),
                new Student("Jack",3)
        );

        Consumer<Student> raiser = e -> {e.score = e.score * 2;};
        raiseStudents(students, System.out::println);
        System.out.println("开始andThen");
        raiseStudents(students, raiser.andThen(System.out::println));
    }

    private static void raiseStudents(List<Student> employees, Consumer<Student> fx) {
        for (Student e : employees) {
            fx.accept(e);
        }
    }
}

输出;

John: 5
Jane: 2
Jack: 3
开始andThen
John: 10
Jane: 4
Jack: 6

二、BiConsumer使用

BiConsumer和上面的Consumer非常相似，只不过BiConsumer可以接受两个泛型 <T> 类型参数，进行处理后无任何返回值。

示例代码一：

import java.util.*;
import java.util.function.BiConsumer;
public class MainServer {
    public static void main(String[] args) throws Exception {
        List<Integer> lista = new ArrayList<>();
        lista.add(2);
        lista.add(1);
        lista.add(3);

        List<Integer> listb = new ArrayList<>();
        listb.add(2);
        listb.add(1);
        listb.add(2);

        // 第一个BiConsumer
        BiConsumer<List<Integer>, List<Integer>> equals = (list1, list2) -> {
            if (list1.size() != list2.size()) {
                System.out.println("False");
            } else {
                for (int i = 0; i < list1.size(); i++)
                    if (list1.get(i) != list2.get(i)) {
                        System.out.println("False");
                        return;
                    }
                System.out.println("True");
            }
        };
        // 第二个BiConsumer
        BiConsumer<List<Integer>, List<Integer> > disp = (list1, list2) -> {
            list1.stream().forEach(a -> System.out.print(a + " "));
            System.out.println();
            list2.stream().forEach(a -> System.out.print(a + " "));
            System.out.println();
        };
        System.out.println("开始执行：");
        // 先执行equals再执行equals，接收的参数是lista和listb
        equals.andThen(disp).accept(lista, listb);
    }
 }

输出：

开始执行：
False
2 1 3 
2 1 2

示例代码二：

Student类：

import java.util.List;

public class Student  {
    public String name;
    public int score;
    public List<Integer> sc;

    public Student (String name ,int score,List<Integer> sc){
        this.name=name;
        this.score=score;
        this.sc=sc;
    }

    public Student (){}

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getScore() {
        return score;
    }

    public void setScore(int score) {
        this.score = score;
    }

    public List<Integer> getSc() {
        return sc;
    }

    public void setSc(List<Integer> sc) {
        this.sc = sc;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", score=" + score +
                ", sc=" + sc +
                '}';
    }
}

BiConsumerTest类：

import com.test.Student;
import java.util.function.BiConsumer;
import static java.util.Objects.requireNonNull;

public interface BiConsumerTest extends BiConsumer<Student, String> {
    @Override
    default BiConsumerTest andThen(final BiConsumer<? super Student, ? super String> after) {
        requireNonNull(after, "after");
        return (l, r) -> {
            accept(l, r);
            after.accept(l, r);
        };
    }
}

测试类：

import com.test.Student;
import com.test.BiConsumerTest;
import java.util.*;

public class MainServer {
    public static void main(String[] args) throws Exception {
        Student student1 = new Student("张三", 85, Arrays.asList(95, 87));
        BiConsumerTest biConsumerTest1 = myBiConsumerTest1("姓名-");
        BiConsumerTest biConsumerTest2 = myBiConsumerTest2("成绩-");
        biConsumerTest1.andThen(biConsumerTest2).accept(student1, "序号1:");
    }

    static BiConsumerTest myBiConsumerTest1(String str) {
        //(student, number) -> System.out.println(number + str + student.name)相当于accept方法
        return (student, number) -> System.out.println(number + str + student.name);
    }

    static BiConsumerTest myBiConsumerTest2(String str) {
        //(student, number) -> System.out.println(number + student.name + str + student.score);相当于accept方法
        return (student, number) -> System.out.println(number + student.name + str + student.score);
    }
}

输出：

序号1:姓名-张三
序号1:张三成绩-85

三、其他和Consumer相关的接口

BiConsumer<T, U> 处理两个参数
DoubleConsumer 处理一个double类型的参数
IntConsumer 处理一个int类型的参数
LongConsumer 处理一个long类型的参数
ObjIntConsumer 处理两个参数,且第二个参数必须为int类型
ObjLongConsumer 处理两个参数,且第二个参数必须为long类型

参考：
About return lambda expressions

开放原子开发者工作坊

开放原子开发者工作坊旨在鼓励更多人参与开源活动，与志同道合的开发者们相互交流开发经验、分享开发心得、获取前沿技术趋势。工作坊有多种形式的开发者活动，如meetup、训练营等，主打技术交流，干货满满，真诚地邀请各位开发者共同参与！

更多推荐

新华网：开源盛会在江城——2024开放原子开发者大会侧记

开源盛会在江城——2024开放原子开发者大会侧记

开放原子开发者工作坊

新华社：释放开源潜能，加快构筑软件创新“朋友圈”

释放开源潜能，加快构筑软件创新“朋友圈”

开放原子开发者工作坊

开源鸿蒙：引领万物智联，加速生态崛起

开放原子开发者工作坊

所有评论(0)

查看更多评论

西凉的悲伤

@qq_33697094

已为社区贡献16条内容