java多word文档合并

最新推荐文章于 2026-05-05 07:44:21 发布

原创最新推荐文章于 2026-05-05 07:44:21 发布 · 990 阅读

9 ·

本内容遵循CC 4.0 BY-SA版权协议

GEO检测

标签

#java

该文章已生成可运行项目，

要将 4 份 Word 文档按顺序合并成一份，在 Java 中可以通过操作 Word 文档的 API 来实现。以下是详细的思路和方案：

实现思路

选择合适的库：使用 Apache POI 或 Aspose.Words 等库操作 Word 文档

读取源文档：依次读取 4 个 Word 文档的内容

创建目标文档：新建一个空白 Word 文档作为合并后的结果

复制内容：按顺序将 4 个源文档的内容复制到目标文档中

保存结果：将合并后的文档保存到指定位置

实现方案（使用 Apache POI）

Apache POI 是处理 Microsoft 文档的开源库，支持.docx 格式。下面是具体实现代码：

Java合并多个Word文档

import org.apache.poi.openxml4j.exceptions.InvalidFormatException;
import org.apache.poi.xwpf.usermodel.*;

import java.io.*;
import java.util.List;

public class WordMerger {
    
    /**
     * 合并多个Word文档
     * @param sourceFiles 源文档路径数组
     * @param targetFile 目标文档路径
     * @throws IOException IO异常
     * @throws InvalidFormatException 格式异常
     */
    public static void mergeWordDocuments(String[] sourceFiles, String targetFile) 
            throws IOException, InvalidFormatException {
        // 创建目标文档
        XWPFDocument targetDoc = new XWPFDocument();
        
        for (String sourceFile : sourceFiles) {
            // 读取源文档
            try (InputStream in = new FileInputStream(sourceFile)) {
                XWPFDocument sourceDoc = new XWPFDocument(in);
                
                // 复制段落
                copyParagraphs(sourceDoc, targetDoc);
                
                // 复制表格
                copyTables(sourceDoc, targetDoc);
                
                // 复制图片
                copyImages(sourceDoc, targetDoc);
                
                sourceDoc.close();
            }
        }
        
        // 保存目标文档
        try (FileOutputStream out = new FileOutputStream(targetFile)) {
            targetDoc.write(out);
        }
        targetDoc.close();
    }
    
    /**
     * 复制段落
     */
    private static void copyParagraphs(XWPFDocument sourceDoc, XWPFDocument targetDoc) {
        List<XWPFParagraph> sourceParagraphs = sourceDoc.getParagraphs();
        for (XWPFParagraph para : sourceParagraphs) {
            XWPFParagraph newPara = targetDoc.createParagraph();
            copyParagraph(para, newPara);
        }
    }
    
    /**
     * 复制单个段落内容和样式
     */
    private static void copyParagraph(XWPFParagraph source, XWPFParagraph target) {
        // 复制段落样式
        target.getCTP().setPPr(source.getCTP().getPPr());
        
        // 复制段落内容
        List<XWPFRun> runs = source.getRuns();
        if (runs != null) {
            for (XWPFRun run : runs) {
                XWPFRun newRun = target.createRun();
                copyRun(run, newRun);
            }
        }
    }
    
    /**
     * 复制文本运行元素
     */
    private static void copyRun(XWPFRun source, XWPFRun target) {
        target.setText(source.getText(0));
        target.setFontFamily(source.getFontFamily());
        target.setFontSize(source.getFontSize());
        target.setBold(source.isBold());
        target.setItalic(source.isItalic());
        target.setUnderline(source.getUnderline());
        target.setColor(source.getColor());
    }
    
    /**
     * 复制表格
     */
    private static void copyTables(XWPFDocument sourceDoc, XWPFDocument targetDoc) {
        List<XWPFTable> tables = sourceDoc.getTables();
        for (XWPFTable table : tables) {
            XWPFTable newTable = targetDoc.createTable();
            
            // 复制表格样式
            newTable.getCTTbl().setTblPr(table.getCTTbl().getTblPr());
            
            // 复制表格内容
            copyTableRows(table, newTable);
        }
    }
    
    /**
     * 复制表格行
     */
    private static void copyTableRows(XWPFTable sourceTable, XWPFTable targetTable) {
        List<XWPFTableRow> rows = sourceTable.getRows();
        for (int i = 0; i < rows.size(); i++) {
            XWPFTableRow sourceRow = rows.get(i);
            XWPFTableRow targetRow;
            
            // 第一行使用已创建的行，其他行需要新增
            if (i == 0) {
                targetRow = targetTable.getRow(0);
            } else {
                targetRow = targetTable.createRow();
            }
            
            // 复制行样式
            targetRow.getCtRow().setTrPr(sourceRow.getCtRow().getTrPr());
            
            // 复制单元格
            copyTableCells(sourceRow, targetRow);
        }
    }
    
    /**
     * 复制表格单元格
     */
    private static void copyTableCells(XWPFTableRow sourceRow, XWPFTableRow targetRow) {
        List<XWPFTableCell> cells = sourceRow.getTableCells();
        for (int j = 0; j < cells.size(); j++) {
            XWPFTableCell sourceCell = cells.get(j);
            XWPFTableCell targetCell;
            
            // 确保目标行有足够的单元格
            if (j < targetRow.getTableCells().size()) {
                targetCell = targetRow.getCell(j);
            } else {
                targetCell = targetRow.addNewTableCell();
            }
            
            // 复制单元格样式
            targetCell.getCTTc().setTcPr(sourceCell.getCTTc().getTcPr());
            
            // 复制单元格内容
            List<XWPFParagraph> cellParagraphs = sourceCell.getParagraphs();
            for (XWPFParagraph para : cellParagraphs) {
                XWPFParagraph newPara = targetCell.addParagraph();
                copyParagraph(para, newPara);
            }
        }
    }
    
    /**
     * 复制图片
     */
    private static void copyImages(XWPFDocument sourceDoc, XWPFDocument targetDoc) {
        // 图片处理相对复杂，需要处理二进制数据
        List<XWPFPictureData> pictures = sourceDoc.getAllPictures();
        for (XWPFPictureData picture : pictures) {
            targetDoc.addPictureData(picture.getData(), picture.getPictureType());
        }
    }
    
    // 测试方法
    public static void main(String[] args) {
        try {
            // 要合并的4个Word文档路径，按顺序排列
            String[] sourceFiles = {
                "document1.docx",
                "document2.docx",
                "document3.docx",
                "document4.docx"
            };
            
            // 合并后的文档路径
            String targetFile = "merged_document.docx";
            
            // 执行合并
            mergeWordDocuments(sourceFiles, targetFile);
            System.out.println("文档合并成功！");
            
        } catch (Exception e) {
            e.printStackTrace();
            System.out.println("文档合并失败：" + e.getMessage());
        }
    }
}

使用说明

添加依赖：需要在项目中添加 Apache POI 的依赖

xml

<dependency>
    <groupId>org.apache.poi</groupId>
    <artifactId>poi-ooxml</artifactId>
    <version>5.2.3</version>
</dependency>

使用方法：
- 将需要合并的 4 个 Word 文档路径按顺序放入sourceFiles数组
- 指定合并后的文档路径targetFile
- 调用mergeWordDocuments方法执行合并

注意事项：

该方案适用于.docx 格式，不适用于.doc 格式
复杂的 Word 格式（如页眉页脚、复杂图表等）可能需要额外处理

大型文档合并可能需要考虑内存使用情况

替代方案

如果需要处理更复杂的 Word 格式，可以考虑使用 Aspose.Words（商业库），它提供了更完善的文档合并功能，代码也更简洁，但需要购买许可（目前测试未提示购买）。

使用 Aspose.Words 的核心合并代码如下：

java

运行

package com.example.demo;

import com.aspose.words.Document;
import com.aspose.words.ImportFormatMode;

public class test {

    public static void main(String[] args) throws Exception {
        Document doc = new Document("D:\\test\\1.doc");
        doc.appendDocument(new Document("D:\\test\\2.doc"), ImportFormatMode.KEEP_SOURCE_FORMATTING);
        doc.appendDocument(new Document("D:\\test\\3.doc"), ImportFormatMode.KEEP_SOURCE_FORMATTING);
        doc.appendDocument(new Document("D:\\test\\4.doc"), ImportFormatMode.KEEP_SOURCE_FORMATTING);
        doc.save("D:\\test\\test2.docx");
    }
}

依赖：

<dependency>
            <groupId>com.luhuiguo</groupId>
            <artifactId>aspose-cells</artifactId>
            <version>23.1</version>
        </dependency>

        <dependency>
            <groupId>com.luhuiguo</groupId>
            <artifactId>aspose-words</artifactId>
            <version>23.1</version>
        </dependency>

选择哪种方案取决于你的需求复杂度和预算情况。对于简单的文档合并，Apache POI 完全可以满足需求。

本文章已经生成可运行项目