Lambda中Function函数接口（六）——Consumer系列接口

最新推荐文章于 2025-01-12 09:09:47 发布

九零大叔芭蕉

最新推荐文章于 2025-01-12 09:09:47 发布

阅读量657

点赞数

分类专栏： Java基础

本文链接：https://blog.csdn.net/whxjason/article/details/110668131

版权

Java基础专栏收录该内容

11 篇文章

订阅专栏

函数式接口汇总链接

Consumer系列接口是消耗一个参数，也就是传进去一个参数，但不返回任何结果，只在方法内部处理。比如我对一个数组进行处理，如果其中一个元素符合我的条件我就把它删除。

Consumer系列共有8个接口，如下：

Consumer

接收一个任意类型的参数，并进行处理。这个接口中有两个方法：

@FunctionalInterface
public interface Consumer<T> {

    /**
     * 对给定参数执行此操作。
     */
    void accept(T t);

    /**
     * 这个方法我们在其他的接口中也是经常见到。
     * 他的作用是：先执行当前Consumer对象的accept方法，然后再执行after对象的方法
     */
    default Consumer<T> andThen(Consumer<? super T> after) {
        Objects.requireNonNull(after);
        return (T t) -> { accept(t); after.accept(t); };
    }
}

我们直接看简单的代码例子：

public class TestConsumer {
    static int length;
    static String str = "test Comsumer";

    public static void main(String[] args) {

        // 直接打印参数值
        test(str, System.out::println);
        // 给参数值拼接字符串
        test(str, s -> {
            s += " and something";
            str = s;
            System.out.println(s);
        });
        // 将字符串通过空格分割，并求其每个元素的长度和
        test(str, s -> {
            String[] split = s.split(" ");
            for (String o : split) {
                length += o.length();
            }
        });
        System.out.println("长度：" + length);

        testAndThen(length, v -> {
            System.out.println("参数值v：" + v);
            length = v + 100;
            System.out.println("长度1：" + length);
        }, last -> {
            System.out.println("参数值last：" + last);
            System.out.println("长度2：" + length);
            if (last > 100) {
                System.out.println("=========");
            }
        });
    }

    public static void test(String str, Consumer<String> consumer) {
        consumer.accept(str);
    }

    public static void testAndThen(int val, Consumer<Integer> consumer, Consumer<Integer> after) {
        Consumer<Integer> andThen = consumer.andThen(after);
        andThen.accept(val);
    }
}

可以着重看一下testAndThen()这个方法的处理过程。

下面是打印的结果：

test Comsumer
test Comsumer and something
长度：24
参数值v：24
长度1：124
参数值last：24
长度2：124

BiConsumer

此接口处理的是接收两个参数。如：

public class TestBiConsumer {
    public static void main(String[] args) {
        test(100, "aaa", (v, s) -> {
            v = v + s.length();
            System.out.println(v);
        });
    }

    public static void test(int val, String str, BiConsumer<Integer, String> consumer) {
        consumer.accept(val, str);
    }
}

IntConsumer
用法同DoubleConsumer一样，这里接收的参数只能是Int类型的。
LongConsumer
用法同DoubleConsumer一样，这里接收的参数只能是Long类型的。

DoubleConsumer

此接口接收的参数类型只能是Double类型。如：

public class TestDoubleConsumer {

    static double rs = 22.22;

    public static void main(String[] args) {
        test(100.011, v -> {
            String valueOf = String.valueOf(v * 2);
            System.out.println(valueOf);
        });

//   注意这里调用test()方法，每一行打印的结果比较。
        test(rs, d1 -> {
            System.out.println("s-rs值1：" + rs);
            System.out.println("s-参数值d1：" + d1);
            d1 += 100;
            rs = d1;
            System.out.println("e-rs值1：" + rs);
            System.out.println("e-参数值d1：" + d1 +"\n");
        }, d2 -> {
            System.out.println("s-rs值2：" + rs);
            System.out.println("s-参数d2：" + d2);
            d2 += 100;
            rs = d2;
            System.out.println("e-rs值2：" + rs);
            System.out.println("e-参数d2：" + d2);

        });
    }

    public static void test(double val, DoubleConsumer doubleConsumer) {
        doubleConsumer.accept(val);
    }

    public static void test(double val, DoubleConsumer doubleConsumer, DoubleConsumer after) {
        DoubleConsumer andThen = doubleConsumer.andThen(after);
        andThen.accept(val);
    }
}

打印结果如下：

200.022
s-rs值1：22.22
s-参数值d1：22.22
e-rs值1：122.22
e-参数值d1：122.22

s-rs值2：122.22
s-参数d2：22.22
e-rs值2：122.22
e-参数d2：122.22

ObjIntConsumer

表示接收两个参数，其中一个必须是int类型，另一个是其他类型的。

@FunctionalInterface
public interface ObjIntConsumer<T> {

    /**
     * Performs this operation on the given arguments.
     *
     * @param t the first input argument
     * @param value the second input argument
     */
    void accept(T t, int value);
}

比如：

public class TestObjIntConsumer {
    public static void main(String[] args) {

        test("test", (s, value) -> {
            int length = s.length();
            int i = length + value;
            System.out.println(i);
        });

        User user = new User("张三", 22);  // 省略User的创建。其实就两个属性，姓名和年龄
        test(user, 20, (u, value) -> {
            int age = u.getAge();
            if (age > value) {
                System.out.println(u.getName());
            }
        });

    }

    public static void test(String str, ObjIntConsumer<String> consumer) {
        consumer.accept(str, 100);
    }

    public static void test(User user, int val, ObjIntConsumer<User> consumer) {
        consumer.accept(user, val);
    }
}

打印结果：