误差棒 标准差

   List<List<String>> getdata = extractDataFromListNullString(chartDateTto.getDataList());
                List<String> lenNameList = getdata.get(0);
                lenNameList.remove(0);
                String chartValue = chartDateTto.getChartValue();

                // 删除第一行的数据照
                getdata.remove(0);
                // 删除每行的第一列数据
                for (List<String> getdatum : getdata) {
                    getdatum.remove(0);
                }

                // 按列分组
                int columnCount = getdata.get(0).size();
                List<List<Double>> groupedData = new ArrayList<>();

                for (int i = 0; i < columnCount; i++) {
                    List<Double> columnData = new ArrayList<>();
                    for (List<String> row : getdata) {
                        columnData.add(Double.parseDouble(row.get(i)));
                    }
                    groupedData.add(columnData);
                }

                // 打印每列数据
                for (List<Double> groupedDatum : groupedData) {
                    System.out.println("我是打印的每一列" + groupedDatum);
                }

                // 计算每组数据的平均值并存入 arrayList
                ArrayList<Double> arrayList = new ArrayList<>();

                for (List<Double> groupedDatum : groupedData) {
                    double sum = 0;
                    for (Double value : groupedDatum) {
                        sum += value;
                    }
                    double average = sum / groupedDatum.size();
                    arrayList.add(average);
                }

                // 打印平均值
                for (Double aDouble : arrayList) {
                    System.out.println("我是平均值" + aDouble);
                }

                // 打印每组名称
                for (String s : lenNameList) {
                    System.out.println("我是每组名称" + s);
                }

                // 将每个平均值和对应的组名称进行配对并放入 group 集合中
                ArrayList<Object> group = new ArrayList<>();
                for (int i = 0; i < arrayList.size(); i++) {
                    String name = lenNameList.get(i);
                    Double average = arrayList.get(i);
                    ArrayList<Object> pairedData = new ArrayList<>();
                    pairedData.add(name);
                    pairedData.add(average);
                    group.add(pairedData);
                }

                // 打印分组后的数据
                for (Object obj : group) {
                    System.out.println("我是分组数据: " + obj);
                }

                // 计算每组数据的上限和下限
                ArrayList<Double> upperLimits = new ArrayList<>();
                ArrayList<Double> lowerLimits = new ArrayList<>();

                for (List<Double> groupedDatum : groupedData) {
                    double max = Collections.max(groupedDatum); // 计算上限
                    double min = Collections.min(groupedDatum); // 计算下限
                    upperLimits.add(max);
                    lowerLimits.add(min);
                }

                // 打印上限和下限
                for (int i = 0; i < upperLimits.size(); i++) {
                    System.out.println("我是" + lenNameList.get(i) + "的上限: " + upperLimits.get(i) + ", 下限: " + lowerLimits.get(i));
                }

                // 将上限和下限以数组的形式放入集合
                ArrayList<ArrayList<Object>> limitsGroup = new ArrayList<>();
                for (int i = 0; i < upperLimits.size(); i++) {
                    ArrayList<Object> limitsData = new ArrayList<>();
                    limitsData.add(lenNameList.get(i)); // 添加组名称
                    limitsData.add(upperLimits.get(i)); // 添加上限
                    limitsData.add(lowerLimits.get(i)); // 添加下限
                    limitsGroup.add(limitsData);
                }

                // 打印上限和下限的集合，使用英文双引号
                ArrayList<ArrayNode> formattedLimitsList = new ArrayList<>(); // 新集合用于存储格式化的数组

                ObjectMapper objectMapper = new ObjectMapper();

                for (ArrayList<Object> limitsData : limitsGroup) {
                    String name = (String) limitsData.get(0);
                    Double upperLimit = (Double) limitsData.get(1);
                    Double lowerLimit = (Double) limitsData.get(2);

                    // 创建一个 JSON 数组节点
                    ArrayNode limitArrayNode = objectMapper.createArrayNode();
                    limitArrayNode.add(name);
                    limitArrayNode.add(upperLimit);
                    limitArrayNode.add(lowerLimit);

                    // 打印格式化的结果
                    System.out.println(limitArrayNode.toString());

                    // 将格式化的数组添加到新集合中
                    formattedLimitsList.add(limitArrayNode);
                }

                // 解析 chartValue
                JsonNode rootNode = objectMapper.readTree(chartValue);

                // 获取 series 数组并清空第二个对象的 data 数组
                JsonNode seriesNode = rootNode.path("series");
                if (seriesNode.isArray() && seriesNode.size() > 1) {
                    JsonNode secondSeriesNode = seriesNode.get(1);
                    JsonNode dataNode = secondSeriesNode.path("data");
                    if (dataNode.isArray()) {
                        // 清空 data 数组
                        ((ArrayNode) dataNode).removeAll(); // 删除所有元素

                        // 将 formattedLimitsList 的内容添加到 data 数组中
                        for (ArrayNode limit : formattedLimitsList) {
                            ((ArrayNode) dataNode).add(limit);
                        }
                    }
                }
                // 获取 source 数组并清空内容
                JsonNode datasetNode = rootNode.path("dataset");
                if (datasetNode.isArray() && datasetNode.size() > 0) {
                    JsonNode sourceNode = datasetNode.get(0).path("source");
                    if (sourceNode.isArray()) {
                        // 清空 source 数组
                        ((ArrayNode) sourceNode).removeAll();

                        // 将 group 的内容替换到 source 数组中
                        for (Object obj : group) {
                            ((ArrayNode) sourceNode).add(objectMapper.valueToTree(obj));
                        }
                    }
                }

                // 将修改后的 JSON 转换为字符串并返回
                String updatedChartValue = objectMapper.writeValueAsString(rootNode);
                ArrayList<ChartSmartVo> newList = new ArrayList<>();
                ChartSmartVo chartSmartVo = new ChartSmartVo();
                chartSmartVo.setConfigValue(updatedChartValue);
                chartSmartVo.setUniList(lenNameList);
                newList.add(chartSmartVo);
                // 如果需要可以在这里返回 formattedLimitsList 或用于进一步处理
                return AjaxResult.success(newList);