java通过正则批量修改xml文件中的属性值

最新推荐文章于 2024-01-04 14:54:08 发布
最新推荐文章于 2024-01-04 14:54:08 发布
阅读量846 收藏 4
点赞数
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36047517/article/details/121655431
版权 
/**
* 读取原xml文件转换为string类型
*/
 String content=XMLUtil.readFileToString(c:\12345.xml);
        
       /**
        *写正则定义xml中所有包含systemDiffCode的值进行定义
        * \w 表示匹配包括下划线的任何单词字符。等价于'[A-Za-z0-9_]'。
        */
        String regEx="systemDiffCode=\"(\\w+?)\"";
        Pattern pat=Pattern.compile(regEx);
        Matcher mat=pat.matcher(content);
        content=mat.replaceAll("systemDiffCode=\""+'10'+"\"");
        /**
        *写正则定义xml中所有包含systemCode的值进行定义
        */
        regEx="systemCode=\"(\\w+?)\"";
        pat=Pattern.compile(regEx);
        mat=pat.matcher(content);
        content=mat.replaceAll("systemCode=\""+'20'+"\"");

        System.out.print(content);

        /**
         * 写xml文件,形成新的xml文件
         */
        XMLUtil.WriteStringToXMLFile(content, "c:\\123.xml");
上面
content=mat.replaceAll("infoCode=\""+'10'+"\"");

content=mat.replaceAll("infoCode=\""+'20'+"\"");

10和20就是要替换的值，根据需要可以自行修改想要的值。

XMLUtil工具类：
package com.huige.utils;

import java.io.BufferedReader;
import java.io.ByteArrayInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.Writer;
import java.net.MalformedURLException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;


import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.dom4j.Attribute;
import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.DocumentHelper;
import org.dom4j.Element;
import org.dom4j.io.OutputFormat;
import org.dom4j.io.SAXReader;
import org.dom4j.io.XMLWriter;


public class XMLUtil {
    private static final Log logger = LogFactory.getLog(XMLUtil.class);
    private static final String XML_LINE_BREAK = "&#x000A";
    public static final String SUFFIX_XML = ".xml";

    private static boolean isExisDocType(String sourceXML) {
        if (sourceXML.indexOf("<!DOCTYPE") > 0) return true;
        return false;
    }

    public static String getXMLDoctypeToDoc(String sourceXML) {
        String doctype = "";
        if (sourceXML.indexOf("<!DOCTYPE") != -1) {
            doctype += sourceXML.substring(sourceXML.indexOf("<!DOCTYPE") + "<!DOCTYPE".length(), sourceXML.indexOf("]>") + 1);
        }
        return doctype;
    }

    /**
     * 解析带有doctype和不带有doctype定义的XML内容
     *
     * @param xmlStr
     * @return
     */
    public static Document parseStringOfDocTypeToDocument(String xmlStr) {
        try {
            SAXReader sax = new SAXReader();
            sax.setValidation(false);
            if (isExisDocType(xmlStr)) sax.setEntityResolver(new CopyrightTesolver());
            Document document = sax.read(new ByteArrayInputStream(xmlStr.getBytes("utf-8")));
            String doctypeString = getXMLDoctypeToDoc(xmlStr);
            if (null != document.getDocType()) document.getDocType().setElementName(doctypeString);
            return document;
        } catch (Exception e) {

            e.printStackTrace();
            return null;
        }
    }

    public static Document parseStringToDocument(String xmlStr) {
        try {

            Document document = DocumentHelper.parseText(xmlStr);

            return document;
        } catch (Exception e) {

            logger.error("XMLUtil:parseStringToDocument:" + xmlStr);
            e.printStackTrace();
            return null;
        }
    }

    /**
     * String Element
     *
     * @param xmlStr -
     *               xml String
     * @return Element
     */
    public static Element parseStringToElement(String xmlStr) {
        try {
            Document document = parseStringToDocument(xmlStr);
            if (document != null) {
                return document.getRootElement();
            } else {
                return null;
            }
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    /**
     * Element String
     *
     * @param element -
     *                Element
     * @return java.lang.String
     */

    public static String parseElementToString(Element element) {
        return element.asXML();
    }

    /**
     * Document String
     *
     * @param - document
     * @return java.lang.String
     */

    public static String parseDocumentToString(Document document) {

        return document.asXML();
    }


    /**
     * 
     *
     * @param filePath
     * @return javax.swing.text.Document
     * @throws DocumentException
     */
    public static String readFileToString(String filePath) {
        StringBuffer buf;
        try {
            InputStreamReader isr = new InputStreamReader(new FileInputStream(filePath), "utf-8");
            BufferedReader read = new BufferedReader(isr);
            buf = new StringBuffer();
            while (read.ready())
                buf.append((char) read.read());
            read.close();
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
        return buf.toString();
    }

    /**
     * @param @param filePath 设定文件
     * @return void 返回类型
     * @throws
     * @Title: addXMLDoctype
     * @Description: 为xml添加Doctype
     */
    public static String addXMLDoctype(String sourceXML, String filePath) {
        String xml = "";
        Document document = null;
        SAXReader reader = new SAXReader();
        reader.setEncoding("UTF-8");
        Writer wr = null;
        try {
            File xmlFile = new File(filePath);
            document = reader.read(xmlFile);
            wr = new OutputStreamWriter(new FileOutputStream(filePath), "UTF-8");
            xml = getXMLDoctype(sourceXML) + document.getRootElement().asXML();
            wr.write(xml);
            wr.flush();
            wr.close();
        } catch (DocumentException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return xml;
    }


    /**
     * @return 设定文件
     * @return String 返回类型
     * @throws
     * @Title: getXMLDoctype
     * @Description: 获取xml的Doctype
     */
    public static String getXMLDoctype(String sourceXML) {
        String doctype = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>";
        if (sourceXML.indexOf("<!DOCTYPE") != -1) {
            doctype += sourceXML.substring(sourceXML.indexOf("<!DOCTYPE"), sourceXML.indexOf("]>") + 2);
        }
        return doctype;
    }

    public static String readInToString(InputStream is) {
        StringBuffer buf;
        BufferedReader breader;

        try {
            breader = new BufferedReader(new InputStreamReader(is));
            buf = new StringBuffer();
            while (breader.ready())
                buf.append((char) breader.read());
            breader.close();
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }

        return buf.toString();

    }

    /**
     * Element
     *
     * @param
     * @param filePath -
     *                
     * @return boolean
     */
    public static Boolean WriteDocumentToFile(Document document, String filePath, String fileName) {
        //设置生成xml的格式
        OutputFormat format = OutputFormat.createPrettyPrint();
        //设置编码格式
        format.setEncoding("UTF-8");
        try {
            File targetFile = new File(filePath);
            if (!targetFile.exists()) {
                targetFile.mkdirs();
            }
            //生成XML文件
            File file = new File(filePath + fileName + SUFFIX_XML);
            XMLWriter writer = new XMLWriter(new FileOutputStream(file), format);
            //设置是否转义,默认使用转义字符
            writer.setEscapeText(false);
            writer.write(document);
            writer.close();
            return true;
        } catch (IOException e) {
            e.printStackTrace();
            return false;
        }
    }


    /**
     * 
     *
     * @param parentElement -
     *                      
     * @param attribute     -
     *                      document
     * @return javax.swing.text.Element
     */
    @SuppressWarnings("unchecked")
    public List<Element> getElementByAttribute(Element parentElement,
                                               Attribute attribute) {
        List<Element> nodeList = parentElement.elements();
        List<Element> returnList = new ArrayList();
        for (Element childNode : nodeList) {
            if (childNode.attributeValue(attribute.getName()).equals(
                    attribute.getValue())) {
                returnList.add(childNode);
            }
        }
        return null;
    }

    /**
     * 
     *
     * @param parentElement -
     *                     
     * @param -             Element??tagName
     * @return javax.swing.text.Element
     */
    public List<Element> getElementByTagName(Element parentElement,
                                             String tagName) {
        List<Element> list = parentElement.elements(tagName);
        return list;
    }

    /**
     *Element
     *
     * @param -      
     * @param element1 -Element
     * @param element2 -Element
     * @return boolean
     */
    public boolean getElementByTagName(Element element1, Element element2) {
        if (element1.asXML().equals(element2.asXML())) {
            return true;
        } else {
            return false;
        }

    }

    /**
     * 
     * 
     *
     * @param fileName
     * @return Document
     * @throws MalformedURLException
     * @throws DocumentException
     */
    public static Document read(String fileName) throws MalformedURLException,
            DocumentException {

        SAXReader reader = new SAXReader();

        Document document = reader.read(new File(fileName));

        return document;

    }

    /**
     * Root
     *
     * @param 
     * @return
     */
    public Element getRootElement(Document doc) {
        return doc.getRootElement();
    }


    /**
     * 
     *
     * @param -XML
     * @param id-XML ID
     * @param elementPath          --"ui/UiFormat"  "result/datasets"
     * @return
     */
    public static StringBuffer getSContent(String xml, String id,
                                           String elementPath) {
       
        StringBuffer sContent = new StringBuffer("");
        Document doc = null;
        doc = parseStringToDocument(xml);
        Element temp = null;
       
        temp = (Element) doc.selectSingleNode(elementPath + "[@id=" + id + "]");
        
        Iterator iterator = temp.elementIterator();
        
        while (iterator.hasNext()) {

            Element element1 = (Element) iterator.next();
            String value = parseElementToString(element1);
            sContent.append(value);
        }

        return sContent;
    }

    /**
     * 
     *
     * @param xml               
     * @param id                
     * @param elementPath??????
     * @return type?????
     * @throws Throwable
     */

    public static String getTypeFromContent(String xml, String id,
                                            String elementPath) throws Throwable {
        String value = null;
        Element foo = null;
        try {

            Document doc = null;
            doc = parseStringToDocument(xml);
            Element temp = null;
          
            temp = (Element) doc.selectSingleNode(elementPath + "[@id=" + id
                    + "]");
            Iterator iterator = temp.elementIterator();
            Element element1 = (Element) iterator.next();
            value = parseElementToString(element1);
            foo = parseStringToElement(value);

        } catch (Exception e) {
            e.printStackTrace();
            logger.info("IDtype");
            throw e;
        }
        return foo.elementText("type");
    }

    /**
     * @param xml
     * @param elementPath
     * @return
     * @throws DocumentException
     */
    public static String getNodeText(String xml, String elementPath)
            throws DocumentException {

        Element temp = null;
        Document doc = null;
        try {

            doc = XMLUtil.parseStringToDocument(xml);
            temp = (Element) doc.selectSingleNode(elementPath);
        } catch (Exception e) {
            e.printStackTrace();
            logger.info("!");
        }
        return temp.getText();
    }

    /**
     * 
     *
     * @param xml
     * @param id
     * @param elementPath
     * @return
     * @throws DocumentException
     */
    public static String getNodeTextById(String xml, String id,
                                         String elementPath, String s) throws DocumentException {
        String value = null;
        Element foo = null;

        Document doc = null;
        doc = parseStringToDocument(xml);
        Element temp = null;
        
        temp = (Element) doc.selectSingleNode(elementPath + "[@id=" + id + "]");
        Iterator iterator = temp.elementIterator();
        Element element1 = (Element) iterator.next();
        value = parseElementToString(element1);
        foo = parseStringToElement(value);

        return foo.elementText(s);
    }

    public static boolean WriteStringToXMLFile(String xmlStr, String filePath) {
        try {
            System.out.println("--------------------------" + filePath);
            Document document = DocumentHelper.parseText(xmlStr);
            OutputFormat format = OutputFormat.createPrettyPrint();
            format.setEncoding("utf-8");
            format.setNewLineAfterDeclaration(false);
            //format.setSuppressDeclaration(true);
            format.setIndent(true);
            //format.setNewlines(true);
            org.dom4j.io.XMLWriter xmlWriter = new org.dom4j.io.XMLWriter(
                    new FileOutputStream(filePath), format);
            xmlWriter.write(document);
            xmlWriter.close();
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }

    }

    /**
     * 
     *
     * @param xml <row><key>2008-01-07 13:32:17</key><value>0</value></row>
     * @param s   key
     * @return java.lang.string
     */
    public static String getNodeTextByTag(String xml, String s) {

        Element temp = null;
        temp = (Element) XMLUtil.parseStringToElement(xml);
        return temp.elementText(s);
    }

    /**
     * @param @return 
     * @return Document 
     * @throws
     * @Title: createNewDocument
     * @Description: ??Document??
     */
    public static Document createNewDocument() {
        Document doc = DocumentHelper.createDocument();
        return doc;
    }

    /**
     * @param @param  doc
     * @param @param  path
     * @param @throws IOException 
     * @return void
     * @throws
     * @Title: writeXML
     * @Description: 写入XML文件
     */
    public static void writeXML(Document doc, String path) throws IOException {
        try {
            WriteStringToUTF8File(doc.asXML(), path);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public static void WriteStringToUTF8File(String str, String filePath) throws Exception {
        FileOutputStream fos = null;
        OutputStreamWriter osw = null;
        try {
            fos = new FileOutputStream(filePath);
            osw = new OutputStreamWriter(fos, "utf-8");
            osw.write(str);
            osw.flush();
        } catch (RuntimeException e) {
            e.printStackTrace();
        } finally {
            if (osw != null) {
                osw.close();
            }
        }
    }

    public static boolean WriteDocUmentToFile(Document document, String filePath) {
        try {
            OutputFormat format=OutputFormat.createPrettyPrint();
            format.setEncoding("utf-8");
            format.setNewLineAfterDeclaration(true);
            //format.setSuppressDeclaration(true);
            format.setIndent(true);
            //format.setNewlines(true);
            format.setTrimText(true);
            org.dom4j.io.XMLWriter xmlWriter = new org.dom4j.io.XMLWriter(
                    new FileOutputStream(filePath),format);
            xmlWriter.write(document);
            xmlWriter.close();
            return true;
        } catch (Exception e) {

            e.printStackTrace();
            return false;
        }

    }
    
}

辉_哥
关注
hadoop配置文件详解系列（一）-core-site.xml篇
关于代码的那些事
03-09 4492
导读：关于hadoop的配置文件，目前其它网站资料中都是只写了几个常用的属性配置，但平时可能也会用到其它属性，这里就一起写出来，供大家参考。本篇先从core-site.xml开始，后续将继续进行其它配置文件的梳理。 属性名称 属性值 描述 hadoop.common.configuration.version 0.23.0 配置文件的版本。 hadoop.tmp.dir /tmp/hadoop-${user.name}
python批量修改xml配置文件
aabbcc_007008的博客
11-09 1270
# -*- coding:utf-8 -*- #! python 3.9.7 ''' 因为项目中有几十个xml配置文件要修改，每个文件有好几百行，手动修改工作量大还容易出错。 所以通过python脚本实现一个小工具，读取xml文件内容，修改属性的value值后，再重新写入xml文件。 该代码通过参考网络资源，临时拼凑起来的。 ''' import xml.dom.minidom # dom方式解析xml文件 import re,os # 正则表达式替换字符串 # 替换xml文件中的字符串 def .
使用Java结合Dom4j和XPath等API对xml文件进行批量增删改查
weixin_53273474的博客
11-29 478
对如何使用java语言结合dom4j和xpath对xml文件进行批量增删改查操作进行总结
java操作xml文件--修改节点
yffhhffv的博客
11-12 1555
java操作xml文件--修改节点
如何用java批量修改文件名和生成xml
weixin_44380181的博客
03-22 223
首先在Android studio项目中创建module library，选择类型为java的。然后编写java脚本，也就是带main方法的java类，包含批量处理的逻辑。通过File api，传入文件路径，即可获得所有路径下的文件进行批量处理。然后点击main方法左边的绿色按钮即可运行。
java 批量修改文件内容_Java正则表达式批量修改文件内容
weixin_39765588的博客
02-13 545
一个Java语言编写的，批量替换纯文本文件内容。使用说明：1. 需要修改的文件，修改内容都有共同点。2. 可以捕捉到被替换的内容，在被替换的内容上可以新增加自己的内容进行替换。3. 工具并没有提供相关的操作界面，只能通过main方法执行。4. 程序可以在原有的基础上进行扩展。5. 开发环境为： JDK1.7其中一段相关代码：package com.what21.tool.regex;im...
XML文件读取工具(Notepad++)
04-18
1. **语法高亮**：Notepad++能自动识别XML文件，并对其进行语法高亮，使得代码更易读，更容易区分元素、属性和值。 2. **代码折叠**：对于结构复杂的XML文件，Notepad++允许你折叠或展开元素，这样可以更好地管理和...
FormOSLScript：批量生成Java脚本并自定义id属性
资源摘要信息:"FormOSLScript是一个Java语言编写的工具或脚本，它允许用户根据预先设定的模板批量生成脚本，并对生成的脚本中特定的id属性进行修改。这种方式在处理大量相似脚本时特别有用，因为它可以自动化地完成...
java中的Ant构建_Ant构建
weixin_28686463的博客
02-26 1427
简介Apache Ant是一个Java库和命令行工具，其任务是将构建文件中描述的进程作为相互依赖的目标和扩展点。只要使用过Linux系统的读者，应该知道 make这个命令。当编译Linux内核及一些软件源程序时，经常要用这个命令。Make命令其实就 是一个项目管理工具，而Ant所实现功能与此类似，像make，gnumake和nmake这些编译工具都有 一定的缺陷，但是Ant却克服了这些工具的缺陷。...
easyexcel导入时读不到数据_java编程中通过easypoi导入excel文件并验证导入数据
weixin_40007804的博客
12-19 2481
引言现如今越来越多的web网站或者内部管理web系统都有自己的数据分析中心。其数据中心的数据有些来源于人工单独操作，某些来自人工搜集大量的信息后通过excel文件批量导入进系统。本博客将讲解在java编程中,通过excel文件导入数据的方法，其实现是通过国人基于Apache晦涩难懂的POI编写的easypoi框架。一.准备jdk 1.8+(由于本博客使用的spring boot框架所以jdk版本偏...
批量对xml文件指定内容的更改
02-15
1.实现了对文件夹中xml文件的筛选。 2.实现了对xml文件的批量更改。 3.正则表达式匹配具体的内容，修改并保存。
XML批量修改工具XMLPatch.zip
07-17
XMLPatch 是一个简单的工具，用来批量的修改 XML 文件，它使用 patch 文件的形式，包含要改动的内容，然后批量的应用到指定的 XML 文件，完成批量修改过程。 标签：XMLPatch
修改xml等文件
09-30
使用freemaker导出word，生成模版是在${和}之间总是会多出许多html标记，用UE等工具修改时很麻烦，因为一行太长。 使用方法：填写导出word模版xml文件，点击删除按钮就OK。
深度学习常用的工具（2）批量修改xml文件中的标签属性
12-21
深度学习常用的工具（2） 批量修改xml文件中的标签属性 """ 批量修改xml文件中的标签属性 对folder,filename和path内容进行修改，并同时去除文件名中的中文汉字 """ import re import os import xml.etree.ElementTree as ET def change_xml(xml_path): filelist = os.listdir(xml_path) # 打开xml文档 for xmlfile in filelist: # print(xmlfile) doc = ET.pa
XML编码批量转换工具
08-15
XML编码批量转换工具,可以将其它编码转成 utf-8 编码
批量修改xml文件中的内容
m0_56791536的博客
03-08 988
【代码】批量修改xml文件中的内容。
【实际开发04】- XxxMapper.xml/java - 批量处理
猫猫聚会ing ~ 的 博客
01-11 1398
1、查存时增加状态 status 条件 , 启动 status 禁用全局隐藏机制 - 20.10.24。连接查询 Where 限制主表 , 谨慎 : 使用副表限制 - ★。导致模糊查询 name 参数失效。API 调用返回结果集 : {}
JAVA批量新增、批量修改
最新发布
sungencheng的博客
01-04 2079
java批量新增、批量修改xml
Java正则表达式解析XML文件实战教程
"Java语言通过正则表达式解析XML文件的方法和步骤，包括创建Node类来表示XML节点，以及利用正则表达式提取XML的结构信息。" 在Java编程中，解析XML文件通常是通过DOM（Document Object Model）、SAX（Simple API ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值