复杂的盒须图

    @ApiOperation("导入盒须图数据4")
    @PostMapping("/importData4")
    @Transactional(rollbackFor = Exception.class)
    public AjaxResult importData4(@RequestBody ChartDateTto chartDateTto) throws Exception {
        // 提取数据
        List<List<String>> getdata = extractDataFromListNullString(chartDateTto.getDataList());
        int sizeLine = getdata.size();
        System.out.println("我是有多少列" + sizeLine);
        // 打印原始数据
        for (List<String> getdatum : getdata) {
            System.out.println(getdatum);
        }
        ArrayList<String> legendNameList = new ArrayList<>();//X轴名称
        // 获取第一行数据（数据名行）
        List<String> strings = getdata.get(0);
        int previousNonZeroIndex = -1;
        ArrayList<Object> arrayList = new ArrayList<>();
        for (int i = 1; i < strings.size(); i++) {

            // 检查是否是非零值（注意此处 "0" 是字符串形式）

            String value = strings.get(i);
            // 检查是否是非零值（注意此处 "0" 是字符串形式）
            if (!value.equals("0")) {
                legendNameList.add(value);
            }
            if (!value.equals("0")) {
                if (previousNonZeroIndex != -1) {
                    int columnsBetween = i - previousNonZeroIndex;
                    arrayList.add(columnsBetween);
                }
                previousNonZeroIndex = i;
            }
        }

        for (String aas : legendNameList) {
            System.out.println("我X轴的名称" + aas);
        }

        ArrayList<String> xAxisNameList = new ArrayList<>(); //图例名称
        // 获取第一行数据（数据名行）
        List<String> dataRow = getdata.get(1);
        int lastNonZeroIndex = -1;
        ArrayList<Object> columnGaps = new ArrayList<>();
        for (int i = 1; i < dataRow.size(); i++) {

            // 获取当前的值
            String currentValue = dataRow.get(i);

            // 检查是否是非零值（注意此处 "0" 是字符串形式）
            if (!currentValue.equals("0")) {
                xAxisNameList.add(currentValue);
            }

            // 处理非零值之间的列间隔
            if (!currentValue.equals("0")) {
                if (lastNonZeroIndex != -1) {
                    int columnsBetween = i - lastNonZeroIndex;
                    columnGaps.add(columnsBetween);
                }
                lastNonZeroIndex = i;
            }
        }




      /*  for (String aas : legendNameList) {
            System.out.println("我是图例名称"+aas);
        }*/
        // 移除第一行和第二行（如果需要）
        getdata.remove(0);
        getdata.remove(0);
        Object arr0 = arrayList.get(0);
        Integer integerValue = (Integer) arr0;
        int line = integerValue;
        System.out.println("我是中间隔的列数" + line);

        // 从 xAxisNameList 中提取前几位
        ArrayList<String> selectedXAxisNames = new ArrayList<>();//图例名称
        for (int i = 0; i < Math.min(line, xAxisNameList.size()); i++) {
            selectedXAxisNames.add(xAxisNameList.get(i));
        }

        // 输出 selectedXAxisNames 中的所有名称
        for (String name : selectedXAxisNames) {
            System.out.println("提取的图例名称: " + name);
        }

        int number = sizeLine / line; //列的数据
        // 创建一个ArrayList的List来存储每一列的数据
        List<List<Double>> columnData = new ArrayList<>();
        // 初始化columnData，假设getdata不为空且至少有一行数据
        if (!getdata.isEmpty()) {
            int numColumns = getdata.get(0).size() - 1; // 减去1，因为我们要移除每行的第一列
            for (int i = 0; i < numColumns; i++) {
                columnData.add(new ArrayList<>());
            }
        }

        // 获取seriesName列表
        ArrayList<String> seriesName = new ArrayList<>();

        // 遍历excel的每一行数据
        for (int rowIndex = 0; rowIndex < getdata.size(); rowIndex++) {
            List<String> row = getdata.get(rowIndex);
            String firstColumnValue = row.remove(0); // 移除第一列并获取其值
            seriesName.add(firstColumnValue);

            for (int colIndex = 0; colIndex < row.size(); colIndex++) {
                String cellValue = row.get(colIndex);
                try {
                    double numericValue = Double.parseDouble(cellValue);
                    columnData.get(colIndex).add(numericValue);
                } catch (NumberFormatException e) {
                    System.err.println("Invalid number format: " + cellValue);
                }
            }
        }

        ArrayList<Object> arrayLists = new ArrayList<>();
        for (int colIndex = 0; colIndex < columnData.size(); colIndex++) {
            arrayLists.add(columnData.get(colIndex));
        }

        // 分割 arrayLists
        List<List<Object>> groupedLists = splitList(arrayLists, line);

        // 打印分组后的数据
        for (int i = 0; i < groupedLists.size(); i++) {
            System.out.println("Group " + (i + 1) + ": " + groupedLists.get(i));
        }

        // 以下操作json
        String chartValue = chartDateTto.getChartValue();
        ObjectMapper objectMapper = new ObjectMapper();
        JsonNode rootNode = objectMapper.readTree(chartValue);
        ArrayNode dataset = (ArrayNode) rootNode.path("dataset");

        // 查找并保留第一个含有 source 的对象，删除其他含有 source 的对象
        JsonNode firstSourceNode = null;
        int firstSourceNodeIndex = -1;
        for (int i = 0; i < dataset.size(); i++) {
            JsonNode node = dataset.get(i);
            if (node.has("source")) {
                if (firstSourceNode == null) {
                    // 记录第一个含有 source 的对象，并保存其索引
                    firstSourceNode = node;
                    firstSourceNodeIndex = i;
                } else {
                    // 删除其他含有 source 的对象
                    dataset.remove(i);
                    i--; // 调整索引，因为我们删除了一个元素
                }
            }
        }

        // 根据 groupedLists.size() 的值复制 firstSourceNode，并添加到 dataset 中
        int requiredDatasets = groupedLists.size();
        int insertIndex = firstSourceNodeIndex + 1; // 插入位置在第一个 source 对象之后
        for (int i = 1; i < requiredDatasets; i++) { // 从1开始，因为第一个已经存在
            dataset.insert(insertIndex, firstSourceNode.deepCopy());
            insertIndex++; // 每次插入后，更新插入位置
        }

        // 更新 dataset 中每个 source 对象的 source 数组值
        int groupIndex = 0;
        for (JsonNode node : dataset) {
            if (node.has("source")) {
                ArrayNode sourceArray = (ArrayNode) node.get("source");

                // 确保 sourceArray 与 groupedLists 的大小一致
                sourceArray.removeAll();
                List<Object> groupData = groupedLists.get(groupIndex);
                for (Object item : groupData) {
                    // 将每个项转换为 JsonNode
                    ArrayNode arrayNode = objectMapper.createArrayNode();
                    ((List<Double>) item).forEach(arrayNode::add);
                    sourceArray.add(arrayNode);
                }
                groupIndex++;
            }
        }

        //处理 legend 中的data 要求取出
        ArrayNode legend = (ArrayNode) rootNode.path("legend");
        // 获取 legend 的 data 数组
        ArrayNode legendDataArray = (ArrayNode) legend.get(0).get("data");
        // 保留 data 数组中的第一个对象
        JsonNode firstLegendData = legendDataArray.get(0);
        // 删除剩余的对象
        legendDataArray.removeAll();
        legendDataArray.add(firstLegendData);
        // 根据 selectedXAxisNames.size() 进行复制第一个对象，并替换 name 的值
        for (int i = 0; i < selectedXAxisNames.size(); i++) {
            // 复制第一个对象
            JsonNode newLegendData = firstLegendData.deepCopy();

            // 替换 name 的值
            ((ObjectNode) newLegendData).put("name", selectedXAxisNames.get(i));

            // 将新对象添加到 data 数组中
            legendDataArray.add(newLegendData);
        }
        // 复制完成后删除第一个对象
        legendDataArray.remove(0);


        // 处理  series
        ArrayNode series = (ArrayNode) rootNode.path("series");
        // 获取 series 数组中的第一个对象
        JsonNode firstSeries = series.get(0);
        // 删除 series 数组中的所有对象
        series.removeAll();

        // 根据 selectedXAxisNames.size() 进行复制第一个对象，并替换 name 和 datasetIndex 的值
        for (int i = 0; i < selectedXAxisNames.size(); i++) {
            // 复制第一个对象
            JsonNode newSeries = firstSeries.deepCopy();

            // 替换 name 的值
            ((ObjectNode) newSeries).put("name", selectedXAxisNames.get(i));

            // 设置 datasetIndex 的值
            ((ObjectNode) newSeries).put("datasetIndex", i);

            // 将新对象添加到 series 数组中
            series.add(newSeries);
        }


        //处理dataset的fromDatasetIndex

// 处理 dataset 的 fromDatasetIndex
        ArrayNode datasetArray = (ArrayNode) rootNode.path("dataset");

// 查找并保留第一个含有 fromDatasetIndex 的对象，删除其他含有 fromDatasetIndex 的对象
        JsonNode firstFromDatasetIndexNode = null;
        int firstFromDatasetIndexNodeIndex = -1;
        for (int i = 0; i < datasetArray.size(); i++) {
            JsonNode node = datasetArray.get(i);
            if (node.has("fromDatasetIndex")) {
                if (firstFromDatasetIndexNode == null) {
                    // 记录第一个含有 fromDatasetIndex 的对象，并保存其索引
                    firstFromDatasetIndexNode = node;
                    firstFromDatasetIndexNodeIndex = i;
                } else {
                    // 删除其他含有 fromDatasetIndex 的对象
                    datasetArray.remove(i);
                    i--; // 调整索引，因为我们删除了一个元素
                }
            }
        }

// 根据 line 的值复制 firstFromDatasetIndexNode，并添加到 dataset 中
        // 假设 integerValue 已经被正确赋值
        int insertIndexa = firstFromDatasetIndexNodeIndex + 1; // 插入位置在第一个含有 fromDatasetIndex 的对象之后
        for (int i = 1; i < line; i++) { // 从1开始，因为第一个已经存在
            JsonNode newFromDatasetIndexNode = firstFromDatasetIndexNode.deepCopy();
            ((ObjectNode) newFromDatasetIndexNode).put("fromDatasetIndex", i); // 设置 fromDatasetIndex 的值
            datasetArray.insert(insertIndexa, newFromDatasetIndexNode);
            insertIndexa++; // 每次插入后，更新插入位置
        }




     //  dataset 数组中只含有transform和seriesLayoutBy的对象 保留dataset数组中只含有transform和seriesLayoutBy的第一个对象
        //   删除剩下的dataset 数组中只含有transform和seriesLayoutBy的对象 然后对这个对象进行复制 复制的次数为line-1次
     //   我的目的是要求dataset 数组中只含有transform和seriesLayoutBy的对象的数量和line数量相同

        ArrayNode datasetArrays = (ArrayNode) rootNode.path("dataset");










//处理数字

// 获取 dataset 中含有 fromDatasetIndex 的最后一个值
        int maxFromDatasetIndex = -1;
        for (JsonNode node : dataset) {
            if (node.has("fromDatasetIndex")) {
                int fromDatasetIndex = node.get("fromDatasetIndex").asInt();
                if (fromDatasetIndex > maxFromDatasetIndex) {
                    maxFromDatasetIndex = fromDatasetIndex;
                }
            }
        }

// 更新 series 数组中的 datasetIndex 从 maxFromDatasetIndex 递增
        if (maxFromDatasetIndex != -1) {
            ArrayNode seriesa = (ArrayNode) rootNode.path("series");
            int datasetIndex = maxFromDatasetIndex + 1; // 从最大值开始递增

            for (JsonNode seriesNode : seriesa) {
                ((ObjectNode) seriesNode).put("datasetIndex", datasetIndex);
                datasetIndex++; // 递增 datasetIndex
            }
        }

// 打印更新后的 dataset
        System.out.println("更新后的 dataset: " + dataset.toString());

// 打印完整的 JSON 数据
        String updatedJson = rootNode.toString();
        System.out.println("完整的 JSON 数据: " + updatedJson);


        ArrayList<Object> newList = new ArrayList<>();
        ChartSmartVo chartSmartVo = new ChartSmartVo();
        chartSmartVo.setConfigValue(updatedJson);
        chartSmartVo.setUniList(legendNameList);
        newList.add(chartSmartVo);

        return AjaxResult.success(newList);
    }