将消费者与不同的参数或不同的参数数量结合起来

Question

比方说，我们的方法接收输入字符串和returns 一些列表输出。这个输出是一些生成器的结果，其中一些依赖于输入而另一些则不依赖——它们只是添加预定义的值。我想像一些函数接口（例如消费者）的列表一样实现这些生成器，然后将它们组合成一个消费者并将其应用于输入字符串。

所以，我将能够轻松独立地更换小型发电机。但问题是，并非我所有的生成器都需要 input String 作为参数，我只是将此参数传递到那里只有一个原因 - 能够将此类消费者与其他消费者组合。

public class ConsumersTest {

private static <T, U> BiConsumer<T, U> combine(List<BiConsumer<T, U>> consumers) {
    return consumers.stream().reduce((arg1, arg2) -> {}, BiConsumer::andThen);
}

List<String> generate(String input) {
    ArrayList<String> output = new ArrayList<>();
    combine(getGenerators()).accept(input, output);
    return output;
}

private List<BiConsumer<String, List<String>>> getGenerators() {
    return Arrays.asList(
            this::addFirstDependent,
            this::addSecondIndependent
    );
}

private void addFirstDependent(String input, List<String> output) {
    if (input.contains("some string")) {
        output.add("First-Dependent");
    }
}

private void addSecondIndependent(String input, List<String> output) {
    output.add("Predefined Output");
}}

是否可以将不同的消费者组合在一个保护伞下并在一个地方应用它们？或者这是一个坏主意而不是做这些事情的正确方法？

Answer 1

在模块化软件和 适配器 中拥有通用接口以适应特定的实现并不罕见。例如

public class ConsumersTest {

    List<String> generate(String input) {
        ArrayList<String> output = new ArrayList<>();
        generators.accept(input, output);
        return output;
    }

    private static <T, U> BiConsumer<T, U> ignoreFirstArg(Consumer<U> consumer) {
        return (t, u) -> consumer.accept(u);
    }

    private final BiConsumer<String, List<String>> generators =
        Stream.<BiConsumer<String, List<String>>>of(
                this::addFirstDependent,
                ignoreFirstArg(this::addSecondIndependent)
        ).reduce(BiConsumer::andThen).orElse((arg1, arg2) -> {});

    private void addFirstDependent(String input, List<String> output) {
        if (input.contains("some string")) {
            output.add("First-Dependent");
        }
    }

    private void addSecondIndependent(List<String> output) {
        output.add("Predefined Output");
    }
}

所以 ignoreFirstArg 是没有第一个参数的方法的通用适配器。可以有任意数量的适配器方法。但请注意，如果适配器非常具体，因此只使用一次，也可以在组合代码中编写 lambda 表达式而不是方法引用。请注意，我更改了该代码，以便不会对每个 generate(String input) 调用进行重复评估，否则，当您不重用组合函数时，将它们组合起来就没有意义，因为您也可以使用

List<String> generate(String input) {
    ArrayList<String> output = new ArrayList<>();
    Stream.<BiConsumer<String, List<String>>>of(
            this::addFirstDependent,
            ignoreFirstArg(this::addSecondIndependent)
    ).forEach(g -> g.accept(input, output));
    return output;
}

甚至更简单

List<String> generate(String input) {
    ArrayList<String> output = new ArrayList<>();

    this.addFirstDependent(input, output);
    this.addSecondIndependent(output);

    return output;
}

这并不比功能代码更难维护，因为每个生成器仍然由一行组成。

将消费者与不同的参数或不同的参数数量结合起来

Combine Consumers with different arguments or different arguments number

java

lambda

java-8

functional-interface

method-reference