使用Java Stream并行查找多参数组合计算的最大值

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;
}

<dependency>
    <groupId>com.google.guava</groupId>
    <artifactId>guava</artifactId>
    <version>32.1.3-jre</version> <!-- 使用最新版本 -->
</dependency>

import java.util.List;

public class ResultObject {
    private final int paramA;
    private final int paramB;
    private final int paramC;
    private final double value;

    // 假设这是您的计算逻辑，这里仅为示例
    private static double runCalculation(int a, int b, int c) {
        // 替换为您的实际复杂计算逻辑
        return (double) (a * 2 + b * 3 + c * 0.5);
    }

    public ResultObject(List<Integer> params) {
        if (params == null || params.size() < 3) {
            throw new IllegalArgumentException("Parameters list must contain at least 3 integers.");
        }
        this.paramA = params.get(0);
        this.paramB = params.get(1);
        this.paramC = params.get(2);
        this.value = runCalculation(paramA, paramB, paramC); // 在构造函数中执行计算
    }

    public double getValue() {
        return value;
    }

    public int getParamA() {
        return paramA;
    }

    public int getParamB() {
        return paramB;
    }

    public int getParamC() {
        return paramC;
    }

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

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 StreamMaxCalculation {

    public static void main(String[] args) {
        int maxParameterValue = 10; // 参数的上限（不包含）

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

        // 2. 使用Guava的cartesianProduct生成所有参数组合的笛卡尔积
        // Sets.cartesianProduct接受可变参数，每个参数是一个Set
        // 这里我们有三个参数，所以传入三次parameterRange
        Optional<ResultObject> bestResultObject = Sets.cartesianProduct(parameterRange, parameterRange, parameterRange)
                .stream()                               // 将所有组合转换为Stream
                .parallel()                             // 开启并行处理，充分利用多核CPU
                .map(ResultObject::new)                 // 将每个List<Integer>组合映射为ResultObject实例
                .max(Comparator.comparingDouble(ResultObject::getValue)); // 使用max操作符和Comparator查找value最大的ResultObject

        // 3. 处理结果
        if (bestResultObject.isPresent()) {
            System.out.println("找到的最佳结果对象: " + bestResultObject.get());
        } else {
            System.out.println("未找到任何结果对象，参数范围可能为空。");
        }
    }
}