精华内容
下载资源
问答
  • java读取xml文件

    2018-03-15 14:59:22
    文档中有代码案例,详细讲解了使用java读取xml,并附带有关于xml的dtd讲解,里面包含详细的文档和代码案例。和读取xml所需的jar。
  • //通过文件路径及文件名读取xml public XMLReader(String path, String filename); //初始化读取包下的的XML文件 public XMLReader(Package package1, String fileName); //读取WEB-INF下的xml文件 public XMLReader...
  • JAVA操作XML文件

    2019-03-30 01:46:12
    NULL 博文链接:https://aa00aa00.iteye.com/blog/1330577
  • 例如xml文件的形式是<student><age>1</age><age2>2</age2></student>,在Java文件中设置demo路径,要替换的值,最后分别生成xml文件,例如要换成aa,则xml两个,一个为<student><age>aa</age><age>2</age></student>,...
  • java 读取xml文件生成树形图

    热门讨论 2012-12-21 13:38:54
    java代码读取xml文件,生成树形图。这里是源码,可直接使用,是我项目中提取生成树的核心文件。
  • java读取和写入xml文件

    2017-02-27 22:27:56
    该资源包含了java四种方式读取和写入xml文件的代码
  • java读取xml文件导入到mysql数据库中

    热门讨论 2013-08-30 12:33:25
    xml文件导入到mysql数据库中,包括文件:ConnectionUtils.java,InsertDT.java,db_mysql.properties,test01.xml,需要的jar包dom4j-1.6.1.jar,mysql-connection-java-3.1.1.3-bin.jar,jaxen-1.1-beta-7.jar
  • 主要介绍了通过Java读取xml文件内容过程解析,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • Java操作XML文件

    千次阅读 多人点赞 2019-08-30 09:21:57
    目录 一、使用DOM4j进行XML的DOM解析 1.1、使用DOM4j查询XML文档 1.2、使用DOM4j修改XML文档 1.3、使用xPath技术 ... Java中有两种解析XML文件的方式:DOM解析和SAX解析。 一、使用DOM4j进行XML的DOM解析 ...

    目录

    一、使用DOM4j进行XML的DOM解析

    1.1、使用DOM4j查询XML文档

    1.2、使用DOM4j修改XML文档

    1.3、使用xPath技术

    二、使用SAX方式解析XML文档

    2.1、使用SAX解析方式查询XML文档

    2.2、对比DOM解析和SAX解析


        Java中有两种解析XML文件的方式:DOM解析和SAX解析。

    一、使用DOM4j进行XML的DOM解析

        DOM解析是一次性将整个XML文档加载进内存,在内存中构建Document的对象树,通过Document对象,得到树上的节点对象,通过节点对象访问(操作)到XML文档的内容。

        通常使用Dom4j工具进行XML的DOM解析,首先要到Dom4j的官网https://dom4j.github.io/下载包并加载到IDE开发工具中(例如eclipse)。

    1.1、使用DOM4j查询XML文档

        XML文档在DOM解析中可以被映射为多种节点,其中比较重要和常见的是元素节点(Element)、属性节点(Attribute)和文本节点(Text)。

        查询节点主要可以使用以下方法:

    • Document new SAXReader().read(File file)    ——    读取XML文档 
    • Element Document.getRootElement()    ——    获取XML文档的根元素节点
    • Iterator Element.nodeIterator()    ——    获取当前元素节点下的所有子节点
    • Iterator<Element> Element.elementIterator(元素名)    ——    指定名称的所有子元素节点
    • Iterator<Attribute> Element.attributeIterator()    ——    获取所有子属性节点
    • List<Element> Element.elements()    ——    获取所有子元素节点
    • List<Attribute> Element.attributes()    ——    获取所有子属性字节
    • Element Element.element(元素名)    ——    指定名称的第一个子元素节点
    • Attribute Element.attribute(属性名)    ——    获取指定名称的子属性节点
    • String Element.attributeValue(属性名)    ——    获取指定名称的子属性的属性值
    • String Attribute.getName()    ——    获取属性名称
    • String Attribute.getValue()    ——    获取属性值
    • String Element.getText()    ——    获取当前元素节点的子文本节点
    • String Element.elementText(元素名)    ——    获取当前元素节点的指定名称的子文本节点

        示例:在eclipse中读取以下students.xml文档的内容,并打印至控制台

    <?xml version="1.0" encoding="UTF-8"?>
    
    <Students>
      <Student id="001">
        <name>张三</name>
        <age>19</age>
        <gender>男</gender>
        <grade>计算机1班</grade>
      </Student>
      <Student id="002">
        <name>李四</name>
        <age>20</age>
        <gender>男</gender>
        <grade>计算机2班</grade>
      </Student>
    </Students>
    
    package xml;
    
    import java.io.File;
    import java.util.List;
    
    import org.dom4j.Attribute;
    import org.dom4j.Document;
    import org.dom4j.DocumentException;
    import org.dom4j.Element;
    import org.dom4j.io.SAXReader;
    
    public class ReadAndPrintXML {
    	public static void main(String[] args) throws Exception {
    		// 创建一个XML解析器对象
    		SAXReader reader = new SAXReader();
    		// 读取XML文档,返回Document对象
    		Document document = reader.read(new File("E:\\xml\\students.xml"));
    		
    		// 获取根元素节点
    		Element root = document.getRootElement();
    		StringBuilder sb = new StringBuilder();
    		recursion(root, sb);
    		System.out.println(sb.toString());
    	}
    	
    	private static void recursion(Element ele, StringBuilder sb) {
    		sb.append("<");
    		// 解析元素节点
    		sb.append(ele.getName());
    		
    		// 解析属性节点
    		List<Attribute> attributes = ele.attributes();
    		for(Attribute attribute : attributes) {
    			sb.append(" ");
    			sb.append(attribute.getName());
    			sb.append("=");
    			sb.append(attribute.getValue());
    		}
    		
    		sb.append(">");
    		
    		// 解析文本节点
    		sb.append(ele.getText());
    		
    		// 递归解析元素节点
    		List<Element> elements = ele.elements();
    		for(Element element : elements) {
    			recursion(element, sb);
    		}
    		
    		sb.append("<" + ele.getName() + "/>\n");
    	}
    
    }
    

    1.2、使用DOM4j修改XML文档

        ①写出内容到xml文档

        XMLWriter writer = new XMLWriter(OutputStream out, OutputFormat format)

        writer.write(Document doc)

        上面的OutputFormat对象可以由OutputFormat类的两个静态方法来生成:

    • createPrettyPrint()    ——    生成的OutputFormat对象,使写出的XML文档整齐排列,适合开发环境使用
    • createCompactFormat()    ——    生成的OutputFormat对象,使写出的XML文档紧凑排列,适合生产环境使用

        ②生成文档或增加节点

    • Document DocumentHelper.createDocument()    ——    生成一个新的XML Document对象
    • Element Element.addElement(元素节点名)    ——    增加一个子元素节点
    • Attribute Element.addAttribute(属性名,属性值)    ——    增加一个子属性节点

        ③修改节点

    • Attribute.setValue(属性值)    ——    修改属性节点值
    • Attribute Element.addAttribute(同名属性名,属性值)    ——    修改同名的属性节点值
    • Element.setText(内容)    ——    修改文本节点内容

        ④删除节点

    • Element.detach()    ——    删除元素节点
    • Attribute.detach()    ——    删除属性节点

        示例:生成一个和前面的students.xml一样的XML文档,并写入到磁盘

    import java.io.FileOutputStream;
    import java.io.UnsupportedEncodingException;
    
    import org.dom4j.Document;
    import org.dom4j.DocumentHelper;
    import org.dom4j.Element;
    import org.dom4j.io.OutputFormat;
    import org.dom4j.io.XMLWriter;
    
    public class WriteXML {
    	public static void main(String[] args) throws Exception {
    		// 创建一个XMLWriter对象
    		OutputFormat format = OutputFormat.createPrettyPrint();
    		XMLWriter writer = new XMLWriter(new FileOutputStream("E:\\xml\\students2.xml"), format);
    		// 生成一个新的Document对象
    		Document doc = DocumentHelper.createDocument();
    		// 增加Students元素节点
    		Element students = doc.addElement("Students");
    		// 增加两个Student元素节点
    		Element student1 = students.addElement("student");
    		Element student2 = students.addElement("student");
    		// 为两个Student元素节点分别增加id属性节点
    		student1.addAttribute("id", "001");
    		student2.addAttribute("id", "002");
    		// 分别增加name, age, gender, grade元素子节点
    		student1.addElement("name").setText("张三");
    		student1.addElement("age").setText("19");
    		student1.addElement("gender").setText("男");
    		student1.addElement("grade").setText("计算机1班");
    		student2.addElement("name").setText("李四");
    		student2.addElement("age").setText("20");
    		student2.addElement("gender").setText("男");
    		student2.addElement("grade").setText("计算机2班");
    		// 将Document对象写入磁盘
    		writer.write(doc);
    		writer.close();
    	}
    }

    1.3、使用xPath技术

        使用dom4j查询比较深的层次结构的节点时,比较麻烦,因此可以使用xPath技术快速获取所需的节点对象。

        首先也需要在eclipse中导入xPath的jar包,我这里使用的是jaxen-1.1-beta-6.jar

        ①使用xPath的方法

    • List<Node>  Document.selectNodes(xpath表达式)    ——    查询多个节点对象
    • Node  Document.selectSingleNode(xpath表达式)    ——    查询一个节点对象

        ②xPath表达式语法

    • /     ——    绝对路径,表示从xml文档的根位置开始
    • //    ——    相对路径,表示不分任何层次结构的选择元素
    • *    ——    表示匹配所有元素
    • []    ——    条件,表示选择符合条件的元素
    • @    ——    属性,表示选择属性节点
    • and    ——    关系,表示条件的与关系
    • text()    ——    文本,表示选择文本内容

        示例:

    import java.io.File;
    import java.util.List;
    
    import org.dom4j.Document;
    import org.dom4j.DocumentException;
    import org.dom4j.Element;
    import org.dom4j.Node;
    import org.dom4j.io.SAXReader;
    
    public class XPathTest {
    	public static void main(String[] args) throws Exception {
    		SAXReader reader = new SAXReader();
    		Document doc = reader.read(new File("E:\\xml\\students.xml"));
    		
    		// 选择所有的student元素
    		List<Node> list = doc.selectNodes("//Student");
    		
    		// 选择文本内容是"张三"的name元素
    		Element name = (Element) doc.selectSingleNode("//name[text()='张三']");
    		
    		// 选择所有id属性节点
    		List<Node> list2 = doc.selectNodes("//@id");
    		
    		// 选择id属性为002的student元素
    		Element student = (Element) doc.selectSingleNode("//Student[@id='002']");
    		
    		// 选择根元素节点的所有子节点
    		Element root = doc.getRootElement();
    		List<Node> list3 = doc.selectNodes("/Students/*");
    	}
    }

    二、使用SAX方式解析XML文档

        SAX方式解析的原理是:在内存中加载一点,读取一点,处理一点。对内存要求比较低。

        JDK内置了SAX解析工具,存放在org.xml.sax包中。

    2.1、使用SAX解析方式查询XML文档

        核心的API类:

            1、SAXParser.parse(File f, DefaultHandler dh)方法:解析XML文件

                参数一File:表示读取的XMl文件

                参数二DefaultHandler:SAX事件处理程序,包含SAX解析的主要逻辑。开发人员需要写一个DefaultHandler的子类,然后将其对象作为参数传入parse()方法。

           2、 SAXParserFactory类,用于创建SAXParser对象,创建方式如下:

                SAXParser parse = SAXParserFactory.newInstance().newSAXParser();

           3、DefaultHandler类的主要方法:

    •     void startDocument()    ——    在读到文档开始时调用
    •     void endDocument()    ——    在读到文档结束时调用
    •     void startElement(String uri, String localName, String qName, Attributes attributes)    ——    读到开始标签时调用
    •     void endElement(String uri, String localName, String qName)    ——    读到结束标签时调用
    •     characters(char[] ch, int start int length)    ——    读到文本内容时调用

        示例:使用SAX解析方式读取上面students.xml的内容,并打印至控制台。

    import java.io.File;
    
    import javax.xml.parsers.ParserConfigurationException;
    import javax.xml.parsers.SAXParser;
    import javax.xml.parsers.SAXParserFactory;
    
    import org.xml.sax.Attributes;
    import org.xml.sax.SAXException;
    import org.xml.sax.helpers.DefaultHandler;
    
    public class SAXTest {
    	public static void main(String[] args) throws Exception {
    		SAXParser parser = SAXParserFactory.newInstance().newSAXParser();
    		parser.parse(new File("E:\\xml\\students.xml"), new MyDefaultHandler());
    	}
    }
    
    class MyDefaultHandler extends DefaultHandler{
    	@Override
    	public void startDocument() throws SAXException {
    		System.out.println("----文档开始解析-------");
    	}
    	
    	@Override
    	public void startElement(String uri, String localName, String qName, Attributes attributes) throws SAXException {
    		System.out.print("<" + qName);
    		
    		for(int i = 0; i < attributes.getLength(); i++) {
    			System.out.print(" " + attributes.getQName(i) + "=" + attributes.getValue(i));
    		}
    		System.out.print(">");
    	}
    	
    	@Override
    	public void characters(char[] ch, int start, int length) throws SAXException {
    		System.out.print(new String(ch, start, length));
    	}
    	@Override
    	public void endElement(String uri, String localName, String qName) throws SAXException {
    		System.out.print("</" + qName + ">");
    	}
    	
    	@Override
    	public void endDocument() throws SAXException {
    		System.out.println("\n----文档开始解析结束-----");
    	}
    }

     

    2.2、对比DOM解析和SAX解析

    展开全文
  • 下面小编就为大家带来一篇java读取XML文件的四种方法总结(必看篇)。小编觉得挺不错的,现在就分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • NULL 博文链接:https://suky.iteye.com/blog/621169
  • 压缩包中有一个项目(项目中包含操作xml文件的类和对应的xml文件)、一个用于操作xml文件的jar包,用于操作xml文件,并且获得list集合。
  • Java读取xml文件

    2019-02-01 14:54:53
    Java读取XML文件笔记。 最近在学习解了Spring原理,试想自己写一个简单的IOC与AOP玩玩,怎奈不熟xml格式与文件读取,只能先去学习了解咯,头疼,特此做一个XML文件读取笔记 首先是一个XML(文件名MySpring.xml) &...

    Java读取XML文件笔记。

    最近在学习解了Spring原理,试想自己写一个简单的IOC与AOP玩玩,怎奈不熟xml格式与文件读取,只能先去学习了解咯,头疼,特此做一个XML文件读取笔记

    首先是一个XML(文件名MySpring.xml)

    <beans>
      <bean id="user" class="com.xiaoli.model.User">
            <property name="name" value="小立"></property>      <!--姓名-->
            <property name="age" value="22"></property>         <!--年龄-->
            <property name="sex" value="男"></property>          <!--性别-->
        </bean>
    </beans>
    

    然后是读取XML文件的Java代码
    全部使用的Java原生API下的包

        //第一步 读取 xml文件
        //1、将xml文件转为输入流
            InputStream in=Main.class.getClassLoader().getResourceAsStream("com/xiaoli/resouorce/MySpring.xml");
            //2、创建一个DocumentBuilderFactory的对象
            DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
            //3 创建DocumentBuilder对象
            DocumentBuilder documentBuilder = dbf.newDocumentBuilder();
            //4 通过DocumentBuilder对象的parser方法加载Io流文件
            Document document = documentBuilder.parse(in);
            in.close();
            //5 获取所有bean节点的集合
            NodeList beanList = document.getElementsByTagName("bean");
    
            // 6 遍历bean标签
            for(int i=0;i<beanList.getLength();i++){
               //7 通过 item(i)方法 获取一个bean节点,beanlist的索引值从0开始
                Node node = beanList.item(i);
                //8 node 强制类型转换为Element
                if(node instanceof Element){
                    Element el=(Element)node;
                    //9 获取bean标签里面的指定元素的值;
                    String beanId = el.getAttribute("id");
                    String beanClass = el.getAttribute("class");
                    System.out.println(beanId+"      "+beanClass);
                    // 10 获取bean标签的子标签。
                    NodeList propertyList = el.getElementsByTagName("property");
    
                    //遍历子标签property
                    for(int j=0;j<propertyList.getLength();j++){
                        Node item = propertyList.item(j);
                        if(item instanceof Element){
                            Element ele=(Element)item;
                            String name = ele.getAttribute("name");
                            String value = ele.getAttribute("value");
                            System.out.println(name+"      "+value);
                        }
                    }
                }
            }
    

    最终得到结果
    在这里插入图片描述
    大功告成XML文件读取成功。

    版权声明: 本文为博主原创文章,未经博主允许不得转载 https://blog.csdn.net/qq_44614710/article/details/86741247

    展开全文
  • java读取xml文件并存入数据库

    热门讨论 2010-12-16 16:03:29
    javaxml中读入数据并存入到sqlserver2005数据库中
  • 1、java代码: 主要采用dom来进行操作 代码如下: package test; import java.io.IOException; import javax.xml.parsers.DocumentBuilder; import javax.xml.parsers.DocumentBuilderFactory; import javax.xml....
  • 下面小编就为大家带来一篇java实现利用String类的简单方法读取xml文件中某个标签中的内容。小编觉得挺不错的,现在就分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • NULL 博文链接:https://filer325.iteye.com/blog/851734
  • Java读写xml文件操作

    2020-11-22 17:03:38
    XML文件简介 XML文件介绍 XML(EXtensible Markup Language)是扩展性标记语言。由程序设计编写者自定义实现。 XML主要是用来以标记文本形式表示一组或多组数据,很多计算机语言都提供对XML文件的解析,使用XML格式...

    XML文件简介

    XML文件介绍

    • XML(EXtensible Markup Language)是扩展性标记语言。由程序设计编写者自定义实现。
    • XML主要是用来以标记文本形式表示一组或多组数据,很多计算机语言都提供对XML文件的解析,使用XML格式传递数据可以实现跨平台跨计算机编程语言
    • XML是W3C组织强烈推荐的数据交换格式标准

    XML语法规则

    • 标准声明 <?xml version="1.0" encoding="UTF-8"?>:版本号和编码方式
    • 标签封闭

      This is a paragraph

    • 这是错误的:标签大小写敏感,一边大写一边小写则为达到标签封闭
    • 至少有一个根元类:root为根元素,child为子元素
    • xml的属性值必须加引号("或’)
    • 实体引用:

    &lt:<
    &gt:>
    &amp:&
    &apos:’
    &quot:"

    • 注释符《!–注释–》(英文符号)
    • 在XML中,空格会被保留,属性与数据中有空格,则空格也是属性和数据中的一部分

    XML文档的编写

    XML元素

    • XML中的元素是用<元素名称>与</元素名称>定义在文档中的节点描述
    • 元素中可以包含其他子元素、元素属性及普通常量文本
    • 名称可以含字母、数字以及其他的字符(建议只使用字母与数字)
    • 名称不能以数字或者标点符号开始
    • 名称不能以字符xml(或者XML,Xml)开始
    • 名称不能包含空格

    XML元素属性

    • XML中属性是用来描述元素特征的,它必须有名称和值组成,之间用=符号实现赋值,属性值必须使用单引号或者双引号包围
    • 特殊情况:

    如果属性本身包含双引号,那么有必要使用单引号包围它如:name='George “Shotgun” Ziegler’不建议使用
    或者可以使用实体引用

    代码示例

    <?xml version="1.0" encoding="UTF-8"?>
    <!-- 此XML文档用来存储学生信息 -->
    <!-- 这是文档的根元素 -->
    <students>
    	<!-- 每个student元素代表一个学生对象 -->
    	<student ID="001">
    		<name>张三</name>
    		<birth>2001-1-1</birth>
    		<sex></sex>
    	</student>
    	
    	<student ID="002">
    		<name>李四</name>
    		<birth>2001-2-1</birth>
    		<sex></sex>
    	</student>
    	
    	<student ID="003">
    		<name>王五</name>
    		<birth>2001-3-1</birth>
    		<sex></sex>
    	</student>
    	
    </students>
    

    student对象的子元素起到和属性类似的作用,描述对象的特征,子元素之间的是文本,字符串常量

    XML文件的解析

    • DOM文档对象模型
    • SAX简单的XML API
    • JDOM Java文档对象类型
    • DOM4J扩展JDOM

    JDOM解析XML

    JDOM概述

    1. JDOM是由第三方提供和维护的一组标准的Java实现,用来以Java语言形式解析XML文档;因此它知识和与Java平台语言,JDOM不遵循任何DOM实现标准,它只和Java相关
    2. JDOM对XML文档实现最为简单的读写操作,JDOM将XML文档中的每个节点(node)称之为Element(元素),并提供对元素上下级元素的获取等实用方法
    3. JDOM解析XML大体分为两种操作
      1. 读取目标XML文档并解析,封装成运行时的Java对象进行处理
      2. 将运行的Java对象以XML文件方式写入硬盘存储

    JDOM读取XML文档

    流程

    1. 创建SAXBuilder用来构建加载目标XML文档
    2. 基于XML路径创建XML文件对象
    3. 使用SAXBuilder加载XML文件对象
    4. 利用JDOM相关方法解析XML文档封装为Java对象

    获取应用程序类路径

    Java程序的输出目录是bin目录,不能从src中获取文件,由于开发者文件路径和用户不同,需要通过获取类路径的方式来获得文件

    /**
    	 * 获取类路径的通用方法
    	 * @return String 类路径
    	 */
    	public static String getClassPath() {
    		/*getClassLoader.getResource()获得文件的绝对路径,getPath获取部分路径(省去file:部分)*/
    		String classPath = Tools.class.getClassLoader().getResource("").getPath().toString();
    		/*解码,修改编码格式,防止乱码*/
    		try {
    			URLDecoder.decode(classPath, "utf-8");
    		} catch (UnsupportedEncodingException e) {
    			e.printStackTrace();
    		}
    		return classPath;
    	}
    

    代码实现

    学生实体类

    import java.util.Date;
    
    /***
     * 学生实体类,存储学生信息
     * @author lenovo
     *
     */
    public class Students {
    
    	private String ID;
    	private String name;
    	private Date birth;
    	private Sex sex;
    	private enum Sex{,;
    	}
    	
    	public String getID() {
    		return ID;
    	}
    	public void setID(String ID) {
    		this.ID = ID;
    	}
    	public String getName() {
    		return name;
    	}
    	public void setName(String name) {
    		this.name = name;
    	}
    	public Date getBirth() {
    		return birth;
    	}
    	public void setBirth(Date birth) {
    		this.birth = birth;
    	}
    	public Sex getSex() {
    		return sex;
    	}
    	public void setSex(Character sex) {
    		this.sex = Sex.valueOf(sex.toString());
    	}
    }
    

    xml文档的解析功能类

    /***
     * xml文档的解析功能类
     * @author lenovo
     *
     */
    public class JDOMXMLManager {
    
    	/*创建需要使用的SAXBuilder和Document对象*/
    	private static SAXBuilder saxbuilder;//用来构建xml文件
    	private static Document document;//xml文档对象
    	
    	/**
    	 * 此方法用来创建一个SAXBuilder对象
    	 */
    	private static void newInstanceSAXBuilder() {
    		if(saxbuilder == null)
    			saxbuilder = new SAXBuilder();
    	}
    	
    	/**
    	 * 将文件的数据封装为Students对象,存储在集合List中返回
    	 * @return List封装学生对象的集合链表
    	 */
    	public static List<Students> toStudentsFromXML(String xmlFileName){
    		List<Students> stuList = new ArrayList<Students>();
    		/*1.通过方法创建SAXBuilder用来构建xml文档*/
    		newInstanceSAXBuilder();
    		/*2.基于xml文件路径创建xml文件对象*/
    		String classPath = Tools.getClassPath(); //通过工具类获取类路径
    		File xmlFile = new File(classPath+"com/study/doc/"+xmlFileName);//创建文件对象:类路径+包路径+文件名(注意包间用‘/’连接)
    		try {
    			/*3.使用SAXBuilder加载xml文件对象*/
    			document = saxbuilder.build(xmlFile);//build方法将加载file对象为document对象
    			/*4.解析xml文档*/
    			if(document!=null) {
    				/*获得根节点*/
    				Element root = document.getRootElement();
    				/*获得所有子元素*/
    				List<Element> studentList = root.getChildren();
    				/*循环遍历获取子元素存储的数据*/
    				for(Element e:studentList) {
    					Students stu = new Students();
    					/*getAttribute获取属性对象,getValue获得值,getChild获取子标签对象,getText获取标签的文本内容*/
    					stu.setID(e.getAttribute("ID").getValue());
    					stu.setName(e.getChild("name").getText());
    					stu.setSex(e.getChild("sex").getText());
    					String birth = e.getChild("birth").getText();
    					Date date = new SimpleDateFormat("yyyy-MM-dd").parse(birth);//格式化日期获取Date对象
    					stu.setBirth(date);
    					stuList.add(stu);
    				}
    			}
    		} catch (Exception e) {
    			e.printStackTrace();
    		}
    		return stuList;
    	}
    

    主要方法

    new SAXBuilder().build(file);参数为file对象,为目标xml文件的file对象建立document对象并返回
    new Document().getRootElement();返回xml文档的根元素,Element对象
    new Element().getAttribute(name);通过属性的名称,返回元素的指定属性对象
    new Element().getAttribute(name).getValue();通过属性名称,返回元素的指定属性的值
    new Element().getChild(name);通过标签的名称,返回元素的指定子元素
    new Element().getChild(name).getText();通过标签的名称,发挥元素的指定子元素的文本

    JDOM写入文档

    流程

    1. 创建XMLOutputter对象用来修改写入XML文档
    2. 基于XML路径创建XML文件对象
    3. 使用SAXBuilder加载XML文件对象
    4. 利用JDOM相关方法将修改信息写入到目标XML文件

    代码实现

    实习xml文件修改功能的方法

    	/**
    	 * 对XML文档信息的修改
    	 * @param xmlFile 需要修改的xml文档名
    	 */
    	public static void ModifyXML(String xmlFileName) {
    		/*创建字符输出流对象,用于写入目标文件*/
    		Writer out = null;
    		/*获得修改信息*/
    		Students stu = new Students();
    		stu = input();
    		/*创建SAXBuilder对象*/
    		newInstanceSAXBuilder();
    		/*1.创建XMLOutputter用来修改写入XML文档*/
    		newInstanceXMLOutputter();
    		/*2.基于XML路径创建XML文件对象*/
    		String classPath = Tools.getClassPath();//获取类路径
    		File xmlFile = new File(classPath+"com/study/doc/"+xmlFileName);
    		try {
    			/*3.使用SAXBuilder加载XML文件对象*/
    			document = saxbuilder.build(xmlFile);
    			/*4.将修改信息写入目标文件*/
    			/*获得根节点*/
    			Element root = document.getRootElement();
    			/*获得所有子元素*/
    			List<Element> children = new ArrayList<Element>();
    			children = root.getChildren();
    			/*将修改信息写入目标元素*/
    			for(Element e:children) {
    				if(stu.getID().equals(e.getAttribute("ID").getValue())) {//通过标识符ID锁定目标元素
    					Element name = e.getChild("name");
    					name.setText(stu.getName());
    					Element birth = e.getChild("birth");
    					birth.setText(new SimpleDateFormat("yyyy-MM-dd").format(stu.getBirth()));
    					Element sex = e.getChild("sex");
    					sex.setText(stu.getSex());
    				}
    			}
    			/*将修改完的元素写入目标文件中*/
    			out = new FileWriter(xmlFile);//写入目标文件的输出流
    			xmlOutput.output(document, out);//将document对象放入对应输出流来写入目标文件
    		} catch (Exception e) {
    			e.printStackTrace();
    		} finally {
    			/*关闭输出流*/
    			if(out!=null) {
    				try {
    					out.close();
    				} catch (IOException e) {
    					e.printStackTrace();
    				}
    				out = null;
    			}
    		}
    	}
    

    用于输入修改信息的方法

    	/**
    	 * 此方法用来从控制台接收需要修改的数据
    	 * 以ID作为唯一标识符,来区分不同的元素
    	 * @return 返回修改后的数据封装的学生对象
    	 */
    	private static Students input() {
    		Students stu = new Students();
    		Scanner in = new Scanner(System.in);
    		System.out.println("请输入需要修改的学生ID:");
    		stu.setID(in.next());
    		System.out.println("请输入学生姓名:");
    		stu.setName(in.next());
    		System.out.println("请输入学生生日:");
    		String birth = in.next();
    		Date sdf = null;
    		try {
    			sdf = new SimpleDateFormat("yyyy-MM-dd").parse(birth);
    		} catch (ParseException e) {
    			e.printStackTrace();
    		}
    		stu.setBirth(sdf);
    		System.out.println("请输入学生性别:");
    		stu.setSex(in.next());
    		return stu;
    	}
    

    主要方法

    new XMLOutputter().output(doctype,outStream);此方法将文档对象写入目标文件,参数doctype为文件对象,outStream为将写入的目标文件的输出流

    DOM4J解析XML文件

    DOM4J概述

    1. DOM4J是由第三方提供扩展子JDOMAPI的一组解析XML文件的java实现,它只和Java相关
    2. DOM4J对XML文档实现与JDOM类似,JDOM将XML文档中的每个节点(node)称之为Element(元素),并提供对元素上下级元素的获取等实用方法
    3. DOM4J解析XML大体分为两步操作:
      1. 获取目标XML文档并解析,封装成运行时的Java对象进行处理
      2. 将运行时Java对象以XML文件方式写入硬盘存储

    DOM4J写入XML文档

    流程

    1. 创建DocumentFactory用来创建Document对象
    2. 使用DOM4J实现对Document对象操作
    3. 创建XMLWriter用来将Document对象写入XML文件
    4. 关闭相关文件流

    代码实现(创建XML文档)

    员工实体类

    /***
     * 员工实体类
     */
    public class Employee {
    
    	private String code;
    	private String name;
    	private String sex;
    	private Date birth;
    	
    	public String getCode() {
    		return code;
    	}
    	public void setCode(String code) {
    		this.code = code;
    	}
    	public String getName() {
    		return name;
    	}
    	public void setName(String name) {
    		this.name = name;
    	}
    	public String getSex() {
    		return sex;
    	}
    	public void setSex(String sex) {
    		this.sex = sex;
    	}
    	public Date getBirth() {
    		return birth;
    	}
    	public void setBirth(Date birth) {
    		this.birth = birth;
    	}
    	
    }
    
    

    XML文档解析类

    /***
     1. XML文档解析功能类DOM4J
     2.  */
    public class DOM4JXMLManager {
    
    	/*创建用于创建Document对象的DocumentFactory*/
    	private final DocumentFactory docFactory = DocumentFactory.getInstance();
    	/*声明文件输出流*/
    	Writer writer = null;
    	/*声明用于写入XML文档的XMLWriter*/
    	XMLWriter xmlWriter = null;
    	/*声明进行XML文档操作的Document对象*/
    	Document document = null;
    	
    	/**
    	 * 录入员工信息的方法
    	 * @return 员工对象封装的集合
    	 */
    	public List<Employee> input(){
    		Scanner in = new Scanner(System.in);
    		List<Employee> empList = new ArrayList<Employee>();
    		while(true) {
    			Employee emp = new Employee();
    			System.out.println("请输入员工编号:");
    			emp.setCode(in.next());
    			System.out.println("请输入员工姓名:");
    			emp.setName(in.next());
    			System.out.println("请输入员工性别:");
    			emp.setSex(in.next());
    			System.out.println("请输入员工出生年份:");
    			int year = in.nextInt();
    			System.out.println("请输入员工出生月份:");
    			int month = in.nextInt();
    			System.out.println("请输入员工出生日期:");
    			int date = in.nextInt();
    			emp.setBirth(Tools.toDate(year, month, date));
    			empList.add(emp);
    			System.out.println("继续录入请输入1,停止录入输入其他数字:");
    			if(in.nextInt()!=1)
    				break;
    		}
    		return empList;
    	}
    	
    	/**
    	 * 创建并写入XML文档的方法
    	 * @param empList 需要写入的Employee数据的集合
    	 * @param fileName 创建的XML文档名称
    	 */
    	public void createEmployeeXML(List<Employee> empList,String fileName) {
    		/*1.使用DocumentFactory创建Document对象*/
    		Document document = docFactory.createDocument("utf-8");//设置编码格式为utf8
    		/*2.利用DocumentFactory对象与Document对象创建XML文档根元素*/
    		Element rootEle = docFactory.createElement("employees");//创建元素rootEle
    		document.setRootElement(rootEle);//将rootELe设为根元素
    		/*3.根据数据长度循环创建子元素*/
    		if(!empList.isEmpty()&&empList!=null) {
    			for(Employee emp:empList) {
    				/*一级子元素*/
    				Element empEle = docFactory.createElement("employee");
    				/*二级子元素*/
    				Element codeEle = docFactory.createElement("code");
    				codeEle.setText(emp.getCode());
    				Element nameEle = docFactory.createElement("name");
    				nameEle.setText(emp.getName());
    				Element sexEle = docFactory.createElement("sex");
    				sexEle.setText(emp.getSex());
    				Element birthEle = docFactory.createElement("birth");
    				birthEle.setText(new SimpleDateFormat("yyyy/MM/dd").format(emp.getBirth()));
    				/*将二级子元素添加到父元素下*/
    				empEle.add(codeEle);
    				empEle.add(nameEle);
    				empEle.add(sexEle);
    				empEle.add(birthEle);
    				/*将一级子元素添加到根元素下*/
    				rootEle.add(empEle);
    			}
    		}
    		/*4.XML文档写入操作*/
    		String classPath = Tools.getClassPath();//获取类路径
    		File xmlFile = new File(classPath+"com/study/doc/"+fileName);//创建文件对象
    		try {
    			writer = new FileWriter(xmlFile);//实例化目标文件输出流
    			/*设置格式与编码*/
    			OutputFormat format = OutputFormat.createPrettyPrint();
    			format.setEncoding("UTF-8");
    			xmlWriter = new XMLWriter(writer,format);//利用目标文件的输出流实例化XMLWriter
    			xmlWriter.write(document);//将xml文档对象写入目标文件
    		} catch (IOException e) {
    			e.printStackTrace();
    		} finally {
    			/*5.关闭相关文件流*/
    			try {
    				writer.close();
    			} catch (IOException e) {
    				e.printStackTrace();
    			}
    		}
    	}
    }
    

    主要方法

    new DocumentFactory.createElement(elementName);创建元素,参数为元素名
    new Document.setRootElement(root);将参数root指向的元素设置为根元素
    new Element().add(element);将参数element指向的元素设置为子元素

    DOM4J读取xml文档

    流程

    1. 基于xml文件路径创建File对象
    2. 创建SAXReader来加载xml文件为Document对象
    3. 利用DOM4J相关方法来解析xml文档
    4. 将数据封装为Java对象

    代码实现

    /**
    	 * 读取XML文档的方法DOM4J
    	 * @param fileName
    	 * @return 读取到的数据封装的集合
    	 */
    	public List<Employee> toEmployeeFromXML(String fileName){
    		List<Employee> empList = new ArrayList<Employee>();
    		/*1.基于xml文档路径创建File对象*/
    		String classPath = Tools.getClassPath();
    		File xmlFile = new File(classPath+"com/study/doc/"+fileName);
    		/*2.创建SAXReader*/
    		SAXReader saxReader = new SAXReader();
    		Reader reader = null;
    		try {
    			reader = new FileReader(xmlFile);
    			/*3.创建Document*/
    			document = saxReader.read(xmlFile);
    			/*3.解析xml文档*/
    			if(document!=null) {
    				Element root = document.getRootElement();
    				List<Element> employeeEle = root.elements("employee");
    				/*4.封装数据为Java对像*/
    				for(Element e:employeeEle) {
    					Employee emp = new Employee();
    					emp.setCode(e.elementText("code"));
    					emp.setName(e.elementText("name"));
    					emp.setBirth(new SimpleDateFormat("yyyy/MM/dd").parse(e.elementText("birth")));
    					emp.setSex(e.elementText("sex"));
    					empList.add(emp);
    				}
    			}
    		} catch (Exception e) {
    			e.printStackTrace();
    		} finally {
    			/*5.关闭文件流*/
    			try {
    				reader.close();
    			} catch (IOException e) {
    				e.printStackTrace();
    			}
    		}
    		return empList;
    	}
    
    展开全文
  • java读取xml文件的四种方法
  • Java读取xml文件的四种方法.doc
  • 通过Java读取xml文件内容

    千次阅读 2020-07-21 10:55:08
    通过Java读取xml文件内容 读取XML中的内容就需要对XML进行解析,目前对XML进行解析的方法分为四种: 下面解析的方法是DOM4J,需要下载jar包dom4j:https://dom4j.github.io/ package com.zyb.xml; import ...

    通过Java读取xml文件内容

    读取XML中的内容就需要对XML进行解析,目前对XML进行解析的方法分为四种:

    下面解析的方法是DOM4J,需要下载jar包dom4j:https://dom4j.github.io/

    package com.zyb.xml;
    
    import java.io.File;
    import java.util.Iterator;
    
    import org.dom4j.Attribute;
    import org.dom4j.Document;
    import org.dom4j.DocumentException;
    import org.dom4j.Element;
    import org.dom4j.io.SAXReader;
    
    public class testXml {
    
        public static void main(String[] args) throws Exception {
            // TODO Auto-generated method stub
            //1.创建SAXReader对象用于读取xml文件
            SAXReader reader = new SAXReader();
            //2.读取xml文件,获得Document对象
            Document doc = reader.read(new File("src/book.xml"));
            //3.获取根元素
            Element root = doc.getRootElement();
            //4.获取根元素下的所有子元素(通过迭代器)
            Iterator<Element> it = root.elementIterator();
            while(it.hasNext()){
                
                Element e = it.next();
                //获取id属性(attribute是属性的意思)
                Attribute id = e.attribute("id");
                System.out.println(id.getName()+" = "+id.getStringValue());
                Element author = e.element("author");
                Element money = e.element("price");
                Element time = e.element("time");
                System.out.println(author.getName()+" = "+author.getStringValue());
                System.out.println(money.getName()+" = "+money.getData());
                System.out.println(time.getName()+" = "+time.getText());
                System.out.println("---------------------------------------------------------------");
            }
        }
    
    }
    

    运行结果:

     

      

    不一样的烟火

    展开全文
  • java 读取XML

    2019-03-06 01:09:49
    java xml操作 博文链接:https://11lingxian.iteye.com/blog/123962
  • 主要问题:xml文件配置编码格式与文件本身的编码格式不统一 检查你的xml中 encoding= “UTF-8” 还是 其他格式 一般的在代码中设置编码格式UTF-8 和 GB2312 不完全是不通用的,如果不通,换成对应的就可以 ...
  • java读取xml文件的四种方法: 第一种 DOM 实现方法 第二种 DOM4J实现方法 第三种 JDOM实现方法 第四种SAX实现方法
  • XML读取 InputStream DocumentBuilderFactory Element Node 直接上源码 <?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans"> <bean name="Hello...
  • java读取xml文件demo

    2016-05-08 14:49:41
    java实现的一个读取本地xml文件的例子,进入正题: 需要的包jdom2-2.0.6.jar:下载地址,http://mvnrepository.com/artifact/org.jdom/jdom2 此例子比较简单
  • 主要介绍了Java开发中读取XML与properties配置文件的方法,非常不错,具有参考借鉴价值,需要的朋友可以参考下

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 781,960
精华内容 312,784
关键字:

java操作xml文件

java 订阅