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); // 假设runCalculation返回ResultObject
          if (o.getValue() > bestValue) {
            bestValue = o.getValue(); // 修正：原代码为getValue，应为o.getValue()
            bestObject = o;
          }
        }
      }
    }
    return bestObject;
}

import java.util.List;

class Result {
    int a, b, c;
    double calculatedValue; // 避免与Java内置的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, calculatedValue=%s}", a, b, c, calculatedValue);
    }

    // 假设的计算方法，实际应用中替换为您的业务逻辑
    private static double runCalculation(int a, int b, int c) {
        // 示例：简单地返回三个输入的和
        return a + b + c;
    }
}

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 {

    // 假设的计算方法，实际应用中替换为您的业务逻辑
    private static double runCalculation(int a, int b, int c) {
        // 示例：这里只是简单地返回三个输入的和，您可以替换为任何复杂的计算
        return a + b + c;
    }

    // 封装计算结果的内部类
    private static class Result {
        int a, b, c;
        double calculatedValue;

        public Result(List<Integer> params) {
            if (params == null || params.size() != 3) {
                throw new IllegalArgumentException("Expected 3 parameters for Result construction.");
            }
            this.a = params.get(0);
            this.b = params.get(1);
            this.c = params.get(2);
            this.calculatedValue = runCalculation(a, b, c); // 调用静态的runCalculation
        }

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

    public static Result getBestObjectWithStreams(int maxParameterValue) {
        Set<Integer> params = IntStream.range(0, maxParameterValue).boxed().collect(Collectors.toSet());

        Optional<Result> bestResultOptional = Sets.cartesianProduct(params, params, params).stream()
                .parallel() // 启用并行处理
                .map(Result::new) // 将每个参数组合映射为Result对象
                .max(Comparator.comparingDouble(Result::getCalculatedValue)); // 查找calculatedValue最大的Result

        // 安全地获取结果，如果流为空（例如maxParameterValue为0），则返回null或抛出异常
        return bestResultOptional.orElse(null); // 或者根据业务逻辑抛出异常
    }

    public static void main(String[] args) {
        int maxParamValue = 10;
        Result bestResult = getBestObjectWithStreams(maxParamValue);

        if (bestResult != null) {
            System.out.println("找到的最佳结果: " + bestResult);
        } else {
            System.out.println("未找到任何结果。请检查参数范围。");
        }

        // 示例：maxParamValue = 0 的情况
        Result noResult = getBestObjectWithStreams(0);
        if (noResult == null) {
            System.out.println("当maxParameterValue为0时，未找到结果 (符合预期)。");
        }
    }
}