测试调整格式

whycxzp

2025-06-10 1d34cb0fbec1f4dd9999747f41f7c18ee25ee835

 src/main/java/com/whyc/service/ExcelService.java

@@ -589,13 +589,19 @@
        sheet.addMergedRegion(region25);

        //第三行,第五行,第六行的合并列,前两个单元模块是固定的,其中1个合并单元
        CellRangeAddress region31 = new CellRangeAddress(2, 2,  2, 3);
        CellRangeAddress region51 = new CellRangeAddress(4, 4,  2, 3);
        CellRangeAddress region61 = new CellRangeAddress(5, 5,  2, 3);
        sheet.addMergedRegion(region31);
        sheet.addMergedRegion(region51);
        sheet.addMergedRegion(region61);
        CellRangeAddress region31 = new CellRangeAddress(2, 2,  1, 2);
        CellRangeAddress region32 = new CellRangeAddress(2, 2,  3, 4);
        CellRangeAddress region51 = new CellRangeAddress(4, 4,  1, 2);
        CellRangeAddress region52 = new CellRangeAddress(4, 4,  3, 4);
        CellRangeAddress region61 = new CellRangeAddress(5, 5,  1, 2);
        CellRangeAddress region62 = new CellRangeAddress(5, 5,  3, 4);

        sheet.addMergedRegion(region31);
        sheet.addMergedRegion(region32);
        sheet.addMergedRegion(region51);
        sheet.addMergedRegion(region52);
        sheet.addMergedRegion(region61);
        sheet.addMergedRegion(region62);

        // 创建居中样式
        CellStyle style = workbook.createCellStyle();
@@ -642,43 +648,46 @@

        row2.createCell(0).setCellValue("蓄电池号（#）");
        row2.createCell(1).setCellValue("蓄电池浮充电压值（V）");
        row2.createCell(2).setCellValue("放电前蓄电池开路电压值（V）");
        row2.createCell(3).setCellValue("放电前蓄电池开路电压值（V）");
        row2.createCell(4);

        row3.createCell(0).setCellValue("项目");
        row3.createCell(1).setCellValue("-1（电压）");
        row3.createCell(2).setCellValue("0（电压）");
        row3.createCell(3).setCellValue("0（温度）");
        row3.createCell(2).setCellValue("-1（温度）");
        row3.createCell(3).setCellValue("0（电压）");
        row3.createCell(4).setCellValue("0（温度）");

        //放电特定电压值
        int columnIndex = 3;
        int columnIndex = 5;
        if(dischargeColumnCount > 0){
            row2.createCell(5).setCellValue("放电0.5h蓄电池电压值（V）");
            CellRangeAddress region33 = new CellRangeAddress(2, 2,  4, 5);
            CellRangeAddress region53 = new CellRangeAddress(4, 4,  4, 5);
            CellRangeAddress region63 = new CellRangeAddress(5, 5,  4, 5);
            //row2.createCell(5).setCellValue("放电0.5h蓄电池电压值（V）");
            row2.createCell(columnCount).setCellValue("放电0.5h蓄电池电压值（V）");
            CellRangeAddress region33 = new CellRangeAddress(2, 2,  5, 6);
            CellRangeAddress region53 = new CellRangeAddress(4, 4,  5, 6);
            CellRangeAddress region63 = new CellRangeAddress(5, 5,  5, 6);

            sheet.addMergedRegion(region33);
            sheet.addMergedRegion(region53);
            sheet.addMergedRegion(region63);

            row3.createCell(4).setCellValue("0.5（电压）");
            row3.createCell(5).setCellValue("0.5（温度）");
            row3.createCell(5).setCellValue("0.5（电压）");
            row3.createCell(6).setCellValue("0.5（温度）");
            columnIndex+=2;
            if(dischargeColumnCount > 2){ //合并单元格了,所以索引+2
                row2.createCell(7).setCellValue("放电1h蓄电池电压值（V）");
                CellRangeAddress region34 = new CellRangeAddress(2, 2,  6, 7);
                CellRangeAddress region54 = new CellRangeAddress(4, 2,  6, 7);
                CellRangeAddress region64 = new CellRangeAddress(5, 2,  6, 7);
                //row2.createCell(7).setCellValue("放电1h蓄电池电压值（V）");
                row2.createCell(columnCount).setCellValue("放电1h蓄电池电压值（V）");
                CellRangeAddress region34 = new CellRangeAddress(2, 2,  7, 8);
                CellRangeAddress region54 = new CellRangeAddress(4, 4,  7, 8);
                CellRangeAddress region64 = new CellRangeAddress(5, 5,  7, 8);

                sheet.addMergedRegion(region34);
                sheet.addMergedRegion(region54);
                sheet.addMergedRegion(region64);

                row3.createCell(6).setCellValue("1（电压）");
                row3.createCell(7).setCellValue("1（温度）");
                row3.createCell(7).setCellValue("1（电压）");
                row3.createCell(8).setCellValue("1（温度）");
                columnIndex+=2;
                if(dischargeColumnCount > 4){
                    columnIndex++;
                    //放电nh蓄电池电压值（V）,n从2开始
                    for(int i = 4;i < dischargeColumnCount;i++){
                        row2.createCell(i+5).setCellValue("放电" + (i-2) + "h蓄电池电压值（V）");
@@ -691,28 +700,27 @@
        }

        //充电特定电压值
        row2.createCell(++columnIndex).setCellValue("放电结束0.5h后蓄电池开路电压值（V）");
        row2.createCell(columnIndex).setCellValue("放电结束0.5h后蓄电池开路电压值（V）");
        row3.createCell(columnIndex).setCellValue("10.5");
        columnIndex++;
        if(chargeColumnCount > 0){
            columnIndex++;
            row2.createCell(columnIndex).setCellValue("充电0.5h");

            columnIndex++;
            if(chargeColumnCount > 1){
                //充电nh,n从1开始
                for(int i = 1;i < chargeColumnCount;i++){
                    columnIndex++;
                    row2.createCell(columnIndex).setCellValue("充电" + (i) + "h蓄电池电压值（V）");
                    row3.createCell(columnIndex);//填充单元格的作用
                    columnIndex++;
                }

            }
        }
        row2.createCell(++columnIndex).setCellValue("充满后蓄电池电压值（V)（电流为0）");
        row2.createCell(columnIndex).setCellValue("充满后蓄电池电压值（V)（电流为0）");
        row3.createCell(columnIndex).setCellValue("11");
        row2.createCell(++columnIndex).setCellValue("备注");
        columnIndex++;
        row2.createCell(columnIndex).setCellValue("备注");
        row3.createCell(columnIndex);//填充单元格的作用



        //从rowIndex=4开始
        int rowIndex = 4;
@@ -837,21 +845,24 @@
            //rowTemp.createCell(4).setCellValue("放电前蓄电池开路温度值:"+(j+1)+"#");
            if(j == 0){
                rowTemp.createCell(1).setCellValue(fcVolList.get(j).getGroupVol());
                rowTemp.createCell(2).setCellValue(preVolList.get(j).getGroupVol());
                rowTemp.createCell(3);
                rowTemp.createCell(2);
                rowTemp.createCell(3).setCellValue(preVolList.get(j).getGroupVol());
                rowTemp.createCell(4);
            }else if (j == 1){
                rowTemp.createCell(1).setCellValue(fcVolList.get(j).getGroupCurr());
                rowTemp.createCell(2).setCellValue(preVolList.get(j).getGroupCurr());
                rowTemp.createCell(3);
                rowTemp.createCell(2);
                rowTemp.createCell(3).setCellValue(preVolList.get(j).getGroupCurr());
                rowTemp.createCell(4);
            }else {
                rowTemp.createCell(1).setCellValue(fcVolList.get(j).getMonVol());
                rowTemp.createCell(2).setCellValue(preVolList.get(j).getMonVol());
                rowTemp.createCell(3).setCellValue(preVolList.get(j).getMonTmp());
                rowTemp.createCell(2).setCellValue(fcVolList.get(j).getMonVol());
                rowTemp.createCell(3).setCellValue(preVolList.get(j).getMonVol());
                rowTemp.createCell(4).setCellValue(preVolList.get(j).getMonTmp());
            }


            //放电特定电压值
            int columnIndexTemp = 3;
            int columnIndexTemp = 5;
            Calendar dischargeCalendar = Calendar.getInstance();
            dischargeCalendar.setTime(dischargeStartTime);
            if(dischargeColumnCount > 0){
@@ -864,28 +875,70 @@
                dischargeListOneOriginal.sort(Comparator.comparingInt(BattRealTimeDataHistory::getMonNum));
                addStatistics(dischargeListOneOriginal,"vol");
                //总电流总电压列入
                Float groupVolDisOne = dischargeListOneOriginal.get(0).getGroupVol();
                Float groupCurrDisOne = dischargeListOneOriginal.get(0).getGroupCurr();

                BattRealTimeDataHistory groupVolDataDisOne = new BattRealTimeDataHistory();
                groupVolDataDisOne.setMonNum(-2);
                groupVolDataDisOne.setGroupVol(groupVolDisOne);

                BattRealTimeDataHistory groupCurrDataDisOne = new BattRealTimeDataHistory();
                groupCurrDataDisOne.setMonNum(-1);
                groupCurrDataDisOne.setGroupCurr(groupCurrDisOne);

                dischargeListOne.add(groupVolDataDisOne);
                dischargeListOne.add(groupCurrDataDisOne);
                dischargeListOne.addAll(dischargeListOneOriginal);

                //rowTemp.createCell(5).setCellValue("放电0.5h电压值（V）:"+(j+1)+"#");
                //rowTemp.createCell(6).setCellValue("放电0.5h温度值:"+(j+1)+"#");
                rowTemp.createCell(4).setCellValue(dischargeListOne.get(j).getMonVol());
                rowTemp.createCell(5).setCellValue(dischargeListOne.get(j).getMonTmp());
                if(j==0){
                    //rowTemp.createCell(5).setCellValue(dischargeListOne.get(j).getGroupVol());
                    rowTemp.createCell(columnIndexTemp).setCellValue(dischargeListOne.get(j).getGroupVol());
                }else if (j==1){
                    rowTemp.createCell(columnIndexTemp).setCellValue(dischargeListOne.get(j).getGroupCurr());
                }else {
                    rowTemp.createCell(columnIndexTemp).setCellValue(dischargeListOne.get(j).getMonVol());
                    rowTemp.createCell(columnIndexTemp+1).setCellValue(dischargeListOne.get(j).getMonTmp());
                }
                columnIndexTemp+=2;
                if(dischargeColumnCount > 2){ //合并单元格了,所以索引+2
                    //时间在测试开始时间+1h
                    dischargeCalendar.setTime(dischargeStartTime);
                    dischargeCalendar.add(Calendar.HOUR,1);
                    Date recordTimeTwo = dischargeCalendar.getTime();
                    List<BattRealTimeDataHistory> dischargeListTwo = battRTDataHisService.getRecordList(battGroupId,recordTimeTwo);
                    dischargeListTwo.sort(Comparator.comparingInt(BattRealTimeDataHistory::getMonNum));
                    addStatistics(dischargeListTwo,"vol");
                    List<BattRealTimeDataHistory> dischargeListTwo = new ArrayList<>();
                    List<BattRealTimeDataHistory> dischargeListTwoOriginal = battRTDataHisService.getRecordList(battGroupId,recordTimeTwo);
                    dischargeListTwoOriginal.sort(Comparator.comparingInt(BattRealTimeDataHistory::getMonNum));
                    addStatistics(dischargeListTwoOriginal,"vol");
                    //总电流总电压列入
                    Float groupVolDisTwo = dischargeListTwoOriginal.get(0).getGroupVol();
                    Float groupCurrDisTwo = dischargeListTwoOriginal.get(0).getGroupCurr();

                    BattRealTimeDataHistory groupVolDataDisTwo = new BattRealTimeDataHistory();
                    groupVolDataDisTwo.setMonNum(-2);
                    groupVolDataDisTwo.setGroupVol(groupVolDisTwo);

                    BattRealTimeDataHistory groupCurrDataDisTwo = new BattRealTimeDataHistory();
                    groupCurrDataDisTwo.setMonNum(-1);
                    groupCurrDataDisTwo.setGroupCurr(groupCurrDisTwo);

                    dischargeListTwo.add(groupVolDataDisTwo);
                    dischargeListTwo.add(groupCurrDataDisTwo);
                    dischargeListTwo.addAll(dischargeListTwoOriginal);

                    //rowTemp.createCell(7).setCellValue("放电1h电压值（V）:"+(j+1)+"#");
                    //rowTemp.createCell(8).setCellValue("放电1h温度值:"+(j+1)+"#");
                    rowTemp.createCell(6).setCellValue(dischargeListTwo.get(j).getMonVol());
                    rowTemp.createCell(7).setCellValue(dischargeListTwo.get(j).getMonTmp());
                    if (j==0) {
                        rowTemp.createCell(columnIndexTemp).setCellValue(dischargeListTwo.get(j).getGroupVol());
                    }else if (j==1){
                        rowTemp.createCell(columnIndexTemp).setCellValue(dischargeListTwo.get(j).getGroupCurr());
                    }else {
                        rowTemp.createCell(columnIndexTemp).setCellValue(dischargeListTwo.get(j).getMonVol());
                        rowTemp.createCell(columnIndexTemp+1).setCellValue(dischargeListTwo.get(j).getMonTmp());
                    }
                    columnIndexTemp+=2;
                    if(dischargeColumnCount > 4){
                        columnIndexTemp++;
                        //放电nh蓄电池电压值（V）,n从2开始
                        for(int i = 4;i < dischargeColumnCount;i++){
                            int dischargeHour = i-2;
@@ -893,11 +946,33 @@
                            dischargeCalendar.setTime(dischargeStartTime);
                            dischargeCalendar.add(Calendar.HOUR,dischargeHour);
                            Date recordTimeN = dischargeCalendar.getTime();
                            List<BattRealTimeDataHistory> dischargeListN = battRTDataHisService.getRecordList(battGroupId,recordTimeN);
                            dischargeListN.sort(Comparator.comparingInt(BattRealTimeDataHistory::getMonNum));
                            addStatistics(dischargeListN,"vol");
                            List<BattRealTimeDataHistory> dischargeListN = new ArrayList<>();
                            List<BattRealTimeDataHistory> dischargeListNOriginal = battRTDataHisService.getRecordList(battGroupId,recordTimeN);
                            dischargeListNOriginal.sort(Comparator.comparingInt(BattRealTimeDataHistory::getMonNum));
                            addStatistics(dischargeListNOriginal,"vol");
                            //总电流总电压列入
                            Float groupVolDisN = dischargeListNOriginal.get(0).getGroupVol();
                            Float groupCurrDisN = dischargeListNOriginal.get(0).getGroupCurr();

                            BattRealTimeDataHistory groupVolDataDisN = new BattRealTimeDataHistory();
                            groupVolDataDisN.setMonNum(-2);
                            groupVolDataDisN.setGroupVol(groupVolDisN);

                            BattRealTimeDataHistory groupCurrDataDisN = new BattRealTimeDataHistory();
                            groupCurrDataDisN.setMonNum(-1);
                            groupCurrDataDisN.setGroupCurr(groupCurrDisN);

                            dischargeListN.add(groupVolDataDisN);
                            dischargeListN.add(groupCurrDataDisN);
                            dischargeListN.addAll(dischargeListNOriginal);
                            //rowTemp.createCell(i+5).setCellValue("放电" + dischargeHour + "h蓄电池电压值（V）");
                            rowTemp.createCell(i+5).setCellValue(dischargeListN.get(j).getMonVol());
                            if(j==0){
                                rowTemp.createCell(columnIndexTemp).setCellValue(dischargeListN.get(j).getGroupVol());
                            }else if (j==1){
                                rowTemp.createCell(columnIndexTemp).setCellValue(dischargeListN.get(j).getGroupCurr());
                            }else {
                                rowTemp.createCell(columnIndexTemp).setCellValue(dischargeListN.get(j).getMonVol());
                            }
                            columnIndexTemp++;
                        }

@@ -907,36 +982,68 @@

            //填充放电0.5h后开路电压值
            if(j == 0){
                rowTemp.createCell(++columnIndexTemp).setCellValue(dischargeSetVolListOne.get(j).getGroupVol());
                rowTemp.createCell(columnIndexTemp).setCellValue(dischargeSetVolListOne.get(j).getGroupVol());
            }else if(j == 1){
                rowTemp.createCell(++columnIndexTemp).setCellValue(dischargeSetVolListOne.get(j).getGroupCurr());
                rowTemp.createCell(columnIndexTemp).setCellValue(dischargeSetVolListOne.get(j).getGroupCurr());
            }else {
                rowTemp.createCell(++columnIndexTemp).setCellValue(dischargeSetVolListOne.get(j).getMonVol());
                rowTemp.createCell(columnIndexTemp).setCellValue(dischargeSetVolListOne.get(j).getMonVol());
            }
            columnIndexTemp++;

            if(chargeColumnCount > 0){
                chargeCalendar = Calendar.getInstance();
                chargeCalendar.setTime(chargeStartTime);
                chargeCalendar.add(Calendar.MINUTE,30);
                List<BattRealTimeDataHistory> chargeVolListOne = battRTDataHisService.getRecordList(battGroupId, chargeCalendar.getTime());
                chargeVolListOne.sort(Comparator.comparingInt(BattRealTimeDataHistory::getMonNum));
                addStatistics(chargeVolListOne,"vol");
                columnIndexTemp++;
                List<BattRealTimeDataHistory> chargeVolListOne = new ArrayList<>();
                List<BattRealTimeDataHistory> chargeVolListOneOriginal = battRTDataHisService.getRecordList(battGroupId, chargeCalendar.getTime());
                chargeVolListOneOriginal.sort(Comparator.comparingInt(BattRealTimeDataHistory::getMonNum));
                addStatistics(chargeVolListOneOriginal,"vol");
                //总电流总电压列入
                Float groupVolChargeOne = chargeVolListOneOriginal.get(0).getGroupVol();
                Float groupCurrChargeOne = chargeVolListOneOriginal.get(0).getGroupCurr();

                BattRealTimeDataHistory groupVolDataChargeOne = new BattRealTimeDataHistory();
                groupVolDataChargeOne.setMonNum(-2);
                groupVolDataChargeOne.setGroupVol(groupVolChargeOne);

                BattRealTimeDataHistory groupCurrDataChargeOne = new BattRealTimeDataHistory();
                groupCurrDataChargeOne.setMonNum(-1);
                groupCurrDataChargeOne.setGroupCurr(groupCurrChargeOne);

                chargeVolListOne.add(groupVolDataChargeOne);
                chargeVolListOne.add(groupCurrDataChargeOne);
                chargeVolListOne.addAll(chargeVolListOneOriginal);
                //rowTemp.createCell(columnIndexTemp).setCellValue("充电0.5h");
                rowTemp.createCell(columnIndexTemp).setCellValue(chargeVolListOne.get(j).getMonVol());
                columnIndexTemp++;

                if(chargeColumnCount > 1){
                    //充电nh,n从1开始
                    for(int i = 1;i < chargeColumnCount;i++){
                        columnIndexTemp++;

                        chargeCalendar.setTime(chargeStartTime);
                        chargeCalendar.add(Calendar.HOUR,i);
                        List<BattRealTimeDataHistory> chargeVolListN = battRTDataHisService.getRecordList(battGroupId, chargeCalendar.getTime());
                        chargeVolListN.sort(Comparator.comparingInt(BattRealTimeDataHistory::getMonNum));
                        addStatistics(chargeVolListN,"vol");
                        List<BattRealTimeDataHistory> chargeVolListN = new ArrayList<>();
                        List<BattRealTimeDataHistory> chargeVolListNOriginal = battRTDataHisService.getRecordList(battGroupId, chargeCalendar.getTime());
                        chargeVolListNOriginal.sort(Comparator.comparingInt(BattRealTimeDataHistory::getMonNum));
                        addStatistics(chargeVolListNOriginal,"vol");
                        //总电流总电压列入
                        Float groupVolChargeN = chargeVolListNOriginal.get(0).getGroupVol();
                        Float groupCurrChargeN = chargeVolListNOriginal.get(0).getGroupCurr();

                        BattRealTimeDataHistory groupVolDataChargeN = new BattRealTimeDataHistory();
                        groupVolDataChargeN.setMonNum(-2);
                        groupVolDataChargeN.setGroupVol(groupVolChargeN);

                        BattRealTimeDataHistory groupCurrDataChargeN = new BattRealTimeDataHistory();
                        groupCurrDataChargeN.setMonNum(-1);
                        groupCurrDataChargeN.setGroupCurr(groupCurrChargeN);

                        chargeVolListN.add(groupVolDataChargeN);
                        chargeVolListN.add(groupCurrDataChargeN);
                        chargeVolListN.addAll(chargeVolListNOriginal);
                        //rowTemp.createCell(columnIndexTemp).setCellValue("充电" + (i) + "h蓄电池电压值（V）");
                        rowTemp.createCell(columnIndexTemp).setCellValue(chargeVolListN.get(j).getMonVol());
                        columnIndexTemp++;
                    }

                }
@@ -946,16 +1053,17 @@
            //rowTemp.createCell(++columnIndexTemp).setCellValue("充满后蓄电池电压值（V)（电流为0）");
            if (fcVolListAfter.size() > 0){
                if(j ==  0){
                    rowTemp.createCell(++columnIndexTemp).setCellValue(fcVolListAfter.get(j).getGroupVol());
                    rowTemp.createCell(columnIndexTemp).setCellValue(fcVolListAfter.get(j).getGroupVol());
                }else if(j == 1){
                    rowTemp.createCell(++columnIndexTemp).setCellValue(fcVolListAfter.get(j).getGroupCurr());
                    rowTemp.createCell(columnIndexTemp).setCellValue(fcVolListAfter.get(j).getGroupCurr());
                }else {
                    rowTemp.createCell(++columnIndexTemp).setCellValue(fcVolListAfter.get(j).getMonVol());
                    rowTemp.createCell(columnIndexTemp).setCellValue(fcVolListAfter.get(j).getMonVol());
                }
            }else {
                rowTemp.createCell(++columnIndexTemp).setCellValue("-");
                rowTemp.createCell(columnIndexTemp).setCellValue("-");
            }
            rowTemp.createCell(++columnIndexTemp).setCellValue("-");
            columnIndexTemp++;
            rowTemp.createCell(columnIndexTemp);
        }

        //=====================格式设置=====================//