问题出现状况：

1、获取excel中需要复制的表格区域范围的坐标位置，然后在word中创建表格进行复制

2、word 中的table的单元格宽度根据excel中的宽度或者缩放设置

3、当需要复制的区域范围每一列都为几列合并形成的，在word中合并单元格后就会出现word的table总宽度的宽度变窄问题。

问题原因分析：

测试发现table合并单元格后宽度只有合并前第一列的宽度，分析是table合并列宽并没有把宽度相加

解决方案：

计算需要合并的table的列宽相加，赋值给需要合并单元格的第一列的宽，问题得以解决

tips：先把需要合并单元格的宽度设置好之后再处理合并单元格的问题，否则又会出现总宽度变宽问题

public class WordTableMergeUntil {
    /**
     * 根据 excel 中的 sheet 合并单元格 格式化word中 table 的单元格合并问题
     *
     * @param sheet                 excel 的 sheet 页
     * @param table                 word 中的 table 对象
     * @param excelTableIndexDTO 表格对象在excel的坐标位置
     */
    public static void mergeTable(XSSFSheet sheet, XWPFTable table, ExcelTableIndexDTO excelTableIndexDTO) {

        int excelBeginCellIndex = excelTableIndexDTO.getBeginCellIndex();//excel 起始列
        int excelBeginRowIndex = excelTableIndexDTO.getBeginRowIndex();//excel 起始行
        int excelEndRowIndex = excelTableIndexDTO.getEndRowIndex();//excel 终止行
        // 获取excel中全量需要合并的单元格
        List<CellRangeAddress> mergedRegions = sheet.getMergedRegions();
        // 遍历为 table 中的单元格进行合并
        mergedRegions.forEach(cellAddresses -> {
            int firstRow = cellAddresses.getFirstRow();
            int lastRow = cellAddresses.getLastRow();
            int firstColumn = cellAddresses.getFirstColumn();
            int lastColumn;
            // 合并单元格范围不在表格对象范围内 主动拦截
            if (excelBeginCellIndex > firstColumn || excelBeginRowIndex > firstRow || excelEndRowIndex < lastRow ) {
                return;
            }
            firstRow = cellAddresses.getFirstRow() - excelBeginRowIndex;
            lastRow = cellAddresses.getLastRow() - excelBeginRowIndex;
            firstColumn = cellAddresses.getFirstColumn() - excelBeginCellIndex;
            lastColumn = cellAddresses.getLastColumn() - excelBeginCellIndex;

            // 解决合并单元格列宽问题
            if (firstColumn < lastColumn){
                BigDecimal count = new BigDecimal("0");
                for (int i = firstColumn; i <= lastColumn; i++) {
                    XWPFTableRow tableRow = table.getRow(firstRow);
                    Object width = tableRow.getCell(i).getCTTc().getTcPr().getTcW().getW();
                    if (null == width){
                        return;
                    }
                    count = count.add(new BigDecimal(width.toString()));
                }
                XWPFTableRow row = table.getRow(firstRow);
                if (row != null){
                    XWPFTableCell cell = row.getCell(firstColumn);
                    if (cell != null){
                        cell.getCTTc().addNewTcPr().addNewTcW().setW(count);
                    }
                }
            }

            if (firstRow == lastRow) { // 起始行和结束行一样  只合并当前列的列信息
                WordTableMergeUntil.mergeRow(table, firstRow, firstColumn, lastColumn);
            } else if (firstColumn == lastColumn) { // 起始列和结束列一样  只合并当前行的列信息
                WordTableMergeUntil.mergeCell(table, firstColumn, firstRow, lastRow);
            } else {// 起始行和结束行 起始列和结束列都不一样
                WordTableMergeUntil.mergeRowAndCell(table, firstRow, lastRow, firstColumn, lastColumn);
            }
        });
    }


    /**
     * 合并单元格 行合并
     *
     * @param table    表格对象`
     * @param beginRow 开始行索引
     * @param endRow   结束行索引
     * @param colIndex 合并列索引
     */
    private static void mergeCell(XWPFTable table, int colIndex, int beginRow, int endRow) {
        for (int rowIndex = beginRow; rowIndex <= endRow; rowIndex++) {

            XWPFTableRow tableRow = table.getRow(rowIndex);
            if (Objects.isNull(tableRow)) {
                return;
            }
            XWPFTableCell cell = tableRow.getCell(colIndex);
            if (null == cell){
                continue;
            }
            if (rowIndex == beginRow) {
                cell.getCTTc().addNewTcPr().addNewVMerge().setVal(STMerge.RESTART);
            } else {
                cell.getCTTc().addNewTcPr().addNewVMerge().setVal(STMerge.CONTINUE);
            }
        }
    }


    /**
     * 合并单元格  列合并
     *
     * @param table    表格对象
     * @param row      索引行
     * @param fromCell 开始行
     * @param toCell   结束列
     */
    private static void mergeRow(XWPFTable table, int row, int fromCell, int toCell) {
        if (fromCell == toCell || fromCell > toCell) {
            return;
        }
        XWPFTableRow tableRow = table.getRow(row);
        if (Objects.isNull(tableRow)) {
            return;
        }

        for (int cellIndex = fromCell; cellIndex <= toCell; cellIndex++) {
            XWPFTableCell cell = tableRow.getCell(cellIndex);
            if (null == cell){
                continue;
            }
            if (cellIndex == fromCell) {
                cell.getCTTc().addNewTcPr().addNewHMerge().setVal(STMerge.RESTART);
            } else {
                cell.getCTTc().addNewTcPr().addNewHMerge().setVal(STMerge.CONTINUE);
            }
        }
    }

    /**
     * 合并单元格  列合并
     *
     * @param table    表格对象
     * @param fromRow  开始索引行
     * @param toRow    结束索引行
     * @param fromCell 开始行
     * @param toCell   结束列
     */
    private static void mergeRowAndCell(XWPFTable table, int fromRow, int toRow, int fromCell, int toCell) {

        for (int rowIndex = fromRow; rowIndex <= toRow; rowIndex++) {
            mergeRow(table, rowIndex, fromCell, toCell);
        }
        for (int cellIndex = fromCell; cellIndex <= toCell; cellIndex++) {
            mergeCell(table, cellIndex, fromRow, toRow);
        }
    }

}