构建灵活的参数类型：使用 Builder 模式实现函数式编程-java教程-PHP中文网

构建灵活的参数类型：使用 Builder 模式实现函数式编程

心靈之曲

发布： 2025-08-19 16:06:01

原创

675人浏览过

构建灵活的参数类型：使用 builder 模式实现函数式编程

本文介绍如何使用 Builder 模式来构建一个接受 Function 或 Float/Double 作为参数的函数，用于流式处理。通过 Builder 模式，可以避免方法重载带来的代码冗余，并提供一种优雅的方式来处理动态类型的输入，从而简化创意编码应用中的参数配置。

在函数式编程中，我们经常需要构建接受不同类型参数的函数。当参数类型可能是 Function 或基本类型（如 Float 或 Double）时，直接使用方法重载会导致大量的重复代码。一种更优雅的解决方案是使用 Builder 模式。Builder 模式允许我们逐步构建对象，并在构建过程中处理不同类型的参数。

以下是一个使用 Builder 模式的示例，用于构建一个名为 RangeBuilder 的类，该类可以接受 Function<PVector, Double> 或 Double 作为 scale、min 和 max 参数：

import java.util.List;
import java.util.function.Function;
import java.util.stream.Stream;

public class RangeBuilderExample {

    public static void main(String... args) {
        List<PVector> pvs = List.of(new PVector(0, 0));

        Stream<Double> s = pvs.stream().map(new RangeBuilder().scale(.02)
                                                              .min(0)
                                                              .max(255)
                                                              .build());
        Stream<Double> s2 = pvs.stream().map(new RangeBuilder().scale(new RangeBuilder().scale(.02)
                                                                                        .min(.1)
                                                                                        .max(.002)
                                                                                        .build())
                                                              .min(0)
                                                              .max(255)
                                                              .build());

    }

    public static final class RangeBuilder {

        private Function<PVector, Double> scale;
        private Function<PVector, Double> min;
        private Function<PVector, Double> max;

        public RangeBuilder scale(Function<PVector, Double> scale) {
            this.scale = scale;
            return this;
        }

        public RangeBuilder scale(double scale) {
            return scale(in -> scale);
        }

        public RangeBuilder min(Function<PVector, Double> min) {
            this.min = min;
            return this;
        }

        public RangeBuilder min(double min) {
            return min(in -> min);
        }

        public RangeBuilder max(Function<PVector, Double> max) {
            this.max = max;
            return this;
        }

        public RangeBuilder max(double scale) {
            return max(in -> scale);
        }

        public Function<PVector, Double> build() {
            return pv -> map(noise(pv.x * scale.apply(pv), pv.y * scale.apply(pv)), 0, 1, min.apply(pv), max.apply(pv));
        }

        // 模拟 noise 和 map 函数
        private double noise(double x, double y) {
            // 实际应用中需要替换为真正的噪声函数
            return Math.random();
        }

        private double map(double value, double start1, double stop1, double start2, double stop2) {
            return start2 + (stop2 - start2) * ((value - start1) / (stop1 - start1));
        }

    }

    // 模拟 PVector 类
    private static class PVector {
        public double x;
        public double y;

        public PVector(double x, double y) {
            this.x = x;
            this.y = y;
        }
    }
}

登录后复制

代码解释：

RangeBuilder 类： 这是一个静态内部类，负责构建最终的 Function<PVector, Double> 对象。
参数字段： scale、min 和 max 都是 Function<PVector, Double> 类型，它们代表了缩放比例、最小值和最大值。
Builder 方法： 每个参数都有两个重载的 Builder 方法：

即构数智人
即构数智人是由即构科技推出的AI虚拟数字人视频创作平台，支持数字人形象定制、短视频创作、数字人直播等。

36

查看详情
- 接受 Function<PVector, Double> 作为参数，直接设置对应的字段。
- 接受 double 作为参数，创建一个返回该 double 值的 Function<PVector, Double>，并设置对应的字段。例如，scale(double scale) 方法会创建一个 in -> scale 的 lambda 表达式，并将其赋值给 scale 字段。
build() 方法： 该方法将所有参数组合起来，创建一个最终的 Function<PVector, Double> 对象。在这个例子中，它使用了 map 函数和 noise 函数（这里只是模拟，实际应用中需要替换为真正的实现）来计算最终的结果。

使用示例：

在 main 方法中，我们创建了两个 Stream<Double> 对象 s 和 s2，它们分别使用了不同的参数配置。注意，s2 的 scale 参数本身也是一个 RangeBuilder 构建的函数，这展示了 Builder 模式的灵活性和可组合性。

注意事项：

在实际应用中，需要根据具体的需求来实现 noise 和 map 函数。
可以选择使用 double 类型代替 float 类型，因为 double 是 Java 中浮点数的默认类型，精度更高。
Builder 模式可以有效地避免方法重载带来的代码冗余，并提供一种灵活的方式来处理不同类型的参数。

总结：

通过使用 Builder 模式，我们可以构建灵活的、可配置的函数，这些函数可以接受不同类型的参数，并避免代码冗余。这种模式在函数式编程中非常有用，特别是在需要处理动态类型的输入时。本教程提供了一个简单的示例，展示了如何使用 Builder 模式来构建一个接受 Function 或 Double 作为参数的函数。您可以根据自己的实际需求来扩展和修改这个示例。

以上就是构建灵活的参数类型：使用 Builder 模式实现函数式编程的详细内容，更多请关注php中文网其它相关文章！