在word中如何替换内容 WORD中如何替换文字

材料/工具：word2010

1、打开相应的word文档，比如我们要将文档中的“华为”全部改为“HUAWEI”。

2、点击“编辑”菜单，选择“查找”。

3、出现“查找和替换”对话框。选择“查找”选项卡，在“查找内容”输入框中输入“华为”。

4、并勾选“突出显示所有在该范围找到的项目”，word模板中点击“查找全部”按钮。

5、则文档中所有的“华为”都被选中。

6、点击“替换”选项卡，在“替换为”输入框中输入“HUAWEI”，点击”全部替换“。

7、则整个文档中所有需要替换文字的都被替换了。

在word中，如何进行部分替换

先选中你要替换的内容所在区域（比如说第一段），然后进行全部替换，然后就会弹出是否搜索其余部分内容的时候，选中否，就可以了

在word文档中怎样替换文字？

1、基本替换

用word替换文本是很简单的：首先打开一个文档，执行“编辑一〉替换”(或按“Ctrl+H”组合键)，打开“查找和替换”对话框，在“查找内容”右侧的方框中输入需要替换的字符，在“替换为”右侧的方框中输入替换后的字符，然后单击“全部替换”按钮即可。

2、格式替换

如果需要突出文档中某些特定字符，可以通过格式替换的方法将那些字符设置成不同字体格式(如“加粗、倾斜”等)。打开“查找和替换”对话框，在 “查找内容”和“替换为”右侧的方框中输入同样字符，然后将光标定在“替换为”右侧方框中，单击“高级”按钮展开高级选项，单击其中的“格式”按钮，在随后弹出的快捷菜单中，选择“字体”选项，打开“替换字体”对话框，将字型设置成“加粗倾斜”格式，点击“确定”返回，再单击“全部替换”按钮即可。

3、空行替换

用Word编辑从网上粘贴过来的文本时，常常含有多余空行，手工删除既累又烦，何不用空行替换的方法呢？打开“查找和替换”对话框，在“查找内容”右侧的方框中输入“^p^p”(p一定是小写格式)，在“替换为”右侧的方框中输入“^p”，然后根据空行的多少，反复按几次“全部替换”按钮，就完工了。

4、图片替换

如果一篇文档中，多处需要输入某个小图片，那么先在需要输入图片的地方输入某个特殊字母(笔者用的是五笔输入法，所以通常用字母“z”)，待文章全部录入完成后，通过“插入一〉图片一〉来自文件”等方法将小图片插入一个到文档中，并选中该图片，执行“复制”操作，再打开“查找和替换”对话框，在 “查找内容”后面的方框中输入字母“z”(默认情况下，可以不考虑大小写问题)，在“替换为”后面的方框中输入“^c”，单击“全部替换”按钮就行了。

5、通配替换

如果要想将文档中的书名(包含在书名号“《》”之间的部分)统一设置“黑体、红色”，可以利用通配符替换来实现：打开“查找和替换”对话框，展开 “高级”选项，选中其中的“使用通配符”选项，在“查找内容”中输入“《·》”，然后将光标定在“替换为”右侧的方框中，不输入内容，打开word文档“替换字体”对话框，将“中文字体”和“字体颜色”分别设置为“黑体”和“红色”，点击“确定”返回，再按一下“全部替换”按钮即可。

6、书签替换

在文档录入时，先将文档中要多次出现的字符(如“比上年同期增长128％”)输入到文档中，然后选中这一特定字符，执行“插入一〉书签”命令，打开“书签”对话框，输入一个便于理解的名称(如“zzb1”)，然后依次按“添加一取消”按钮返回。

以后需要输入该字符时，执行“插入-〉引用-〉交叉引用”命令，打开“交叉引用”对话框，按“引用类型”右侧的下拉按钮，在随后出现的下拉列表中，选择“书签”选项，然后选中其中需要的书签名称，再单击“插入”按钮即可。

通过这种方法输入的字符，如果对定义的书签内容进行了修改(如“比上年同期增长127.5％”)，只要按“Ctrl+A”。组合键选中全文，再按一下F9功能键，后面引用的内容会一次性作出相应的更改，起到文内批量替换的效果。

7、粘贴替换

在文档录入时，先将文档中要多次出现的字符(如“比上年同期增长128％”等)输入到文档中，然后选中这一特定字符，执行“复制”操作，再将光标定在需要再次输入此字符的位置上，执行“编辑-〉选择性粘贴”命令，打开“选择性粘贴”对话框，选中其中的“粘贴为链接”选项（其它选项不需要更改），点击“确定”返回。

这样，重复进行“选择性粘贴”就可以将上述字符插入到文档多处。此时，如果修改了最初的字符内容(如“比上年同期增长127.5％”)，则后续词条随之更新，也达到了批量替换的目的。

8、大小写替换

如果想将文档中的大(小)写字母，转换成小(大)写格式，可以这样来做：选中需要转换的文档区域，根据转换的实际需要，反复按“shifl+F3”组合键即可。

格式

Microsoft Word X (Mac OS X)

Microsoft Word在当前使用中是占有巨大优势的文字处理器，这使得Word专用的档案格式Word 文件（.doc）成为事实上最通用的标准。Word文件格式的详细资料并不对外公开。Word文件格式不只一种，因为随Word软件本身的更新，文件格式也会或多或少的改版，新版的格式不一定能被旧版的程序读取（大致上是因为旧版并未内建支援新版格式的能力）。微软已经详细公布Word 97的DOC格式，但是较新的版本资料仍未公开，只有公司内部、政府与研究机构能够获知。业界传闻说某些Word文件格式的特性甚至连微软自己都不清楚。

其他与Word竞争的办公室作业软件，都必须支援事实上最通用的Word专用的档案格式。因为Word文件格式的详细资料并不对外公开，通常这种兼容性是藉由逆向工程来达成。许多文字处理器都有汇出、汇入Word档案专用的转换工具，譬如AbiWord或OpenOffice。（参照文本编辑器当中关于其他竞争软件的说明。）Apache Jakarta POI是一个开放原始码的Java数据库，其主要目标是存取Word的二进制文件格式。不久前，微软自己也提供了检视器，能够不用Word程序就检视Word文件。例：Word Viewer 2003。

Microsoft office Word 97到Microsoft office Word 2003之前的Word文件格式都是二进制文件格式。不久以前，微软声明他们接下来将以XML为基础的档案格式作为他们办公室套装软件的格式。Word 2003提供WordprocessingML的选项。这是一种公开的XML档案格式，由丹麦政府等机构背书支持。Word 2003的专业版能够直接处理非微软的档案规格。

跟其它Microsoft Office程序一样，Word可使用固定宏语言（宏语言）来高度定制。（最初是WordBasic，但自从Microsoft office Word 97以来就变成Visual Basic）然而，这种性能也可以在文档中嵌入就像梅利莎蠕虫的电脑病毒。这就是电脑用户需要安装防火墙和反病毒软件的另一个原因。Microsoft's security advice

人们所知道的第一个感染Microsoft Word文档的病毒叫做概念病毒，一个相对危害很小的病毒，它的出现是为了证明宏病毒出现的可能性。

如何在Word中全部替换指定内容？

如果是要用另外的内容覆盖这几页内容，就先复制另外的内容，再选中这几页的内容，再粘贴，这几页内容就被替换掉了。

如果是要替换这几页中的部分相同文字，就选中这几页内容，再按CTRL+F，再在查找对话框中输入原文字，在替换为对话框中输入被替换成的文字，点全部替换就行了。

在Word文档中怎样将文字替换成自己要用的格式

这个用替换，但替换的不是文字，而是格式。

操作如下：

打开WORD-编辑-替换工具(或直接用 CTR+H 命令)，在替换对话框中输入：

查找内容:"行" 替换内容:"行"

点击该对话框下面左侧的"高级"选项,选中"替换为"中的"行"字。

在对话框最下方出现"格式"、“特殊字符”和“不限定格式”三个小的选项钮，选择“格式-字体”，在弹出的对话框中设置字体为“加粗”，字体颜色为“红色”，确定。

再回到替换对话框中，点击“全部替换”即可完成上述要求。

'工具-引用
Microsoft Word 16.0 Object Library (16会因为机器安装的版本不一)

WordApp.Selection.Find.ClearFormatting
WordDoc.Range.Find.Execute findtext:="被替换掉啥", ReplaceWith:="替换成啥", MatchWildcards:=True, Forward:=True, Replace:=wdReplaceAll, Wrap:=wdFindContinue


如果不引用，可以用数字代替
Replace选项
wdReplaceAll	2	替换所有匹配项。    
wdReplaceOne	1	替换遇到的第一个匹配项
wdReplaceNone	0	不替换任何匹配项。    

Wrap选项
wdFindAsk	2	搜索完所选内容或者区域后，Microsoft Word 会显示一条消息，询问是否搜索文档的其他部分。
wdFindContinue	1	到达搜索区域的开始或者结尾时，继续执行查找操作。
wdFindStop	0	到达搜索范围的开始或者结尾时，停止执行查找操作。

MatchWildcards 为 True，则可以指定通配符及其他高级搜索条件。例如，“*(ing)” 将查找以“ing”结尾的所有单词。详细内容
MatchCase  可选。如果是 True，则查找文本需区分大小写。相当于“编辑”菜单“查找和替换”对话框中的“区分大小写”复选框。
MatchWholeWord  可选。如果为 True，则只查找匹配的完整单词，而并非作为一个长单词的一部分的文字。相当于“编辑”菜单“查找和替换”对话框中的“全字匹配”复选框。

<!-- 需要用的包-->
<!-- https://mvnrepository.com/artifact/org.apache.poi/poi -->
<dependency>
    <groupId>org.apache.poi</groupId>
    <artifactId>poi</artifactId>
    <version>3.14</version>
</dependency>
<!-- https://mvnrepository.com/artifact/org.apache.poi/poi-ooxml -->
<dependency>
    <groupId>org.apache.poi</groupId>
    <artifactId>poi-ooxml</artifactId>
    <version>3.14</version>
</dependency>
<dependency>
    <groupId>org.apache.poi</groupId>
    <artifactId>poi-scratchpad</artifactId>
    <version>3.14</version>
</dependency>
<dependency>
    <groupId>org.apache.poi</groupId>
    <artifactId>poi-ooxml-schemas</artifactId>
    <version>3.14</version>
</dependency>

package com.example.demo.jisuan;

import org.apache.poi.POIXMLDocument;

import org.apache.poi.openxml4j.opc.OPCPackage;
import org.apache.poi.xwpf.usermodel.XWPFDocument;
import org.apache.poi.xwpf.usermodel.XWPFParagraph;
import org.apache.poi.xwpf.usermodel.XWPFRun;
import org.apache.poi.xwpf.usermodel.XWPFTable;
import org.apache.poi.xwpf.usermodel.XWPFTableCell;
import org.apache.poi.xwpf.usermodel.XWPFTableRow;

import java.io.ByteArrayInputStream;
import java.io.File;
import java.io.FileOutputStream;
import java.util.*;

import org.apache.xmlbeans.XmlCursor;
import org.openxmlformats.schemas.wordprocessingml.x2006.main.*;

import java.beans.IntrospectionException;
import java.beans.PropertyDescriptor;
import java.io.FileOutputStream;
import java.io.IOException;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.math.BigInteger;
import java.util.List;

public class WordUtil2 {


    /**
     * 替换word中指定字符串
     * 注意模板需要替换的字符串的格式
     * 1、要连着打出来，或者在别的地方写好粘过来
     * 2、先word转PDF，再将PDF转word
     * <p>
     * 替换word模板并生成新的word
     *
     * @param srcPath  模板地址
     * @param destPath 新的word地址
     * @param map      替换的内容
     * @return 是否成功替换
     */
    public static boolean newWord(String srcPath,
                                  String destPath, Map<String, Object> map) {
        //创建新的word文件
        File errorExcelfile = new File(destPath);
        if (!errorExcelfile.exists()) {
            File file = errorExcelfile.getParentFile();
            if (!file.exists())
                file.mkdirs();
        }
        try {
            OPCPackage opcPackage = POIXMLDocument.openPackage(srcPath);
            CustomXWPFDocument doc = new CustomXWPFDocument(opcPackage);
            // 替换段落中的指定文字
            Iterator<XWPFParagraph> itPara = doc.getParagraphsIterator();
            while (itPara.hasNext()) {
                XWPFParagraph paragraph = (XWPFParagraph) itPara.next();
                List<XWPFRun> runs = paragraph.getRuns();
                for (int i = 0; i < runs.size(); i++) {
                    //遍历读取模板的内容
                    String oneparaString = runs.get(i).getText(runs.get(i).getTextPosition());
                    if (oneparaString == null) {
                        continue;
                    }
                    //遍历要替换的内容  和模板相同字符串的key 被替换为value
                    for (Map.Entry<String, Object> entry : map.entrySet()) {
                        String key = entry.getKey();
                        if (oneparaString.indexOf(key) != -1) {
                            Object value = entry.getValue();
                            if (value instanceof String) {
                                oneparaString = oneparaString.replace(entry.getKey(), entry.getValue().toString());
                            } else if (value instanceof Map) {
                                //判断如果值是map类型 就说明是图片
                                oneparaString = oneparaString.replace(key, "");
                                Map pic = (Map) value;
                                int width = Integer.parseInt(pic.get("width").toString());
                                int height = Integer.parseInt(pic.get("height").toString());
                                int picType = getPictureType(pic.get("type").toString());
                                byte[] byteArray = (byte[]) pic.get("content");
                                ByteArrayInputStream byteInputStream = new ByteArrayInputStream(byteArray);
                                //以字节流的形式 向  XWPFParagraph 添加图片
                                doc.addPictureData(byteInputStream, picType);
                                //创建图片模板
                                doc.createPicture(doc.getAllPictures().size() - 1, width, height, paragraph);
                            }
                        }
                    }
                    runs.get(i).setText(oneparaString, 0);
                }
            }

            FileOutputStream outStream = null;
            outStream = new FileOutputStream(destPath);
            doc.write(outStream);
            outStream.close();
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }

    }

    /**
     * 根据图片类型，取得对应的图片类型代码
     *
     * @param picType
     * @return int
     */
    private static int getPictureType(String picType) {
        int res = CustomXWPFDocument.PICTURE_TYPE_PICT;
        if (picType != null) {
            if (picType.equalsIgnoreCase("png")) {
                res = CustomXWPFDocument.PICTURE_TYPE_PNG;
            } else if (picType.equalsIgnoreCase("dib")) {
                res = CustomXWPFDocument.PICTURE_TYPE_DIB;
            } else if (picType.equalsIgnoreCase("emf")) {
                res = CustomXWPFDocument.PICTURE_TYPE_EMF;
            } else if (picType.equalsIgnoreCase("jpg") || picType.equalsIgnoreCase("jpeg")) {
                res = CustomXWPFDocument.PICTURE_TYPE_JPEG;
            } else if (picType.equalsIgnoreCase("wmf")) {
                res = CustomXWPFDocument.PICTURE_TYPE_WMF;
            }
        }
        return res;
    }



    public static void main(String[] args) {
        System.out.println("hello world");
        List<Person> dtos = new ArrayList<>();
        for (int i = 0; i < 20; i++) {
            Person dto = new Person();
            if(i%3==0){
                dto.setName("张三" + i);
                dto.setSex("nan" + i);
                dto.setAge("11" + i);
                dtos.add(dto);
            }else{
                dto.setName("");
                dto.setSex("nan" + i);
                dto.setAge("");
                dtos.add(dto);
            }

        }
        List<String> head = new ArrayList<>();
        head.add("姓名");
        head.add("年龄");
        head.add("性别");
        String srcPath = "F:\\jinxin.docx";
        String targetPath = "F:\\jinxin1.docx";
        String key = "liebiaotable";// 在文档中需要替换插入表格的位置
        exportBg(head, dtos, srcPath, targetPath, key);
    }

//    public static void main(String[] args) {
//        Map<String,Object> map = new HashMap<>();
//        map.put("需求说明","测试替换");
//        newWord("F:\\jin.docx","F:\\jinxin.docx",map);
//    }

    /**
     * 替换word中指定字符串（这里用来将字符串替换为表格，上边的newWord用来替换文字等）
     * @param head 表头
     * @param data 数据
     * @param srcPath 需要操作的文档模板
     * @param targetPath 操作完后输出的位置
     * @param key 需要替换的文字，如果需要替换多个位置就用个map啥的
     * @param <T>
     */
    //创建一个表格插入到key标记的位置
    public static <T> void exportBg(List<String> head, List<T> data, String srcPath, String targetPath, String key) {
        XWPFDocument doc = null;
        try {
            doc = new XWPFDocument(POIXMLDocument.openPackage(srcPath));
            List<XWPFParagraph> paragraphList = doc.getParagraphs();
            if (paragraphList != null && paragraphList.size() > 0) {
                for (XWPFParagraph paragraph : paragraphList) {
                    List<XWPFRun> runs = paragraph.getRuns();
                    for (int i = 0; i < runs.size(); i++) {
                        String text = runs.get(i).getText(0);
                        if (text != null) {
                            text = text.trim();
                            if (text.indexOf(key) >= 0) {
                                runs.get(i).setText(text.replace(key, ""), 0);
                                XmlCursor cursor = paragraph.getCTP().newCursor();
                                // 在指定游标位置插入表格
                                XWPFTable table = doc.insertNewTbl(cursor);

                                CTTblPr tablePr = table.getCTTbl().getTblPr();
                                CTTblWidth width = tablePr.addNewTblW();
                                //获取这个东西用来改表格宽度
                                width.setW(BigInteger.valueOf(7000));

                                insertInfo(table, head, data);
                                break;
                            }
                        }
                    }
                }
            }
            FileOutputStream os = new FileOutputStream(targetPath);
            doc.write(os);
            os.flush();
            os.close();
        } catch (IOException | IllegalAccessException | IntrospectionException | InvocationTargetException e) {
            e.printStackTrace();
        }


    }

    /**
     * 把信息插入表格
     */
    private static <T> void insertInfo(XWPFTable table, List<String> head, List<T> data) throws IntrospectionException, InvocationTargetException, IllegalAccessException {
        //获取第一行
        XWPFTableRow row = table.getRow(0);
//        //获取这个东西用来改表格宽度
//        CTTblPr tblPr = table.getCTTbl().getTblPr();
//        //改变长度策略为自己调整 默认为auto
//        tblPr.getTblW().setType(STTblWidth.DXA);
//        //设置表格宽度为7000
//        tblPr.getTblW().setW(BigInteger.valueOf(10));
        //根据头创建表格head
        for (int col = 1; col < head.size(); col++) {//默认会创建一列，即从第2列开始
            // 第一行创建了多少列，后续增加的行自动增加列
            CTTcPr cPr = row.createCell().getCTTc().addNewTcPr();
            //设置单元格高度为500
            row.getCtRow().addNewTrPr().addNewTrHeight().setVal(BigInteger.valueOf(500));
            //可以用来设置单元格长度
            //CTTblWidth width = cPr.addNewTcW();
            //width.setW(BigInteger.valueOf(2000));
        }
        //循环给表格添加头信息
        for (int i = 0; i < head.size(); i++) {
            //往表格里面写入头信息
            row.getCell(i).setText(head.get(i));
        }
        //计数器
        int i = 0;
        //循环填充body列表（列表为vo数组）
        for (T item : data) {
            //获取类
            Class<?> clazz = item.getClass();
            //获取item字段
            Field[] fields = item.getClass().getDeclaredFields();
            //创建行
            row = table.createRow();
            //修改行高为500
            row.getCtRow().addNewTrPr().addNewTrHeight().setVal(BigInteger.valueOf(1000));
            //循环获取vo类的属性
            for (Field field : fields) {
                //获取当前field的属性描述器
                PropertyDescriptor descriptor = new PropertyDescriptor(field.getName(), clazz);
                //获取field字段的get方法
                Method readMethod = descriptor.getReadMethod();
                //执行get方法并填充到表格中
                row.getCell(i).setText(String.valueOf(readMethod.invoke(item)));
                //计数器+1
                i++;
            }
            //执行完一行计数器归零
            i = 0;
        }
        mergeCellsVertically(table,0,1,4);

    }

    /**
     *
     * @param table 自己猜
     * @param col  第几列
     * @param fromRow  开始行
     * @param toRow   结束行
     */
    // word跨行并单元格
    public static void mergeCellsVertically(XWPFTable table, int col, int fromRow, int toRow) {
        for (int rowIndex = fromRow; rowIndex <= toRow; rowIndex++) {
            XWPFTableCell cell = table.getRow(rowIndex).getCell(col);
            if ( rowIndex == fromRow ) {
                // The first merged cell is set with RESTART merge value
                cell.getCTTc().addNewTcPr().addNewVMerge().setVal(STMerge.RESTART);
            } else {
                // Cells which join (merge) the first one, are set with CONTINUE
                cell.getCTTc().addNewTcPr().addNewVMerge().setVal(STMerge.CONTINUE);
            }
        }
    }

    /**
     * 列的我这里没用，留着备用
     * @param table
     * @param row
     * @param fromCell
     * @param toCell
     */
//    // word跨列合并单元格
//    public  void mergeCellsHorizontal(XWPFTable table, int row, int fromCell, int toCell) {
//        for (int cellIndex = fromCell; cellIndex <= toCell; cellIndex++) {
//            XWPFTableCell cell = table.getRow(row).getCell(cellIndex);
//            if (cellIndex == fromCell) {
//                // The first merged cell is set with RESTART merge value
//                cell.getCTTc().addNewTcPr().addNewHMerge().setVal(STMerge.RESTART);
//            } else {
//                // Cells which join (merge) the first one, are set with CONTINUE
//                cell.getCTTc().addNewTcPr().addNewHMerge().setVal(STMerge.CONTINUE);
//            }
//        }
//    }


}

、、

<!-- 之前打算用这个包的方法开发来着，没研究明白所以放弃了 -->
<dependencies>
<!--        <dependency>-->
<!--            <groupId>e-iceblue</groupId>-->
<!--            <artifactId>spire.doc.free</artifactId>-->
<!--            <version>3.9.0</version>-->
<!--        </dependency>-->
<!--        <dependency>-->
<!--            <groupId>e-iceblue</groupId>-->
<!--            <artifactId>spire.xls.free</artifactId>-->
<!--            <version>3.9.1</version>-->
<!--        </dependency>-->
<!--        <dependency>-->
<!--            <groupId> e-iceblue </groupId>-->
<!--            <artifactId>spire.office</artifactId>-->
<!--            <version>4.8.0</version>-->
<!--        </dependency>-->
</dependencies>
<repositories>
        <repository>
            <id>com.e-iceblue</id>
            <url>https://repo.e-iceblue.cn/repository/maven-public/</url>
        </repository>
    </repositories>