Java的Consumer接口只能接受一个参数,但可以通过自定义接口、使用Tuple或嵌套结构来实现对多个参数的处理,对于Supplier接口,它不能接受参数,但可以通过自定义BiSupplier、结合Function或封装参数为对象来实现对两个参数并返回一个值的功能。文章介绍了Java中Consumer和Supplier函数式接口的使用,以及如何通过自定义接口、使用组合或第三方库来实现多参数的类似功能
Consumer如何接受多参数？
在 Java 中，Consumer 是一个只接受 一个参数 的函数式接口，定义在 java.util.function 包中。其主要方法是 accept(T t)，用于处理传入的参数而不返回值。
如果你需要一个可以接受 三个参数 的类似功能，可以通过以下方式实现：
1. 创建自定义的 Consumer 接口
你可以自己定义一个支持三个参数的 Consumer：
|
1 2 3 4 |
@FunctionalInterface public interface TriConsumer<T, U, V> { void accept(T t, U u, V v); } |
使用示例：
|
1 2 3 4 5 6 7 |
TriConsumer<String, Integer, Boolean> triConsumer = (name, age, isActive) -> { System.out.println("Name: " + name); System.out.println("Age: " + age); System.out.println("Active: " + isActive); };
triConsumer.accept("Alice", 25, true); |
2. 使用三参数的现成函数式接口
虽然标准库中没有 TriConsumer，但一些第三方库（例如 Apache Commons 或 Vavr）中可能提供了类似的功能。这样你就不需要自己实现。
3. 使用组合 Consumer 解决
如果你坚持使用 Java 自带的 Consumer，可以将三个参数打包成一个对象传递。例如：
使用 Consumer 和 Tuple：
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 |
class Tuple3<T, U, V> { final T first; final U second; final V third;
public Tuple3(T first, U second, V third) { this.first = first; this.second = second; this.third = third; } }
Consumer<Tuple3<String, Integer, Boolean>> consumer = tuple -> { System.out.println("Name: " + tuple.first); System.out.println("Age: " + tuple.second); System.out.println("Active: " + tuple.third); };
consumer.accept(new Tuple3<>("Bob", 30, false)); |
4. 使用 BiConsumer 和嵌套
BiConsumer 是标准库中支持两个参数的函数式接口。通过嵌套 Consumer，可以间接实现对三个参数的操作：
|
1 2 3 4 5 6 7 8 9 10 |
BiConsumer<String, Integer> biConsumer = (name, age) -> { Consumer<Boolean> innerConsumer = isActive -> { System.out.println("Name: " + name); System.out.println("Age: " + age); System.out.println("Active: " + isActive); }; innerConsumer.accept(true); };
biConsumer.accept("Charlie", 28); |
参考代码
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 |
@Override public List<CsAIAppConfig> doGenerateDefaultAI(AIServiceSettingDTO aiServiceSetting) { List<CsAIAppConfig> aiConfigOfList = new ArrayList<>();
// 定义一个通用方法来构建并生成AI配置 BiConsumer<String, AIEnableEnum> createAIConfig = (modelId, enableEnum) -> Optional.ofNullable(modelId).ifPresent(id -> { SaveOrUpdateAIEntity build = SaveOrUpdateAIEntity.builder() .targetId("DEFAULT") .modelId(id) .aiEnableEnum(enableEnum) .knowledge(getKnowledgeByEnum(enableEnum, aiServiceSetting)) .csAIAppConfigs(aiServiceSetting.getCsAIAppConfigs()) .build(); generateAI(build, aiConfigOfList); });
// 构建各类AI配置 createAIConfig.accept(aiServiceSetting.getWorkOrderModelId(), AIEnableEnum.CS_WORK_ORDER_AI_ENABLE); createAIConfig.accept(aiServiceSetting.getWxKfModelId(), AIEnableEnum.CS_WX_KF_AI_ENABLE); createAIConfig.accept(aiServiceSetting.getZxKfModelId(), AIEnableEnum.CS_ZX_KF_AI_ENABLE); createAIConfig.accept(aiServiceSetting.getMhKhModelId(), AIEnableEnum.CS_MH_KH_AI_ENABLE);
return aiConfigOfList; } |
Supply 如何接受两个参数？
在 Java 的标准库中，Supplier 是一个函数式接口，用于生成一个结果。它的核心方法是：
|
1 |
T get(); |
这意味着 Supplier 不接受任何参数，只负责返回一个值。
如果你需要类似 Supplier 接受两个参数：
Java 的标准库没有直接提供这样一个接口，但你可以通过以下方式实现：
1. 自定义一个类似 BiSupplier 的接口
可以创建一个支持两个输入参数并返回一个值的接口：
|
1 2 3 4 |
@FunctionalInterface public interface BiSupplier<T, U, R> { R get(T t, U u); } |
使用示例：
|
1 2 3 4 |
BiSupplier<String, Integer, String> biSupplier = (name, age) -> "Name: " + name + ", Age: " + age;
System.out.println(biSupplier.get("Alice", 25)); // 输出: Name: Alice, Age: 25 |
2. 结合 Function 使用
如果你不想创建新接口，可以使用 BiFunction 替代：
|
1 2 3 4 |
BiFunction<String, Integer, String> biFunction = (name, age) -> "Name: " + name + ", Age: " + age;
System.out.println(biFunction.apply("Alice", 25)); // 输出: Name: Alice, Age: 25 |
虽然它的名字是 BiFunction，但功能上可以等效于一个接受两个参数的 Supplier。
3. 将参数封装为对象
你可以通过将两个参数封装为一个对象，仍然使用标准的 Supplier：
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 |
class Person { String name; int age;
public Person(String name, int age) { this.name = name; this.age = age; }
@Override public String toString() { return "Name: " + name + ", Age: " + age; } }
Supplier<Person> personSupplier = () -> new Person("Alice", 25);
System.out.println(personSupplier.get()); // 输出: Name: Alice, Age: 25 |
总结
Java 的 Consumer 本身只能接受一个参数。对于三个参数，可以自定义 TriConsumer，使用 Tuple 或嵌套结构。如果需要更强大的函数式接口支持，考虑引入第三方库或切换到更高级的解决方案。
Supplier 本身不能接受任何参数，只负责提供一个值。如果需要接受两个参数并返回一个值： 自定义 BiSupplier。使用 BiFunction 替代。封装参数为一个对象，继续使用标准的 Supplier。
