Java解析XML文件
java_Dom4j解析XML详解
学习:Dom4j1、DOM4J简介DOM4J是 出品的一个开源XML 解析包。
DOM4J应用于Java 平台,采用了Java 集合框架并完全支持DOM,SAX 和JAXP。
DOM4J 使用起来非常简单。
只要你了解基本的XML-DOM 模型,就能使用。
Dom:把整个文档作为一个对象。
DOM4J 最大的特色是使用大量的接口。
它的主要接口都在org.dom4j里面定义:接口之间的继承关系如下:interface ng.Cloneableinterface org.dom4j.Nodeinterface org.dom4j.Attributeinterface org.dom4j.Branchinterface org.dom4j.Documentinterface org.dom4j.Elementinterface org.dom4j.CharacterDatainterface org.dom4j.CDATAinterface mentinterface org.dom4j.Textinterface org.dom4j.DocumentTypeinterface org.dom4j.Entityinterface org.dom4j.ProcessingInstruction2、XML文档操作12.1、读取XML文档:读写XML文档主要依赖于org.dom4j.io包,有DOMReader和SAXReader两种方式。
因为利用了相同的接口,它们的调用方式是一样的。
public static Docum ent load(String filenam e) {Document docum ent =null;try {SAXReader saxReader = new SAXReader();docum ent =saxReader.read(new File(filename)); //读取XML文件,获得docum ent 对象} catch (Exception ex) {ex.printStackTrace();}return docum ent;}或public static Docum ent load(URL url) {Document docum ent =null;try {SAXReader saxReader = new SAXReader();docum ent =saxReader.read(url); //读取XML文件,获得docum ent对象} catch (Exception ex) {ex.printStackTrace();}return docum ent;}//读取指定的xml文件之后返回一个Document对象,这个对象代表了整个XML文档,用于各种Do m运算。
Java解析XML的四种方式
Java解析XML的四种方式在平时工作中,难免会遇到把XML 作为数据存储格式。
面对目前种类繁多的解决方案,哪个最适合我们呢?在这篇文章中,对这四种主流方案做一个不完全评测,仅仅针对遍历XML 这块来测试,因为遍历XML 是工作中使用最多的。
预备XML 文件格式如下:<?xml version="1.0" encoding="GB2312"?><RESULT><V ALUE><NO>A1234</NO><ADDR>四川省XX县XX镇XX路X段XX号</ADDR></V ALUE><V ALUE><NO>B1234</NO><ADDR>四川省XX市XX乡XX村XX组</ADDR></V ALUE></RESULT>测试首先出场的是DOM(JAXP Crimson 解析器)DOM 是用与平台和语言无关的方式表示XML 文档的官方W3C 标准。
DOM 是以层次结构组织的节点或信息片断的集合。
这个层次结构允许开发人员在树中寻找特定信息。
分析该结构通常需要加载整个文档和构造层次结构,然后才能做任何工作。
由于它是基于信息层次的,因而DOM 被认为是基于树或基于对象的。
DOM 以及广义的基于树的处理具有几个优点。
首先,由于树在内存中是持久的,因此可以修改它以便应用程序能对数据和结构作出更改。
它还可以在任何时候在树中上下导航,而不是像SAX 那样是一次性的处理。
DOM 使用起来也要简单得多。
另一方面,对于特别大的文档,解析和加载整个文档可能很慢且很耗资源,因此使用其他手段来处理这样的数据会更好。
这些基于事件的模型,比如SAX。
Bean文件:package com.test;import java.io.*;import java.util.*;import org.w3c.dom.*;import javax.xml.parsers.*;public class MyXMLReader{public static void main(String arge[]){long lasting =System.currentTimeMillis();try{File f=new File("data_10k.xml");DocumentBuilderFactory factory=DocumentBuilderFactory.newInstance();DocumentBuilder builder=factory.newDocumentBuilder();Document doc = builder.parse(f);NodeList nl = doc.getElementsByTagName("VALUE");for (int i=0;i<nl.getLength();i++){System.out.print("车牌号码:" +doc.getElementsByTagName("NO").item(i).getFirstChild().getNodeValue());System.out.println(" 车主地址:" +doc.getElementsByTagName("ADDR").item(i).getFirstChild().getNodeValue());}}catch(Exception e){e.printStackTrace();}System.out.println("运行时间:"+(System.currentTimeMillis() - lasting)+" 毫秒");}}10k消耗时间:265 203 219 172100k消耗时间:9172 9016 8891 90001000k消耗时间:691719 675407 708375 73965610000k消耗时间:OutOfMemoryError接着是SAX这种处理的优点非常类似于流媒体的优点。
JavaXML解析的四种方法(连载)
JavaXML解析的四种⽅法(连载)1. xml简介 XML:指可扩展标记语⾔, Extensible Markup Language;类似HTML。
XML的设计宗旨是传输数据,⽽⾮显⽰数据。
⼀个xml⽂档实例:1 <?xml version="1.0" encoding="UTF-8"?>2 <company name="Tencent" address="深圳市南⼭区">3 <department deptNo="001" name="development">4 <employee id="devHead" position="minister">许刚</employee>5 <employee position="developer">⼯程师A</employee>6 </department>7 <department deptNo="002" name="education">8 <employee position="minister" telephone="1234567">申林</employee>9 <employee position="trainee">实习⽣A</employee>10 </department>11 </company> 第⼀⾏是 XML 声明。
它定义 XML 的版本 (1.0) 和所使⽤的编码. 下⼀⾏描述⽂档的根元素:<company>开始,该根元素具有2个属性“name”,"address"。
java xmlparser用法
文章标题:深入探讨Java XML解析器的使用方法与技巧一、引言:解析XML在Java中的重要性XML作为一种可扩展的标记语言,被广泛应用于数据交换和存储的场景中。
在Java开发中,对XML的解析是一项非常常见的任务,它涉及到从XML文档中提取数据、修改数据以及创建新的XML文档等方面。
对于Java开发者来说,掌握XML解析器的使用方法与技巧是非常重要的。
二、Java中常见的XML解析器介绍在Java中,常见的XML解析器主要包括DOM解析器、SAX解析器和StAX解析器。
下面将针对这三种解析器进行详细介绍,并分别分析它们的优缺点和适用场景。
1. DOM解析器DOM(Document Object Model)解析器将整个XML文档解析成内存中的一个树形结构,因此适合于对XML文档进行随机访问和修改。
但是,由于DOM解析器需要将整个文档加载到内存中,对于大型XML文档来说,可能会占用过多的内存,因此不适合对大型XML文档进行解析。
2. SAX解析器SAX(Simple API for XML)解析器是一种基于事件驱动的解析器,它逐行解析XML文档,只在遇到标签开始、标签结束和文本内容时触发相应的事件,从而大大减小了内存开销。
SAX解析器适合用于对大型XML文档进行顺序读取和简单处理。
3. StAX解析器StAX(Streaming API for XML)解析器是一种基于迭代器的解析器,它允许开发者以类似流的方式读写XML文档,同时也支持部分随机访问功能。
由于StAX解析器结合了DOM和SAX解析器的优点,因此在某些场景下可以取得很好的效果。
三、Java中使用XML解析器的常见场景和技巧1. 选择合适的解析器在实际开发中,选择合适的解析器非常重要。
如果需要对XML文档进行较为复杂的处理,并且内存资源充足,那么可以选择DOM解析器;如果需要对大型XML文档进行顺序读取和简单处理,那么可以选择SAX解析器;如果需要兼顾随机访问和内存占用的平衡,那么可以选择StAX解析器。
Java动态生成和解析xml文件步骤详解
Java动态⽣成和解析xml⽂件步骤详解⾸先声明,这个地⽅是利⽤dom4j进⾏解析和⽣成,需要⽤到dom4j的jar包,所以⾸先需要我们获取jar包:<dependency><groupId>dom4j</groupId><artifactId>dom4j</artifactId><version>1.6.1</version></dependency>⽣成xml⽂件代码案列:package day12;import java.io.FileOutputStream;import java.util.ArrayList;import java.util.List;import org.dom4j.Document;import org.dom4j.DocumentHelper;import org.dom4j.Element;import org.dom4j.io.OutputFormat;import org.dom4j.io.XMLWriter;/*** 写出XML⽂档*/public class WriteXmlDemo {public static void main(String[] args) {List<Emp> empList = new ArrayList<Emp>();empList.add(new Emp(1,"张三",22,"男",3000));empList.add(new Emp(2,"李四",23,"⼥",4000));empList.add(new Emp(3,"王五",24,"男",5000));empList.add(new Emp(4,"赵六",25,"⼥",6000));empList.add(new Emp(5,"钱七",26,"男",7000));empList.add(new Emp(6,"传奇",21,"男",8000));/** 写出XML⽂档的⼤致步骤* 1.创建空⽩⽂档对象Document* 2.向该⽂档中添加根元素* 3.按照规定的XML⽂档结构从根元素开始,逐级添加⼦元素,已完成该结构* 4.创建XMLWriter* 5.将Document对象写出成XML⽂档* 6.将XMLWriter关闭*///1Document doc = DocumentHelper.createDocument();/** 2.Element addElement(String name)* Document提供的该⽅法是⽤来向当前⽂档中添加给定名字的根元素。
java使用document解析xml文件
java使⽤document解析xml⽂件准备⼯作:1创建java⼯程2创建xml⽂档。
完成后看下⾯代码:import org.w3c.dom.*;import javax.xml.parsers.DocumentBuilder;import javax.xml.parsers.DocumentBuilderFactory;public class Main {public static void main(String[] args) throws Exception {//创建⼀个⽂档解析器⼯⼚DocumentBuilderFactory fac= DocumentBuilderFactory.newInstance();//⽤上⾯的⼯⼚创建⼀个⽂档解析器DocumentBuilder builder=fac.newDocumentBuilder();//⽤上⾯的⽂档解析器解析⼀个⽂件放到document对象⾥Document doc=builder.parse("src/server.xml");//获取⽂档中节点名称为Listener的所有节点,并返回⼀个节点集合NodeList listenerList=doc.getElementsByTagName("Listener");System.out.println("⼀共有"+listenerList.getLength()+"个节点");//遍历整个集合(把所有标签名为Listener的节点⼀个⼀个拿出来for (int i=0;i<listenerList.getLength();i++){System.out.println("===========这是第"+(i+1)+"个listener节点的开始:===========");//把集合⾥的每⼀个listener节点分别拿出来Node node=listenerList.item(i);//再把上⼀个节点中的所有属性拿出来NamedNodeMap nodeMap= node.getAttributes();System.out.println("第"+(i+1)+"个节点⼀共有"+nodeMap.getLength()+"个属性");//遍历所有属性for(int j=0;j<nodeMap.getLength();j++){Node node1=nodeMap.item(j);System.out.println("第"+(j+1)+"个属性的名称是"+node1.getNodeName());System.out.println("第"+(j+1)+"个属性的值是"+node1.getNodeValue());}//获取节点的所有⼦节点,注意会把所有换⾏符也解析为⼦节点NodeList childNode=node.getChildNodes();//遍历所有⼦节点for(int k=0;k<childNode.getLength();k++){if(childNode.item(k).getNodeType()==Node.ELEMENT_NODE){//这个过滤条件是只将标签节点保留(换⾏符的节点就删去)}System.out.println("===========这是第"+(i+1)+"个节点的结束:===========");}}}为了⽅便记忆,在这⾥拆解⼀下。
在Java中使用xpath对xml解析
在Java中使⽤xpath对xml解析个⼈博客地址:xpath是⼀门在xml⽂档中查找信息的语⾔。
xpath⽤于在XML⽂档中通过元素和属性进⾏导航。
它的返回值可能是节点,节点集合,⽂本,以及节点和⽂本的混合等。
在学习本⽂档之前应该对XML的节点,元素,属性,⽂本,处理指令,注释,根节点,命名空间以及节点关系有⼀定的了解以及对xpath也有了解。
XML学习地址:xpath基本语法学习地址:xpath官⽅⽂档:https:///cvc4tEIGy5EvS访问密码 9d16本⽂主要介绍:Java中使⽤xpath操作对xml操作。
1)⾸先在dom4j中如何使⽤xpath技术导⼊xPath⽀持的jar包。
jaxen-1.1-beta-6.jar(⾸先要先导⼊dom4j包,dom4j下载地址:/dom4j-1.6.1/)。
导包之后如图所⽰:如果不知道怎样导包请参考我以前的⼀篇博客:2)在Java中使⽤xpath⽅法,主要有两点:List<Node> selectNodes("xpath表达式"); 查询多个节点对象Node selectSingleNode("xpath表达式"); 查询⼀个节点对象下⾯就⽤实例说明使⽤⽅法。
⼀、selectNodes使⽤⽅法:1package com.vastsum.demo;23import java.io.File;4import java.io.FileOutputStream;5import java.util.List;67import org.dom4j.Document;8import org.dom4j.Element;9import org.dom4j.Node;10import org.dom4j.io.OutputFormat;11import org.dom4j.io.SAXReader;12import org.dom4j.io.XMLWriter;1314/**15 *16 * @author shutu00817 *selectNode的使⽤⽅法18*/19public class xpathDemo {2021public static void main(String[] args) throws Exception {2223 Document doc = new SAXReader().read(new File("./src/contact.xml"));2425/**26 * @param xpath 表⽰xpath语法变量27*/28 String xpath="";2930/**31 * 1. / 绝对路径表⽰从xml的根位置开始或⼦元素(⼀个层次结构)32*/33 xpath = "/contactList";34 xpath = "/contactList/contact";3536/**37 * 2. // 相对路径表⽰不分任何层次结构的选择元素。
java 会计档案xml解析
java 会计档案xml解析在当今数字化时代,会计领域的信息处理变得越来越重要。
随着企业数量的增长和财务数据的复杂性,需要一种高效、可靠的方式来处理会计档案。
XML(可扩展标记语言)作为一种常用的数据交换格式,被广泛应用于会计领域。
Java作为一种强大而灵活的编程语言,提供了许多工具和库来解析和处理XML文件。
在会计档案XML解析中,Java的优势得到了充分的发挥。
下面将介绍一些主要的Java XML解析库和技术,以及它们在会计档案处理中的应用。
1. DOM(文档对象模型)解析DOM解析器将整个XML文档加载到内存中,并构建一个树形结构,以便于对文档进行操作。
在会计档案XML解析中,DOM解析器可以方便地遍历XML文档的节点,提取和修改数据。
然而,由于DOM解析器将整个文档加载到内存中,对于大型XML文件来说,内存消耗较大。
2. SAX(简单API for XML)解析SAX解析器以事件驱动的方式逐行读取XML文档,并触发相应的事件。
在会计档案XML解析中,SAX解析器可以高效地处理大型XML文件,因为它不需要将整个文档加载到内存中。
通过实现SAX 解析器的回调函数,可以在遍历过程中处理和提取数据。
3. JAXB(Java体系结构的XML绑定)解析JAXB是Java提供的一种用于将XML文档与Java对象之间进行转换的技术。
在会计档案XML解析中,可以使用JAXB将XML文档映射到Java对象上,从而方便地进行数据操作和处理。
JAXB提供了注解和配置文件来定义XML文档和Java对象之间的映射关系。
除了上述的XML解析库和技术,还有其他一些Java工具和库,如JDOM、Xerces和StAX等,也可以用于会计档案XML解析。
根据具体的需求和项目要求,可以选择合适的解析方式。
在实际应用中,会计档案XML解析的过程可能涉及到数据验证、数据转换、数据存储等多个环节。
因此,除了XML解析技术外,还需要结合其他相关的Java技术和数据库技术来完成整个处理流程。
org.w3c.dom(javadom)解析XML文档
org.w3c.dom(javadom)解析XML⽂档位于org.w3c.dom操作XML会⽐较简单,就是将XML看做是⼀颗树,DOM就是对这颗树的⼀个数据结构的描述,但对⼤型XML⽂件效果可能会不理想⾸先来了解点Java DOM 的 API:1.解析器⼯⼚类:DocumentBuilderFactory创建的⽅法:DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();2.解析器:DocumentBuilder创建⽅法:通过解析器⼯⼚类来获得 DocumentBuilder db = dbf.newDocumentBuilder();3.⽂档树模型Document创建⽅法:a.通过xml⽂档 Document doc = db.parse("bean.xml"); b.将需要解析的xml⽂档转化为输⼊流 InputStream is = new FileInputStream("bean.xml");Document doc = db.parse(is);Document对象代表了⼀个XML⽂档的模型树,所有的其他Node都以⼀定的顺序包含在Document对象之内,排列成⼀个树状结构,以后对XML⽂档的所有操作都与解析器⽆关,直接在这个Document对象上进⾏操作即可;包含的⽅法:4.节点列表类NodeListNodeList代表了⼀个包含⼀个或者多个Node的列表,根据操作可以将其简化的看做为数组5.节点类NodeNode对象是DOM中最基本的对象,代表了⽂档树中的抽象节点。
但在实际使⽤中很少会直接使⽤Node对象,⽽是使⽤Node对象的⼦对象Element,Attr,Text等6.元素类Element是Node类最主要的⼦对象,在元素中可以包含属性,因⽽Element中有存取其属性的⽅法7.属性类Attr代表某个元素的属性,虽然Attr继承⾃Node接⼝,但因为Attr是包含在Element中的,但并不能将其看做是Element的⼦对象,因为Attr并不是DOM树的⼀部分基本的知识就到此结束,更加具体的⼤家可以参阅JDK API⽂档实战:1.使⽤DOM来遍历XML⽂档中的全部内容并且插⼊元素:school.xml⽂档:<?xml version = "1.0" encoding = "utf-8"?><School><Student><Name>沈浪</Name><Num>1006010022</Num><Classes>信管2</Classes><Address>浙江杭州3</Address><Tel>123456</Tel></Student><Student><Name>沈1</Name><Num>1006010033</Num><Classes>信管1</Classes><Address>浙江杭州4</Address><Tel>234567</Tel></Student><Student><Name>沈2</Name><Num>1006010044</Num><Classes>⽣⼯2</Classes><Address>浙江杭州1</Address><Tel>345678</Tel></Student><Student><Name>沈3</Name><Num>1006010055</Num><Classes>电⼦2</Classes><Address>浙江杭州2</Address><Tel>456789</Tel></Student></School>DomDemo.java1 package xidian.sl.dom;2import java.io.FileOutputStream;34import javax.xml.parsers.DocumentBuilder;5import javax.xml.parsers.DocumentBuilderFactory;67import org.apache.crimson.tree.XmlDocument;8import org.w3c.dom.Document;9import org.w3c.dom.Element;10import org.w3c.dom.NodeList;111213public class DomDemo {14/**15 * 遍历xml⽂档16 * */17public static void queryXml(){18try{19//得到DOM解析器的⼯⼚实例20 DocumentBuilderFactory dbFactory = DocumentBuilderFactory.newInstance();21//从DOM⼯⼚中获得DOM解析器22 DocumentBuilder dbBuilder = dbFactory.newDocumentBuilder();23//把要解析的xml⽂档读⼊DOM解析器24 Document doc = dbBuilder.parse("src/xidian/sl/dom/school.xml");25 System.out.println("处理该⽂档的DomImplementation对象 = "+ doc.getImplementation());26//得到⽂档名称为Student的元素的节点列表27 NodeList nList = doc.getElementsByTagName("Student");28//遍历该集合,显⽰结合中的元素及其⼦元素的名字29for(int i = 0; i< nList.getLength() ; i ++){30 Element node = (Element)nList.item(i);31 System.out.println("Name: "+ node.getElementsByTagName("Name").item(0).getFirstChild().getNodeValue());32 System.out.println("Num: "+ node.getElementsByTagName("Num").item(0).getFirstChild().getNodeValue());33 System.out.println("Classes: "+ node.getElementsByTagName("Classes").item(0).getFirstChild().getNodeValue());34 System.out.println("Address: "+ node.getElementsByTagName("Address").item(0).getFirstChild().getNodeValue());35 System.out.println("Tel: "+ node.getElementsByTagName("Tel").item(0).getFirstChild().getNodeValue());36 }3738 }catch (Exception e) {39// TODO: handle exception40 e.printStackTrace();41 }42 }43/**44 * 向已存在的xml⽂件中插⼊元素45 * */46public static void insertXml(){47 Element school = null;48 Element student = null;49 Element name = null;50 Element num = null;51 Element classes = null;52 Element address = null;53 Element tel = null;54try{55//得到DOM解析器的⼯⼚实例56 DocumentBuilderFactory dbFactory = DocumentBuilderFactory.newInstance();57//从DOM⼯⼚中获得DOM解析器58 DocumentBuilder dbBuilder = dbFactory.newDocumentBuilder();59//把要解析的xml⽂档读⼊DOM解析器60 Document doc = dbBuilder.parse("src/xidian/sl/dom/school.xml");61//得到⽂档名称为Student的元素的节点列表62 NodeList nList = doc.getElementsByTagName("School");63 school = (Element)nList.item(0);64//创建名称为Student的元素65 student = doc.createElement("Student");66//设置元素Student的属性值为23167 student.setAttribute("examId", "23");68//创建名称为Name的元素69 name = doc.createElement("Name");70//创建名称为⾹⾹的⽂本节点并作为⼦节点添加到name元素中71 name.appendChild(doc.createTextNode("⾹⾹"));72//将name⼦元素添加到student中73 student.appendChild(name);74/**75 * 下⾯的元素依次加⼊即可76 * */77 num = doc.createElement("Num");78 num.appendChild(doc.createTextNode("1006010066"));79 student.appendChild(num);8081 classes = doc.createElement("Classes");82 classes.appendChild(doc.createTextNode("眼视光5"));83 student.appendChild(classes);8485 address = doc.createElement("Address");86 address.appendChild(doc.createTextNode("浙江温州"));87 student.appendChild(address);8889 tel = doc.createElement("Tel");90 tel.appendChild(doc.createTextNode("123890"));91 student.appendChild(tel);9293//将student作为⼦元素添加到树的根节点school94 school.appendChild(student);95//将内存中的⽂档通过⽂件流⽣成insertSchool.xml,XmlDocument位于crison.jar下96 ((XmlDocument)doc).write(new FileOutputStream("src/xidian/sl/dom/insertSchool.xml"));97 System.out.println("成功");98 }catch (Exception e) {99// TODO: handle exception100 e.printStackTrace();101 }102 }103public static void main(String[] args){104//读取105 DomDemo.queryXml();106//插⼊107 DomDemo.insertXml();108 }109 }110运⾏后结果:然后到⽬录下查看⽣成的xml⽂件:打开查看内容:上⾯添加元素后输出的⽂件与之前的⽂件不是同⼀个⽂件,如果需要输出到原⽂件中,那么只要将路径改为原⽂间路径即可:src/xidian/sl/dom/school.xml2.创建XML过程与插⼊过程相似,就是Document需要创建package xidian.sl.dom;import java.io.FileOutputStream;import javax.xml.parsers.DocumentBuilder;import javax.xml.parsers.DocumentBuilderFactory;import org.apache.crimson.tree.XmlDocument;import org.w3c.dom.Document;import org.w3c.dom.Element;public class CreateNewDom {/*** 创建xml⽂档* */public static void createDom(){Document doc;Element school,student;Element name = null;Element num = null;Element classes = null;Element address = null;Element tel = null;try{//得到DOM解析器的⼯⼚实例DocumentBuilderFactory dbFactory = DocumentBuilderFactory.newInstance();//从DOM⼯⼚中获得DOM解析器DocumentBuilder dbBuilder = dbFactory.newDocumentBuilder();//创建⽂档树模型对象doc = dbBuilder.newDocument();if(doc != null){//创建school元素school = doc.createElement("School");//创建student元素student = doc.createElement("Student");//设置元素Student的属性值为231student.setAttribute("examId", "23");//创建名称为Name的元素name = doc.createElement("Name");//创建名称为⾹⾹的⽂本节点并作为⼦节点添加到name元素中name.appendChild(doc.createTextNode("⾹⾹"));//将name⼦元素添加到student中student.appendChild(name);/*** 下⾯的元素依次加⼊即可* */num = doc.createElement("Num");num.appendChild(doc.createTextNode("1006010066"));student.appendChild(num);classes = doc.createElement("Classes");classes.appendChild(doc.createTextNode("眼视光5"));student.appendChild(classes);address = doc.createElement("Address");address.appendChild(doc.createTextNode("浙江温州"));student.appendChild(address);tel = doc.createElement("Tel");tel.appendChild(doc.createTextNode("123890"));student.appendChild(tel);//将student作为⼦元素添加到树的根节点schoolschool.appendChild(student);//添加到⽂档树中doc.appendChild(school);//将内存中的⽂档通过⽂件流⽣成insertSchool.xml,XmlDocument位于crison.jar下((XmlDocument)doc).write(new FileOutputStream("src/xidian/sl/dom/createSchool.xml")); System.out.println("创建成功");}}catch (Exception e) {// TODO: handle exceptione.printStackTrace();}}public static void main(String[] args) {CreateNewDom.createDom();}}运⾏结果:DOM的操作应该还是⾮常简单明了的,掌握了没哦。
java dom解析
java dom解析DOM解析器是一种用于解析XML文档的Java库。
它允许开发人员以结构化的方式访问和操作XML文件的数据。
DOM解析器将整个XML文档加载到内存中,并将其表示为一个树形结构,其中每个节点都对应着XML文档中的一个元素、属性或文本。
通过 DOM 解析器,我们可以轻松地遍历整个XML文档,提取所需的数据或修改文档的内容。
使用DOM解析器解析XML文档的基本步骤如下:1. 导入所需的Java类库:要使用DOM解析器,我们需要导入javax.xml.parsers包的相应类。
2. 创建一个XML解析器的工厂对象:通过调用javax.xml.parsers包中的DocumentBuilderFactory类的静态方法newInstance(),我们可以获取XML解析器的工厂对象。
3. 创建一个XML解析器对象:使用XML解析器的工厂对象的newDocumentBuilder()方法,我们可以创建一个XML解析器对象。
4. 解析XML文档:通过调用XML解析器对象的parse()方法,我们可以将XML文档加载到内存中并解析它。
解析结果将以一个Document对象的形式返回。
5. 获取节点信息:我们可以使用Document对象提供的方法来访问XML文档中的各个节点。
例如,可以使用getElementsByTagName()方法获取指定标签名的节点列表,使用getAttribute()方法获取节点的属性值,使用getTextContent()方法获取节点的文本内容等等。
6. 进行数据处理:一旦获取了所需的节点信息,我们可以根据具体需求对数据进行处理。
例如,可以将节点的属性值转换为Java对象,将节点的数据存储到数据库中,或者将节点的文本内容展示在用户界面上等等。
7. 释放资源:在处理完XML文档后,记得要释放DOM解析器的资源,可以调用Document对象的normalize()方法进行清理工作。
Java解析xml文件遇到特殊符号会出现异常的解决方案
Java解析xml⽂件遇到特殊符号会出现异常的解决⽅案⽂/朱季谦在⼀次Java解析xml⽂件的开发过程中,使⽤SAX解析时,出现了这样⼀个异常信息:Error on line 60 of document : 对实体 "xxx" 的引⽤必须以 ';' 分隔符结尾;我打开xml⽂件后,发现该“xxx"符号之前跟着⼀个”&“符号,后来了解到,这类符号在xml⾥属于⼀种特殊符号,⽽特殊符号若没⽤转义符表⽰,直接⽤到xml⽂件⾥,就会在使⽤SAX等⽅式做解析时出现奇怪的异常。
其实,这都是因为这些特殊字符造成的。
XML当中特殊符号包括< > & ' "等,它们是不允许作为xml⽂件的PCDATA,若想使⽤话,需⽤转义符代替:< <> >& &" "' '那么,若要正常读取xml⽂件数据,应该如何使⽤转义符替换呢?刚开始是想百度⼀番如何解决,却发现好多帖⼦都是好⼏年前的,且都没有写清楚怎么个解决⽅法,⼤多都是提到是特殊符号引起的解析异常,但怎么过滤掉,显得含糊其辞,因此,只能⾃⼰胡乱捣⿎⼀番,捣⿎出⼀个⽐较合适的将特殊字符过滤的⽅案。
实现思路其实很简单,我们可以在读取xml⽂件使⽤SAX解析前,先把xml⽂件通过Reader读取,然后按⾏读取出来拼接成⼀个String字符串,再使⽤字符串的替换⽅法replaceAll()将特殊符号进⾏替换,替换后,就可以将字符串形式的xml直接转成Document对象做xml解析了:String xmlStr=s.replaceAll("&","&");转换⽅法代码如下:StringBuffer buffer = new StringBuffer();BufferedReader bf= new BufferedReader(new FileReader("D:\\测试.xml"));String s = null;while((s = bf.readLine())!=null){buffer.append(s.trim());}String str = buffer.toString();//在这⼀步进⾏字符替换,替换成合法转义字符String xml=str.replaceAll("&","&");//这⾥就可以将处理过的xml⽂件进⾏读取解析了Document document = DocumentHelper.parseText(xml);⾄此,就可以解决Java解析xml⽂件遇到特殊符号&出现异常的问题了。
java xml格式返回报文解析
java xml格式返回报文解析Java中可以使用多种方式解析XML格式的返回报文,常见的方式有DOM解析、SAX解析以及基于XML绑定技术的解析。
每种方式都有不同的特点和适用场景,下面将详细介绍这三种解析方式。
1. DOM解析:DOM(Document Object Model)解析是将整个XML文档加载到内存中,构建成一个树形结构,并提供API来操作这个树。
DOM解析提供了许多API,可以通过节点遍历和搜索、属性读取和设置、节点创建和删除等方式来处理XML文档。
DOM解析适用于对XML文档进行多次读写操作,如增删改查等复杂的操作。
使用Java的DOM解析,可以通过以下几个步骤实现:1)使用DocumentBuilderFactory创建一个DocumentBuilder对象。
2)调用DocumentBuilder的parse方法,传入XML文件的输入流,将XML文档解析为一个Document对象。
3)通过Document对象可以获取XML文档的根元素,从而开始对XML文档进行遍历和操作。
DOM解析的优点是能够将整个XML文档加载到内存中,便于操作和修改。
但是对于较大的XML文件,DOM解析会消耗大量的内存空间。
2. SAX解析:SAX(Simple API for XML)解析是一种基于事件驱动的解析方式,它逐行读取XML文档并触发相应的事件,应用程序根据事件的发生来处理XML文档。
SAX解析的特点是速度快、内存消耗小,适用于对XML文档进行单次顺序读取的操作。
使用Java的SAX解析,可以通过以下几个步骤实现:1)定义一个继承自DefaultHandler的处理器类,重写相应的事件回调方法。
2)使用SAXParserFactory创建一个SAXParser对象。
3)调用SAXParser的parse方法,传入XML文件的输入流和处理器对象,开始解析XML文档。
SAX解析的优点是速度快,内存消耗小,适用于大型XML文件的解析。
java读取xml文件以及Jsoup解析
java读取xml⽂件以及Jsoup解析xml基本介绍xml基本语法:1.xml⽂档的后缀名为.xml2.xml第⼀⾏必须定义为⽂档声明3.xml⽂档有且仅有⼀个根标签4.属性值必须使⽤引号(单双都可以)引起来5.标签必须正确关闭6.xml标签名区分⼤⼩写组成部分1.⽂档声明格式:<?xml 属性列表 ?>version:版本号(必须); encoding:编码格式; standalone:是否独⽴取值:yes,no2.标签:名称⾃定义,并且按照规则3.属性:id属性值唯⼀4.⽂本:CDATA区:在该区域中的数据会被原样展⽰,格式:<![CDATA[ 数据 ]]>约束:规定xml⽂档的书写规则dtd:简单的约束技术schema:复杂的约束技术DTD:内部dtd:将约束规则定义在xml⽂档中;外部dtd:将约束定义在外部dtd⽂件中外部dtd:本地:<! DOCTYPE 根标签名 SYSTEM "dtd⽂件的位置">⽹络:<! DOCTYPE 根标签名 PUBLIC "dtd⽂件名字" "dtd⽂件的位置URL">java解析xml⽂件的⼏种⽅法解析xml有两种形式,其分别为:1. DOM:将标记语⾔⽂档⼀次性加载进内存,在内存中形成⼀颗dom树优点:操作⽅便,可以对⽂档进⾏CRUD(增删改查)的所有操作缺点:占内存2. SAX:逐⾏读取,基于事件驱动优点:不占内存缺点:只能读取以下⾯这个简单的xml⽂件的解析为例,具体内容参考https:///xmldom/dom_parser.asp<?xml version="1.0" encoding="UTF-8"?><peoples><people number="1"><name id="zs">张三</name><age>12</age></people><people><name>李四</name><age>15</age></people></peoples>第⼀种,使⽤DOM对xml进⾏解析import org.w3c.dom.Document;import org.w3c.dom.Element;import org.w3c.dom.NodeList;import java.io.File;import javax.xml.parsers.DocumentBuilder;import javax.xml.parsers.DocumentBuilderFactory;public class testXml {public static void main(String[] args) {try{File xml = new File("test/test.xml");DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();DocumentBuilder builder = factory.newDocumentBuilder();Document doc = builder.parse(xml);NodeList list = doc.getElementsByTagName("people");for(int i=0;i<list.getLength();i++){Element e = (Element)list.item(i);System.out.println("姓名:"+e.getElementsByTagName("name").item(0).getFirstChild().getNodeValue()+"年龄:"+e.getElementsByTagName("age").item(0).getFirstChild().getNodeValue());}}catch (Exception e){e.printStackTrace();}}}第⼆种形式,DOM4J进⾏解析import java.io.*;import java.util.*;import org.dom4j.*;import org.dom4j.io.*;public class testDOM4J {public static void main(String[] args) {try{File f = new File("test/test.xml");SAXReader reader = new SAXReader();Document doc = reader.read(f);Element root = doc.getRootElement();Element n;for (Iterator i=root.elementIterator("people");i.hasNext();) {n = (Element) i.next();System.out.println("姓名:"+n.elementText("name")+" 年龄:"+n.elementText("age"));}}catch(Exception e){e.printStackTrace();}}}第三种形式,JDOM进⾏解析import java.util.*;import org.jdom2.*;import org.jdom2.input.*;import java.io.File;public class testJDOM {public static void main(String[] args) {try{File f = new File("test/test.xml");SAXBuilder builder = new SAXBuilder();Document doc = builder.build(f);Element e = doc.getRootElement();List li = e.getChildren();Element temp;for(int i=0;i<li.size();i++){temp = (Element) li.get(i);System.out.println("姓名:"+temp.getChild("name").getText()+" 年龄:"+temp.getChild("age").getText());}}catch (Exception e){e.printStackTrace();}}}Jsoup是⼀款Java 的HTML解析器,可直接解析某个URL地址、HTML、XML⽂本内容。
Java解析XML的四种方法
Java解析XML的四种方法概序XML现在已经成为一种通用的数据交换格式,它的平台无关性,语言无关性,系统无关性,给数据集成与交互带来了极大的方便。
XML文件解析方法XML在不同的语言里解析方式都是一样的,只不过实现的语法不同而已。
基本的解析方式有两种,一种叫SAX,另一种叫DOM。
SAX是基于事件流的解析,DOM是基于XML文档树结构的解析。
假设我们XML的内容和结构如下:<?xml version="1.0" encoding="UTF-8"?><employees><employee><name>ddviplinux</name><sex>m</sex><age>30</age></employee></employees>本文实现DOM与SAX的XML文档生成与解析。
首先定义一个操作XML文档的接口XmlDocument 它定义了XML文档的建立与解析的接口。
package com.alisoft.facepay.framework.bean;/**** @author hongliang.dinghl* 定义XML文档建立与解析的接口*/public interface XmlDocument {/*** 建立XML文档* @param fileName 文件全路径名称*/public void createXml(String fileName);/*** 解析XML文档* @param fileName 文件全路径名称*/public void parserXml(String fileName);}1.DOM生成和解析XML文档为 XML 文档的已解析版本定义了一组接口。
解析器读入整个文档,然后构建一个驻留内存的树结构,然后代码就可以使用 DOM 接口来操作这个树结构。
java xml格式返回报文解析
一、概述随着互联网的不断发展,各种Web服务也愈发普及,而这些Web服务通常都是通过HTTP协议来进行通信的。
在Web服务之间进行通信时,数据的传递通常采用XML格式,而Java作为一种常用的编程语言,在处理XML格式数据时也是非常常见的。
二、XML格式返回报文解析的重要性1. XML格式返回报文在Web服务中的应用在Web服务中,XML格式的返回报文被广泛应用于数据的传输和交换。
而对于接收到的XML格式返回报文,需要进行解析和处理,才能够得到其中的有用信息。
2. Java在XML解析中的重要性在Java中,有许多用于解析XML格式数据的工具和库,比如DOM、SAX、JAXB等。
正确地使用这些工具和库,可以高效地对XML格式返回报文进行解析,从而获取其中的数据。
三、Java中XML格式返回报文解析的方法1. 使用DOM进行XML解析DOM(Document Object Model)是一种基于树形结构的XML解析模型,它将整个XML文档作为一个树形结构加载到内存中,并提供了一系列的API来操作这个树形结构。
通过使用DOM,可以方便地对XML格式返回报文进行遍历和操作,获取其中的数据。
2. 使用SAX进行XML解析SAX(Simple API for XML)是一种基于事件驱动的XML解析模型,它以事件驱动的方式逐行扫描XML文档,并触发相应的事件进行解析。
相比DOM,SAX在解析大型XML文档时占用的内存较少,因此性能更优。
通过使用SAX,可以高效地对XML格式返回报文进行解析,获取其中的数据。
3. 使用JAXB进行XML解析JAXB(Java Architecture for XML Binding)是一种将XML数据转换为Java对象的技术,它通过注解和Java类的映射关系,实现了XML数据的自动绑定和解析。
通过使用JAXB,可以将XML格式返回报文直接映射为Java对象,从而方便地进行数据操作和处理。
java 解析xml字符串 简书
在Java中解析XML字符串可以使用多种方法,其中最常见的是使用Java内置的DOM、SAX和StAX API。
1.DOM解析器DOM解析器将XML文档转换为树形结构,并允许您通过编程方式遍历和操作该树形结构。
以下是一个简单的示例,演示如何使用DOM解析器解析XML字符串:java复制代码import javax.xml.parsers.DocumentBuilderFactory;import javax.xml.parsers.DocumentBuilder;import org.w3c.dom.Document;import org.w3c.dom.Element;import org.w3c.dom.NodeList;public class DOMExample {public static void main(String[] args)throws Exception {String xmlString = "<root><element>text</element></root>";DocumentBuilderFactory factory =DocumentBuilderFactory.newInstance();DocumentBuilder builder = factory.newDocumentBuilder();Document document = builder.parse(new InputSource(newStringReader(xmlString)));document.getDocumentElement().normalize();System.out.println("Root element: " +document.getDocumentElement().getNodeName());NodeList nodeList = document.getElementsByTagName("element");for (int i = 0; i < nodeList.getLength(); i++) {Element element = (Element) nodeList.item(i);System.out.println("Element: " + element.getTextContent());}}}2.SAX解析器SAX解析器是一种基于事件的解析器,它按顺序读取XML文档,并在读取每个元素时触发事件。
java xml相关操作
java xml相关操作
Java与XML的结合是一种常见的方式,可以实现数据的存储和传输。
以下是一些Java XML相关操作的详细介绍:
1. 解析XML文件:使用Java中的DOM、SAX或JDOM等API可以解析XML文件并获取其中的数据。
2. 创建XML文件:可以使用Java中的DOM或JDOM等API创建XML文件,并将数据写入其中。
3. 使用XML Schema验证XML文档:可以使用Java中的SAX或DOM API以及一些第三方库,如JAXB或XSDValidator等,来验证XML 文档是否符合XML Schema的规范。
4. 转换XML格式:可以使用Java中的XSLT API将XML文档转换为其他格式,如HTML、PDF等。
5. 使用XPath查询XML文档:可以使用Java中的XPath API来查询XML文档中的数据。
6. 使用JAXB绑定XML和Java对象:可以使用JAXB API将XML 文档中的数据绑定到Java对象上,并进行操作和修改。
7. 使用XML与Web服务交互:可以使用Java中的WebService API 来使用XML和Web服务交互,并获取和发送数据。
总之,Java与XML的结合可以实现许多功能,如数据存储、数据传输、Web服务交互等,是Java开发中的重要部分。
- 1 -。
java读取XML文件内容的四种方法
Java parse XML methods(4)关键字: xml1. 介绍1>DOM(JAXP Crimson解析器)DOM是用与平台和语言无关的方式表示XML文档的官方W3C标准。
DOM是以层次结构组织的节点或信息片断的集合。
这个层次结构允许开发人员在树中寻找特定信息。
分析该结构通常需要加载整个文档和构造层次结构,然后才能做任何工作。
由于它是基于信息层次的,因而DOM被认为是基于树或基于对象的。
DOM 以及广义的基于树的处理具有几个优点。
首先,由于树在内存中是持久的,因此可以修改它以便应用程序能对数据和结构作出更改。
它还可以在任何时候在树中上下导航,而不是像SAX那样是一次性的处理。
DOM使用起来也要简单得多。
2>SAXSAX处理的优点非常类似于流媒体的优点。
分析能够立即开始,而不是等待所有的数据被处理。
而且,由于应用程序只是在读取数据时检查数据,因此不需要将数据存储在内存中。
这对于大型文档来说是个巨大的优点。
事实上,应用程序甚至不必解析整个文档;它可以在某个条件得到满足时停止解析。
一般来说,SAX还比它的替代者DOM快许多。
选择DOM还是选择SAX?对于需要自己编写代码来处理XML文档的开发人员来说,选择DOM还是SAX解析模型是一个非常重要的设计决策。
DOM采用建立树形结构的方式访问XML文档,而SAX 采用的事件模型。
DOM解析器把XML文档转化为一个包含其内容的树,并可以对树进行遍历。
用DOM解析模型的优点是编程容易,开发人员只需要调用建树的指令,然后利用 navigation APIs访问所需的树节点来完成任务。
可以很容易的添加和修改树中的元素。
然而由于使用DOM解析器的时候需要处理整个XML文档,所以对性能和内存的要求比较高,尤其是遇到很大的XML文件的时候。
由于它的遍历能力,DOM解析器常用于XML文档需要频繁的改变的服务中。
SAX解析器采用了基于事件的模型,它在解析XML文档的时候可以触发一系列的事件,当发现给定的tag的时候,它可以激活一个回调方法,告诉该方法制定的标签已经找到。
Java中xml解析
Java中xml解析1.String 字符串保持到txt⽂件String xml ="abcdefghijk";FileWriter fw = null;File f = new File("d:\\a.txt");try {if(!f.exists()){f.createNewFile();}fw = new FileWriter(f);BufferedWriter out = new BufferedWriter(fw);out.write(xml, 0, xml.length()-1);out.close();} catch (IOException e) {e.printStackTrace();}2.读取xml节点,获取节点值,节点属性等导⼊的包import org.dom4j.Document;import org.dom4j.io.SAXReader;SAXReader reader = new SAXReader();Document doc = reader.read(new File("d:/dahua.xml"));doc = DocumentHelper.parseText("字符串");//String 直接转为 Document ⽅法doc.read();//可以读取file,inputstream等//节点:Iterator Element.nodeIterator(); //获取当前标签节点下的所有⼦节点//标签:Element Document.getRootElement(); //获取xml⽂档的根标签Element ELement.element("标签名") //指定名称的第⼀个⼦标签Iterator<Element> Element.elementIterator("标签名");// 指定名称的所有⼦标签List<Element> Element.elements(); //获取所有⼦标签//属性:String Element.attributeValue("属性名") //获取指定名称的属性值Attribute Element.attribute("属性名");//获取指定名称的属性对象Attribute.getName() //获取属性名称Attibute.getValue() //获取属性值List<Attribute> Element.attributes(); //获取所有属性对象Iterator<Attribute> Element.attibuteIterator(); //获取所有属性对象//⽂本:Element.getText(); //获取当前标签的⽂本Element.elementText("标签名") //获取当前标签的指定名称的⼦标签的⽂本内容// 使⽤xpath⽅法List<Node> selectNodes("xpath表达式"); 查询多个节点对象Node selectSingleNode("xpath表达式"); 查询⼀个节点对象。
java解析xml详解及示例
java解析xml详解及示例java 解析xml的几种方法第一种:DOMDOM的全称是Document Object Model,也即文档对象模型。
在应用程序中,基于DOM 的XML分析器将一个XML文档转换成一个对象模型的集合(通常称DOM树),应用程序正是通过对这个对象模型的操作,来实现对XML文档数据的操作。
通过DOM接口,应用程序可以在任何时候访问XML文档中的任何一部分数据,因此,这种利用DOM接口的机制也被称作随机访问机制。
DOM接口提供了一种通过分层对象模型来访问XML文档信息的方式,这些分层对象模型依据XML的文档结构形成了一棵节点树。
无论XML文档中所描述的是什么类型的信息,即便是制表数据、项目列表或一个文档,利用DOM所生成的模型都是节点树的形式。
也就是说,DOM强制使用树模型来访问XML文档中的信息。
由于XML本质上就是一种分层结构,所以这种描述方法是相当有效的。
DOM树所提供的随机访问方式给应用程序的开发带来了很大的灵活性,它可以任意地控制整个XML文档中的内容。
然而,由于DOM 分析器把整个XML文档转化成DOM树放在了内存中,因此,当文档比较大或者结构比较复杂时,对内存的需求就比较高。
而且,对于结构复杂的树的遍历也是一项耗时的操作。
所以,DOM分析器对机器性能的要求比较高,实现效率不十分理想。
不过,由于DOM分析器所采用的树结构的思想与XML 文档的结构相吻合,同时鉴于随机访问所带来的方便,因此,DOM分析器还是有很广泛的使用价值的。
Java代码import java.io.File;import javax.xml.parsers.DocumentBuilder;import javax.xml.parsers.DocumentBuilderFactory;import org.w3c.dom.Document;import org.w3c.dom.Element;import org.w3c.dom.NodeList;public class DomT est1{public static void main(String[] args) throws Exception{// step 1: 获得dom解析器工厂(工作的作用是用于创建具体的解析器)DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();// System.out.println("class name: " + dbf.getClass().getName());// step 2:获得具体的dom解析器DocumentBuilder db = dbf.newDocumentBuilder();// System.out.println("class name: " + db.getClass().getName());// step3: 解析一个xml文档,获得Document对象(根结点)Document document = db.parse(new File("candidate.xml"));NodeList list = document.getElementsByTagName("PERSON");for(int i = 0; i < list.getLength(); i++){Element element = (Element)list.item(i);String content =element.getElementsByTagName("NAME").item(0).getFirstC hild().getNodeValue();System.out.println("name:" + content);content =element.getElementsByTagName("ADDRESS").item(0).getFir stChild().getNodeValue(); System.out.println("address:" + content);content =element.getElementsByTagName("TEL").item(0).getFirstChil d().getNodeValue();System.out.println("tel:" + content);content =element.getElementsByTagName("FAX").item(0).getFirstChil d().getNodeValue();System.out.println("fax:" + content);content =element.getElementsByTagName("EMAIL").item(0).getFirstC hild().getNodeValue();System.out.println("email:" + content);System.out.println("--------------------------------------");}}}Java代码import java.io.File;import javax.xml.parsers.DocumentBuilder;import javax.xml.parsers.DocumentBuilderFactory;import org.w3c.dom.Attr;import /doc/723478280.html,ment;import org.w3c.dom.Document;import org.w3c.dom.Element;import/doc/723478280.html,dNodeMap;import org.w3c.dom.Node;import org.w3c.dom.NodeList;/*** 使用递归解析给定的任意一个xml文档并且将其内容输出到命令行上* @author*/public class DomT est3{public static void main(String[] args) throws Exception{DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();DocumentBuilder db = dbf.newDocumentBuilder();Document doc = db.parse(new File("student.xml"));//获得根元素结点Element root = doc.getDocumentElement();parseElement(root);}private static void parseElement(Element element){String tagName = element.getNodeName();NodeList children = element.getChildNodes();System.out.print("<" + tagName);//element元素的所有属性所构成的NamedNodeMap对象,需要对其进行判断 NamedNodeMap map = element.getAttributes();//如果该元素存在属性if(null != map){{//获得该元素的每一个属性Attr attr = (Attr)map.item(i);String attrName = attr.getName();String attrValue = attr.getValue();System.out.print(" " + attrName + "=\"" + attrValue + "\""); } }System.out.print(">");for(int i = 0; i < children.getLength(); i++){Node node = children.item(i);//获得结点的类型short nodeType = node.getNodeType();if(nodeType == Node.ELEMENT_NODE){//是元素,继续递归parseElement((Element)node);}else if(nodeType == Node.TEXT_NODE){//递归出口System.out.print(node.getNodeValue());}else if(nodeType == /doc/723478280.html,MENT_NODE) {System.out.print("System.out.print(data);System.out.print("-->");}}System.out.print("");}}第二种 sax:SAX的全称是Simple APIs for XML,也即XML简单应用程序接口。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
Java解析XML文件==========================================xml文件<?xml version="1.0" encoding="GB2312"?><RESULT><VALUE><NO>A1234</NO><ADDR>四川省XX县XX镇XX路X段XX号</ADDR></VALUE><VALUE><NO>B1234</NO><ADDR>四川省XX市XX乡XX村XX组</ADDR></VALUE></RESULT>==========================================1)DOM(JAXP Crimson解析器)DOM是用与平台和语言无关的方式表示XML文档的官方W3C标准。
DOM是以层次结构组织的节点或信息片断的集合。
这个层次结构允许开发人员在树中寻找特定信息。
分析该结构通常需要加载整个文档和构造层次结构,然后才能做任何工作。
由于它是基于信息层次的,因而DOM被认为是基于树或基于对象的。
DOM以及广义的基于树的处理具有几个优点。
首先,由于树在内存中是持久的,因此可以修改它以便应用程序能对数据和结构作出更改。
它还可以在任何时候在树中上下导航,而不是像SAX那样是一次性的处理。
DOM使用起来也要简单得多。
import java.io.*;import java.util.*;import org.w3c.dom.*;import javax.xml.parsers.*;public class MyXMLReader{public static void main(String arge[]){long lasting =System.currentTimeMillis();try{File f=new File("data_10k.xml");DocumentBuilderFactory factory=DocumentBuilderFactory.newInstance();DocumentBuilder builder=factory.newDocumentBuilder();Document doc = builder.parse(f);NodeList nl = doc.getElementsByT agName("VALUE");for (int i=0;i<nl.getLength();i++){System.out.print("车牌号码:" +doc.getElementsByT agName("NO").item(i).getFirstChild().getNodeValue());System.out.println("车主地址:" + doc.getElementsByT agName("ADDR").item(i).getFirstChild().getNodeValue());}}catch(Exception e){e.printStackTrace();}==========================================2)SAXSAX处理的优点非常类似于流媒体的优点。
分析能够立即开始,而不是等待所有的数据被处理。
而且,由于应用程序只是在读取数据时检查数据,因此不需要将数据存储在内存中。
这对于大型文档来说是个巨大的优点。
事实上,应用程序甚至不必解析整个文档;它可以在某个条件得到满足时停止解析。
一般来说,SAX还比它的替代者DOM快许多。
选择DOM还是选择SAX?对于需要自己编写代码来处理XML文档的开发人员来说,选择DOM还是SAX解析模型是一个非常重要的设计决策。
DOM采用建立树形结构的方式访问XML文档,而SAX采用的事件模型。
DOM解析器把XML文档转化为一个包含其内容的树,并可以对树进行遍历。
用DOM解析模型的优点是编程容易,开发人员只需要调用建树的指令,然后利用navigation APIs访问所需的树节点来完成任务。
可以很容易的添加和修改树中的元素。
然而由于使用DOM解析器的时候需要处理整个XML文档,所以对性能和内存的要求比较高,尤其是遇到很大的XML 文件的时候。
由于它的遍历能力,DOM解析器常用于XML文档需要频繁的改变的服务中。
SAX解析器采用了基于事件的模型,它在解析XML文档的时候可以触发一系列的事件,当发现给定的tag的时候,它可以激活一个回调方法,告诉该方法制定的标签已经找到。
SAX 对内存的要求通常会比较低,因为它让开发人员自己来决定所要处理的tag.特别是当开发人员只需要处理文档中所包含的部分数据时,SAX这种扩展能力得到了更好的体现。
但用SAX 解析器的时候编码工作会比较困难,而且很难同时访问同一个文档中的多处不同数据。
import org.xml.sax.*;import org.xml.sax.helpers.*;import javax.xml.parsers.*;public class MyXMLReader extends DefaultHandler {java.util.Stack tags = new java.util.Stack();public MyXMLReader() {super();}public static void main(String args[]) {long lasting = System.currentTimeMillis();try {SAXParserFactory sf = SAXParserFactory.newInstance();SAXParser sp = sf.newSAXParser();MyXMLReader reader = new MyXMLReader();sp.parse(new InputSource("data_10k.xml"), reader);} catch (Exception e) {e.printStackTrace();}System.out.println("运行时间:" + (System.currentTimeMillis() - lasting) + "毫秒");} public void characters(char ch[], int start, int length) throws SAXException {String tag = (String) tags.peek();if (tag.equals("NO")) {System.out.print("车牌号码:" + new String(ch, start, length));}if (tag.equals("ADDR")) {System.out.println("地址:" + new String(ch, start, length));}}public void startElement(String uri,String localName,String qName,Attributes attrs) { tags.push(qName);}}==========================================3)JDOM JDOM的目的是成为Java特定文档模型,它简化与XML的交互并且比使用DOM实现更快。
由于是第一个Java特定模型,JDOM一直得到大力推广和促进。
正在考虑通过“Java规范请求JSR-102”将它最终用作“Java标准扩展”。
从2000年初就已经开始了JDOM开发。
JDOM与DOM主要有两方面不同。
首先,JDOM仅使用具体类而不使用接口。
这在某些方面简化了API,但是也限制了灵活性。
第二,API大量使用了Collections类,简化了那些已经熟悉这些类的Java开发者的使用。
JDOM文档声明其目的是“使用20%(或更少)的精力解决80%(或更多)Java/XML问题”(根据学习曲线假定为20%)。
JDOM对于大多数Java/XML应用程序来说当然是有用的,并且大多数开发者发现API比DOM容易理解得多。
JDOM还包括对程序行为的相当广泛检查以防止用户做任何在XML中无意义的事。
然而,它仍需要您充分理解XML以便做一些超出基本的工作(或者甚至理解某些情况下的错误)。
这也许是比学习DOM或JDOM接口都更有意义的工作。
JDOM自身不包含解析器。
它通常使用SAX2解析器来解析和验证输入XML文档(尽管它还可以将以前构造的DOM表示作为输入)。
它包含一些转换器以将JDOM表示输出成SAX2事件流、DOM模型或XML文本文档。
JDOM是在Apache许可证变体下发布的开放源码。
import java.io.*;import java.util.*;import org.jdom.*;import org.jdom.input.*;public class MyXMLReader {public static void main(String arge[]) {long lasting = System.currentTimeMillis();try {SAXBuilder builder = new SAXBuilder();Document doc = builder.build(new File("data_10k.xml"));Element foo = doc.getRootElement();List allChildren = foo.getChildren();for(int i=0;i<allChildren.size();i++) {System.out.print("车牌号码:" + ((Element)allChildren.get(i)).getChild("NO").getText());System.out.println("车主地址:" + ((Element)allChildren.get(i)).getChild("ADDR").getText());}} catch (Exception e) {e.printStackTrace();}}==========================================4)DOM4J 虽然DOM4J代表了完全独立的开发结果,但最初,它是JDOM的一种智能分支。