Java Stream与Guava：高效查找多参数组合的最优结果

public ResultObject getBestObjectWithParameters() {
    int maxParameterValue = 10;
    double bestValue = 0.0;
    ResultObject bestObject = null;
    for (int a = 0; a < maxParameterValue; a++) {
      for (int b = 0; b < maxParameterValue; b++) {
        for (int c = 0; c < maxParameterValue; c++) {
          ResultObject o = runCalculation(a, b, c); // 假设这是您的计算方法
          if (o.getValue() > bestValue) {
            bestValue = o.getValue();
            bestObject = o;
          }
        }
      }
    }
    return bestObject;
}

import com.google.common.collect.Sets;
import java.util.Set;
import java.util.stream.Collectors;
import java.util.stream.IntStream;

// ... (在主方法或适当的上下文中使用)

int maxParameterValue = 10;
// 生成每个参数的取值集合
Set<Integer> params = IntStream.range(0, maxParameterValue)
                               .boxed() // 将IntStream转换为Stream<Integer>
                               .collect(Collectors.toSet());

// 生成所有参数的笛卡尔积，每个组合是一个List<Integer>
// 例如，如果params = {0, 1}，则cartesianProduct(params, params, params)
// 会生成 [[0,0,0], [0,0,1], [0,1,0], ..., [1,1,1]]
Set<List<Integer>> combinations = Sets.cartesianProduct(params, params, params);

// 假设您的实际计算方法是 runCalculation(int a, int b, int c)
// 并且返回一个 double 类型的值
private static double runCalculation(int a, int b, int c) {
    // 替换为您的实际复杂计算逻辑
    // 示例：简单地将三个输入参数相加
    return a + b + c;
}

// Result 类用于封装输入参数和计算结果
private static class Result {
    int a, b, c;
    double calculatedValue; // 将 'result' 字段更名为 'calculatedValue' 以增加可读性

    public Result(List<Integer> params) {
        if (params.size() != 3) {
            throw new IllegalArgumentException("Expected 3 parameters.");
        }
        this.a = params.get(0);
        this.b = params.get(1);
        this.c = params.get(2);
        // 在构造器中执行计算
        this.calculatedValue = runCalculation(a, b, c);
    }

    public double getCalculatedValue() {
        return calculatedValue;
    }

    @Override
    public String toString() {
        return String.format("Result{a=%d, b=%d, c=%d, value=%.2f}", a, b, c, calculatedValue);
    }
}

import com.google.common.collect.Sets;

import java.util.Comparator;
import java.util.List;
import java.util.Optional;
import java.util.Set;
import java.util.stream.Collectors;
import java.util.stream.IntStream;

public class StreamMaxCombinationFinder {

    public static void main(String[] args) {
        int maxParameterValue = 10; // 参数取值范围 [0, 9]

        // 1. 生成每个参数的取值集合
        Set<Integer> params = IntStream.range(0, maxParameterValue)
                                       .boxed()
                                       .collect(Collectors.toSet());

        // 2. 生成所有参数的笛卡尔积
        // Sets.cartesianProduct接受可变参数，这里是3个参数集合
        Set<List<Integer>> combinations = Sets.cartesianProduct(params, params, params);

        // 3. 构建Stream管道，并行处理并找出最优结果
        Optional<Result> bestResultOptional = combinations.stream()
                .parallel() // 启用并行处理
                .map(Result::new) // 将每个参数组合映射为Result对象，并在其中执行计算
                .max(Comparator.comparingDouble(Result::getCalculatedValue)); // 找出calculatedValue最大的Result

        // 4. 处理最终结果
        if (bestResultOptional.isPresent()) {
            Result bestResult = bestResultOptional.get();
            System.out.println("找到的最优结果: " + bestResult);
        } else {
            System.out.println("未找到任何结果 (参数组合为空)。");
        }
    }

    /**
     * 模拟实际的复杂计算方法。
     * 替换为您的业务逻辑。
     */
    private static double runCalculation(int a, int b, int c) {
        // 这是一个示例，您可以替换为任何根据a, b, c计算double值的逻辑
        // 例如：复杂的数学公式、数据库查询、外部服务调用等
        return a * 2.5 + b * 1.8 + c * 0.7; // 示例计算
    }

    /**
     * 内部类，用于封装输入参数和计算结果。
     * 类似于原始问题中的 ResultObject。
     */
    private static class Result {
        int a, b, c;
        double calculatedValue;

        public Result(List<Integer> params) {
            if (params.size() != 3) {
                throw new IllegalArgumentException("Expected 3 parameters for Result creation.");
            }
            this.a = params.get(0);
            this.b = params.get(1);
            this.c = params.get(2);
            this.calculatedValue = runCalculation(a, b, c); // 调用实际的计算方法
        }

        public double getCalculatedValue() {
            return calculatedValue;
        }

        @Override
        public String toString() {
            return String.format("Result{a=%d, b=%d, c=%d, calculatedValue=%.2f}", a, b, c, calculatedValue);
        }
    }
}

找到的最优结果: Result{a=9, b=9, c=9, calculatedValue=45.00}