四中最常用的XML文件解析总结
xml文件解析
10
Jdom
JDOM 使用标准的 Java 编码模式,用以来弥补DOM及SAX在实际 应用当中的不足之处。 这些不足之处主要在于SAX没有文档修改、随机访问以及输出的 功能,而对于DOM来说,在使用时来用起来不太方便。 在 JDOM 中,XML 元素就是 Element 的实例,XML 属性就是 Attribute 的实例,XML 文档本身就是 Document 的实例。 因为 JDOM 对象就是像 Document、Element 和 Attribute 这些类 的直接实例,因此创建一个新 JDOM 对象就如在 Java 语言中使 用 new 操作符一样容易。而不使用复杂的工厂化模式,使对象操 作更为方便。
5
得到文档模型的根元素 Element root = doc.getDocumentElement(); 元素Element的函数: String getTagName() -得到标签的名字 String getAttribute(“unit”) -得到元素的unit属性值 节点Node的函数: NodeList getChildNodes() - 得到子节点的集合 Node getFirstChild() - 得到第一个子节点 Node getLastChild() - 得到最后一个子节点
16
1. 读取并解析XML文档:
读写XML文档主要依赖于org.dom4j.io包,其中提供DOMReader和 SAXReader两类不同方式,而调用方式是一样的。这就是依靠接口的好 处。
// 从文件读取XML,输入文件名,返回XML文档 public Document read(String fileName) throws MalformedURLException, DocumentException { SAXReader reader = new SAXReader(); Document document = reader.read(new File(fileName)); return document; } 2. 取得Root节点 public Element getRootElement(Document doc){ return doc.getRo树
4种方法XML解析文档
XML4种解析方法一、重要源码说明(1)DOM//创建解析工厂DocumentBuilderFactory dbfactory = DocumentBuilderFactory.newInstance();//指定DocumentBuilderDocumentBuilder builder = dbfactory.newDocumentBuilder()//从文件构造一个Document,因为XML文件中已经指定了编码,所以这里不必了Documentdoc=builder.parse(domparse.class.getClassLoader().getResourceAsStream("person.xml")); //获取根节点Element root = doc.getDocumentElement();System.out.println("根节点标记名:" + root.getTagName());//遍历节点NodeList list = root.getChildNodes();for (int i = 1; i < list.getLength(); i=i+2) {Node d = list.item(i);NodeList plist = d.getChildNodes();System.out.println("--"+d.getNodeName());NamedNodeMap nnm = d.getAttributes();for (int j = 0; j<nnm.getLength(); j++) {System.out.println("----"+nnm.item(j).getNodeName()+":"+nnm.item(j).getNodeV alue());}for(int k=1;k<plist.getLength();k=k+2){System.out.println("----"+plist.item(k).getNodeName()+":"+plist.item(k).getTextContent());}}(2)SAX首先创建解析器类继承DefaultHandler在解析器类中重写一些4个方法//文档开始初始化两个容器@Overridepublic void startDocument() throws SAXException {tagName = new V ector<String>();tagV alue = new V ector<String>();}//遇到标签将标签加入标签容器,并将标签的属性打印出来@Overridepublic void startElement(String uri, String localName, String name,Attributes attributes) throws SAXException {tagName.add(name);for (int i = 0; i < attributes.getLength(); i++) {System.out.println("属性名称: "+attributes.getQName(i));System.out.println("属性的值: "+attributes.getV alue(attributes.getQName(i)));}}//遇到文字类容将其添加到相应的字符串容器@Overridepublic void characters(char[] ch, int start, int length)throws SAXException {if(tagName.size()-1==tagV alue.size()){tagV alue.add(new String(ch,start,length));}}//文档结束,将两个容器的值读取出来,完成遍历@Overridepublic void endDocument() throws SAXException {for(int i=0;i<tagName.size();i++){String tagString = tagName.get(i);if(tagString.equals("")||tagString!=null){System.out.println("节点名称:"+tagString);System.out.println("节点的值:"+tagV alue.get(i));}}}用SAXParser加载解析器类SAXParser saxParser = spf.newSAXParser();saxParser.parse(new File(filename), new PersonXMLHandler());(3)JOMSAXBuilder builder=new SAXBuilder(false);Document doc=builder.build(xmlpath);//内存加载XMLElement root=doc.getRootElement();//读取根节点//以递归的方式遍历XMLpublic void parse(Element root){System.out.println("节点名称:"+root.getName());String value = root.getText().trim();System.out.println("节点的值:"+root.getText());List AttrList = root.getAttributes();for (int i = 0; i < AttrList.size(); i++) {Attribute attr = (Attribute)AttrList.get(i);System.out.println("属性名称:"+attr.getName());System.out.println("属性的值:"+attr.getV alue());}List list=root.getChildren();for (Iterator iter =list.iterator(); iter.hasNext();) {Element element = (Element)iter.next();parse(element);}(4)DOM4J//内存加载XML文档SAXReader reader = new SAXReader();Document document = reader.read(new File(fileName));//以递归的方式完成遍历public void treeWalk(Element element) {System.out.println("节点名称:"+element.getName());System.out.println("节点的值:"+element.getText());for ( Iterator<Attribute> i = element.attributeIterator(); i.hasNext(); ) {Attribute attribute = (Attribute) i.next();System.out.println("属性名称:"+attribute.getName());System.out.println("属性的值:"+attribute.getText());}for (int i = 0, size = element.nodeCount(); i < size; i++) {Node node = element.node(i);if (node instanceof Element) {treeWalk((Element) node);}}二、部署与测试说明将工程导入myEclipse或eclipse等开发工具,运行test.java主程序(java application)。
XML的四种解析器原理及性能比较
XML的四种解析器原理及性能比较XML是一种标记语言,用于描述和传输结构化的数据。
解析器是将XML文档解析成计算机能够理解的数据结构的工具。
XML解析器有四种常见的类型,分别是:DOM解析器、SAX解析器、StAX解析器和Pull解析器。
以下将对这四种解析器的原理和性能进行比较。
1. DOM解析器(Document Object Model):DOM解析器将整个XML文档加载到内存中,生成一棵树形结构的文档对象模型(DOM树)。
通过DOM树,可以对XML文档进行遍历、读取和修改。
DOM解析器的优点是易于使用和理解,缺点是占用较大的内存空间,对大型XML文档解析速度慢。
2. SAX解析器(Simple API for XML):SAX解析器是一种事件驱动的解析器,它通过逐行读取XML文档并触发事件来解析XML。
当解析器遇到元素时,会产生相应的事件,应用程序可以注册事件处理器来执行相关操作。
SAX解析器的优点是速度快,占用少量内存,适用于大型XML文档。
缺点是编码相对复杂,需要开发者自行处理解析事件。
3. StAX解析器(Streaming API for XML):StAX解析器是一种基于迭代器的解析器,提供了流式的XML处理方式。
它允许应用程序以推(pull)的方式逐行解析XML文档。
StAX解析器提供了两个核心接口:XMLStreamReader和XMLStreamWriter,分别用于读取和写入XML文档。
StAX解析器的优点是速度快,占用较少内存,适用于大型XML文档。
缺点是相对复杂,需要开发者主动控制解析过程。
4. Pull解析器:Pull解析器也是一种基于迭代器的解析器,类似于StAX解析器。
它通过迭代器(PullIterator)的方式逐行读取和处理XML文档。
相比StAX解析器,Pull解析器更加轻量级,占用更少的内存。
然而,Pull解析器的功能相对有限,仅提供了基本的解析功能。
在性能方面,DOM解析器通常需要将整个XML文档加载到内存中,适用于小型XML文档,而对于大型XML文档,DOM解析器的性能较低。
XML文件详解以及解析
XML⽂件详解以及解析⼀、xml基础详解:1、概述:xml:即可扩展标记语⾔,xml是互联⽹数据传输的重要⼯具,它可以跨越互联⽹任何的平台,不受编程语⾔和的限制,可以说它是⼀个拥有互联⽹最⾼级别通⾏证的数据携带者。
xml是当前处理结构化⽂档信息中相当给⼒的技术,xml有助于在服务器之间穿梭结构化数据,这使得开发⼈员更加得⼼应⼿的控制数据的存储和传输。
Xml⽤于标记电⼦⽂件使其具有结构性的标记语⾔,可以⽤来标记数据、定义数据类型,是⼀种允许⽤户对⾃⼰的标记语⾔进⾏定义的源语⾔。
Xml是标准通⽤标记语⾔(SGML)的⼦集,⾮常适合Web传输。
XML提供统⼀的⽅法来描述和交换独⽴于应⽤程序或供应商的结构化数据。
2、xml的特点及作⽤:特点:v xml与、编程语⾔的开发平台都⽆关;v 实现不同系统之间的数据交互。
作⽤:v 配置应⽤程序和⽹站;v 数据交互;v Ajax基⽯。
在配置⽂件⾥边所有的配置⽂件都是以XMl的格式来编写的。
跨平台进⾏数据交互,它可以跨操作系统,也可以跨编程语⾔的平台。
Ajax是现在⽬前⽐较流⾏的⼀个⽹络交互的技术。
Ajax⾥⾯最后⼀个x实际上就是xml的缩写。
Xml(Extensible Markup Language)是可扩展标记语⾔⼀个xml⽂档必须要有第⼀⾏的声明和它的⽂档元素的描述信息就可以了。
3、xml声明例⼦:注:xml声明⼀般是xml⽂档的第⼀⾏;xml声明由以下⼏个部分组成:4、根元素它是xml⽂档⾥⾯唯⼀的;它的开始是放在最前⾯,结束是放在最后⾯。
5、元素:(1) 所有的xml元素都必须有结束标签;(2) xml标签对⼤⼩写敏感;(3) xml必须正确地嵌套;(4)元素的命名规则:名称中可以包含字母、数字或者其他的字符;名称不能以数字或者标点符号开始;名称中不能包含空格。
(5)空元素6、属性(1)语法<元素名属性名=“属性值”/>例:<Student ID=“S100”><Name>Tom</Name></Student>(2)注意:属性值⽤双引号包裹;⼀个元素可以有多个属性,它的基本格式为:<元素名属性名=“属性值” 属性名=“属性值”>;属性值中不能够直接包含<.”,&。
解析Xml文件的三种方式
解析Xml⽂件的三种⽅式1、Sax解析(simple api for xml) 使⽤流式处理的⽅式,它并不记录所读内容的相关信息。
它是⼀种以事件为驱动的XML API,解析速度快,占⽤内存少。
使⽤回调函数来实现。
1class MyDefaultHander extends DefaultHandler{2private List<Student> list;3private Student student;45 @Override6public void startDocument() throws SAXException {7super.startDocument();8 list=new ArrayList<>();9 }1011 @Override12public void startElement(String uri, String localName, String qName, Attributes attributes) throws SAXException {13super.startElement(uri, localName, qName, attributes);14if(qName.equals("student")){15 student=new Student();1617 }18 preTag=qName;19 }2021 @Override22public void endElement(String uri, String localName, String qName) throws SAXException {23if(qName.equals("student")){24 list.add(student);25 }26 preTag=null;27 }2829 @Override30public void characters(char[] ch, int start, int length) throws SAXException {31if(preTag!=null){32if(preTag.equals("id")){33 student.setId(Integer.parseInt(new String(ch,start,length)));34 }else if(preTag.equals("name")){35 student.setName(new String(ch,start,length));36 }else if(preTag.equals("age")){37 student.setAge(Integer.parseInt(new String(ch,start,length)));38 }39 }40 }41public List<Student> getStudents(){42return list;43 }44 }45public List<Student> sax_parser(){46 List<Student> list=null;47try {48 SAXParser parser= SAXParserFactory.newInstance().newSAXParser();49 InputStream is= getAssets().open("student.xml");50 MyDefaultHander hander=new MyDefaultHander();51 parser.parse(is,hander);52 list= hander.getStudents();53 } catch (ParserConfigurationException e) {54 e.printStackTrace();55 } catch (SAXException e) {56 e.printStackTrace();57 } catch (IOException e) {58 e.printStackTrace();59 }60return list;61 }2、Dom解析 DOM(Document Object Model) 是⼀种⽤于XML⽂档的对象模型,可⽤于直接访问XML⽂档的各个部分。
XML的四种解析器原理及性能比较
XML的四种解析器原理及性能比较1.DOM解析器:DOM解析器将整个XML文档加载到内存中,形成一个树形结构(DOM 树),并提供了对该树进行遍历、查询和修改的操作。
DOM解析器适合于需要多次访问XML元素且需要对XML进行频繁修改的场景。
DOM解析器的原理是将整个XML文档转换为一个树形结构,其中每个节点代表一个XML元素。
由于需要将整个文档加载到内存中,所以对于大型的XML文档,DOM解析器的内存消耗会比较大。
2.SAX解析器:SAX解析器的原理是逐个读取XML文档的节点,并在遇到事件时通过回调函数进行处理。
由于SAX解析器在解析过程中不需要将整个文档加载到内存,所以对于大型的XML文档,它的内存消耗相对较小。
3.StAX解析器:StAX解析器是一种基于迭代器的流式解析器。
它提供了许多类似于迭代器的方法,可以用于逐个处理XML文档中的节点。
StAX解析器既支持事件驱动的处理方式,也支持基于指针的处理方式。
StAX解析器的原理是通过指针方式遍历XML文档,并提供了一系列的API来操作当前指针所指向的节点。
由于StAX解析器在解析过程中只需要加载部分文档内容到内存,所以其内存消耗也比较小。
4. XPath解析器:XPath解析器是一种通过路径表达式来定位和选择XML文档中的节点的解析器。
XPath解析器可以将一个XPath表达式应用到XML文档上,然后返回所匹配的节点集合或属性的值。
XPath解析器的原理是将XPath表达式与XML文档进行匹配,使用查询语言来过滤和选择XML文档中的节点集合。
由于XPath解析器只需加载部分文档内容,所以其内存消耗也较小。
性能比较方面,选择解析器应根据实际需求和XML文档的特点来决定:- 对于小型XML文档,在DOM解析器中使用XPath表达式进行查询较为方便,且性能较好;-对于大型XML文档,SAX解析器和StAX解析器是更好的选择,因为它们在解析过程中不需要加载整个文档到内存中,所以能够节省内存消耗;-如果需要对XML文档进行多次访问和修改,DOM解析器是较好的选择,因为它可以将文档加载到内存中形成DOM树,可以方便地进行多次操作。
xml 格式 解析
xml 格式解析XML格式解析是一种常见的数据解析方法,它可以将XML格式的数据转换为可供程序使用的数据结构。
XML即可扩展标记语言(eXtensible Markup Language),它被广泛应用于数据交换和存储。
下面将介绍XML格式解析的原理和常用的解析方法。
XML格式解析的原理是通过读取XML文件并识别其中的标签、属性和文本内容,将其转换为内存中的数据结构,以便程序进行进一步处理。
XML文件由起始标签、结束标签、属性和文本内容组成。
解析器会根据这些组成部分对XML文档进行解析。
常用的XML格式解析方法有两种:DOM解析和SAX解析。
DOM(文档对象模型)解析是一种将整个XML文档加载到内存中,并构建一个XML树结构的解析方法。
它可以方便地对XML文档进行增删改查操作。
DOM解析器会先将整个XML文档加载到内存中,然后构建一个树状结构,通过遍历树状结构来访问和操作XML文档的节点。
SAX(简单 API for XML)解析是一种基于事件驱动的解析方法。
它边读取XML文档边解析,并在读取到XML文档的不同部分时触发相应的事件。
相比DOM解析,SAX解析更加高效,特别适用于大型XML文件的解析。
SAX解析器会逐行读取XML文档,当遇到起始标签、结束标签或文本内容时触发相应的事件,并通过事件处理程序来处理这些事件。
选择使用DOM解析还是SAX解析取决于具体的需求。
如果需要对XML文档进行多次操作或查询,DOM解析更方便。
但是,如果处理大型XML文件或只需一次性读取XML数据,SAX解析更高效。
总之,XML格式解析是处理XML数据的重要技术。
通过DOM解析和SAX 解析,我们可以将XML格式的数据转换为程序可以处理的数据结构,实现数据的读取、分析和操作。
XML解析的四种方法建议使用demo4j解析测试可以用
XML解析的四种⽅法建议使⽤demo4j解析测试可以⽤4、DOM4J解析 特征: 1、JDOM的⼀种智能分⽀,它合并了许多超出基本XML⽂档表⽰的功能。
2、它使⽤接⼝和抽象基本类⽅法。
3、具有性能优异、灵活性好、功能强⼤和极端易⽤的特点。
4、是⼀个开放源码的⽂件 以下是解析代码:public class DOM4JTest {private static ArrayList<Book> bookList = new ArrayList<Book>();/*** @param args*/public static void main(String[] args) {// 解析books.xml⽂件// 创建SAXReader的对象readerSAXReader reader = new SAXReader();try {// 通过reader对象的read⽅法加载books.xml⽂件,获取docuemnt对象。
Document document = reader.read(new File("src/res/books.xml"));// 通过document对象获取根节点bookstoreElement bookStore = document.getRootElement();// 通过element对象的elementIterator⽅法获取迭代器Iterator it = bookStore.elementIterator();// 遍历迭代器,获取根节点中的信息(书籍)while (it.hasNext()) {System.out.println("=====开始遍历某⼀本书=====");Element book = (Element) it.next();// 获取book的属性名以及属性值List<Attribute> bookAttrs = book.attributes();for (Attribute attr : bookAttrs) {System.out.println("属性名:" + attr.getName() + "--属性值:"+ attr.getValue());}Iterator itt = book.elementIterator();while (itt.hasNext()) {Element bookChild = (Element) itt.next();System.out.println("节点名:" + bookChild.getName() + "--节点值:" + bookChild.getStringValue());}System.out.println("=====结束遍历某⼀本书=====");}} catch (DocumentException e) {// TODO Auto-generated catch blocke.printStackTrace();}}}。
xml文件解析方法
xml文件解析方法XML文件解析方法引言:XML(可扩展标记语言)是一种用于存储和传输数据的标记语言,它具有良好的可读性和灵活性,被广泛应用于数据交换和配置文件等领域。
在处理XML文件时,解析是必不可少的环节。
本文将介绍几种常用的XML文件解析方法,包括DOM、SAX和StAX。
一、DOM解析方法DOM(文档对象模型)是一种将整个XML文件以树形结构加载到内存中的解析方法。
DOM解析器将XML文件解析为一个树状结构,通过遍历节点来获取和操作XML文件中的数据。
DOM解析方法的优点是易于理解和使用,可以随机访问XML文件中的任意节点,但缺点是占用内存较大,不适用于大型XML文件的解析。
1. 创建DOM解析器对象:使用标准的Java API,可以通过DocumentBuilderFactory类来创建DOM解析器对象。
2. 加载XML文件:通过DOM解析器对象的parse()方法加载XML文件,将其转化为一个树形结构。
3. 遍历节点:使用DOM解析器对象提供的方法,如getElementsByTagName()、getChildNodes()等,可以遍历XML文件中的各个节点,获取节点的名称、属性和文本内容等信息。
4. 获取节点数据:通过节点对象提供的方法,如getNodeName()、getTextContent()等,可以获取节点的名称和文本内容。
二、SAX解析方法SAX(简单API for XML)是一种基于事件驱动的XML解析方法。
在SAX解析过程中,解析器顺序读取XML文件,当遇到节点开始、节点结束或节点文本等事件时,会触发相应的回调方法。
相比于DOM 解析方法,SAX解析方法具有内存占用小、解析速度快的优点,但缺点是无法随机访问XML文件中的节点。
1. 创建SAX解析器对象:使用标准的Java API,可以通过SAXParserFactory类来创建SAX解析器对象。
2. 实现事件处理器:自定义一个事件处理器,实现SAX解析器提供的DefaultHandler类,并重写相应的回调方法,如startElement()、endElement()和characters()等。
c解析xml常用方法
c解析xml常用方法解析XML是指将XML文档中的数据提取与分析的过程。
XML是一种标记语言,用于描述数据的结构与内容。
常用的XML解析方法包括DOM、SAX和StAX。
DOM解析:DOM(Document Object Model)是一种将XML文档表示为文档树的解析方法。
DOM解析将整个XML文档加载到内存中,并构建一个树形结构,可以方便地对XML文档进行遍历和操作。
常用的DOM解析类包括DocumentBuilder和Document类。
1.创建DOM解析器:```javaDocumentBuilderFactory factory =DocumentBuilderFactory.newInstance(;DocumentBuilder builder = factory.newDocumentBuilder(;```2.加载XML文档:```javaDocument document = builder.parse(new File("file.xml")); //通过文件Document document = builder.parse(inputStream); //通过输入流Document document = builder.parse(url); //通过URL```3.获取根节点:```javaElement rootElement = document.getDocumentElement(;```4.遍历子节点:```javaNodeList nodeList = rootElement.getChildNodes(;for (int i = 0; i < nodeList.getLength(; i++)Node node = nodeList.item(i);if (node.getNodeType( == Node.ELEMENT_NODE)Element element = (Element) node;//处理子节点}```SAX解析:SAX(Simple API for XML)是一种基于事件驱动的解析方法。
xml的四种解析方法及源代码
xml的四种解析方法及源代码(SAX、DOM、JDOM、DOM4J)第二种:DOM解析DOM中的核心概念就是节点。
DOM在分析XML文档时,将将组成XML文档的各个部分(元素、属性、文本、注释、处理指令等)映射为一个对象(节点)。
在内存中,这些节点形成一课文档树。
整棵树是一个节点,树中的每一个节点也是一棵树(子树),可以说,DOM就是对这棵树的一个对象描述,我们通过访问树中的节点来存取XML文档的内容。
PS:属性节点是附属于元素的,不能被看做是元素的子节点,更不能作为一个单独的节点DOMPrinter.javaJava代码import org.w3c.dom.Document;import dNodeMap;import org.w3c.dom.Node;import .apache.xerces.internal.parsers.DOMParser;public class DOMPrinter{public static void main(String[] args){try{/** *//** 获取Document对象 */DOMParser parser = new DOMParser();parser.parse("db.xml");Document document = parser.getDocument();printNode(document);} catch (Exception e){e.printStackTrace();}}public static void printNode(Node node){short nodeType=node.getNodeType();switch(nodeType){case Node.PROCESSING_INSTRUCTION_NODE://预处理指令类型 printNodeInfo(node);break;case Node.ELEMENT_NODE://元素节点类型printNodeInfo(node);printAttribute(node);break;case Node.TEXT_NODE://文本节点类型printNodeInfo(node);break;default:break;}Node child=node.getFirstChild();while(child!=null){printNode(child);child=child.getNextSibling();}}/** *//*** 根据节点类型打印节点* @param node*/public static void printNodeInfo(Node node){if (node.getNodeType() == Node.ELEMENT_NODE){System.out.println("NodeName: " + node.getNodeName()); }else if (node.getNodeType() == Node.TEXT_NODE){String value = node.getNodeValue().trim();if (!value.equals(""))System.out.println("NodeValue: " + value);elseSystem.out.println();}else{System.out.println(node.getNodeName()+" : "+node.getNodeValu e());}}/** *//*** 打印节点属性* @param aNode 节点*/public static void printAttribute(Node aNode){NamedNodeMap attrs = aNode.getAttributes();if(attrs!=null){for (int i = 0; i < attrs.getLength(); i++){Node attNode = attrs.item(i);System.out.println("Attribute: " + attNode.getNodeName() + "=\"" + attNode.getNodeValue()+"\"");}}}DOM生成XML文档:DOMCreateExample.javaJava代码import java.io.FileNotFoundException;import java.io.FileOutputStream;import java.io.IOException;import javax.xml.parsers.DocumentBuilder;import javax.xml.parsers.DocumentBuilderFactory;import javax.xml.parsers.ParserConfigurationException;import org.w3c.dom.Document;import org.w3c.dom.Element;import .apache.xml.internal.serialize.XMLSerializer;public class DOMCreateExample{public static void main(String[] args) throws ParserConfiguratio nException{//DOMImplementation domImp = DOMImplementationImpl.getDOMImple mentation();DocumentBuilderFactory builderFact = DocumentBuilderFactory.ne wInstance();DocumentBuilder builder = builderFact.newDocumentBuilder();Document doc = builder.newDocument();//Document doc = domImp.createDocument(null, null, null);Element root = doc.createElement("games");Element child1 = doc.createElement("game");child1.appendChild(doc.createTextNode("Final Fantasy VII")); child1.setAttribute("genre", "rpg");root.appendChild(child1);doc.appendChild(root);XMLSerializer serial;try{serial = new XMLSerializer(new FileOutputStream("domcreate.x ml"), null);serial.serialize(doc);} catch (FileNotFoundException e1){e1.printStackTrace();} catch (IOException e){e.printStackTrace();}}}第三种JDOM解析JDOM利用了java语言的优秀特性,极大地简化了对XML文档的处理,相比DOM 简单易用。
xml解析库对比总结(解析方式第三方库TinyXml)
xml解析库对比总结(解析方式第三方库TinyXml)解析方式:1.事件驱动:事件驱动的解析方式是最常见和常用的解析方式。
在这种解析方式下,解析器遇到XML文件中的每个节点时,会触发一系列的事件,应用程序可以通过注册事件处理器来处理这些事件。
这种解析方式适用于大型XML文件,因为它不需要将整个XML文件加载到内存中。
2.文档对象模型(DOM):DOM解析方式会将整个XML文件加载到内存中,并将其表示为一个树形结构。
通过DOM解析方式,应用程序可以方便地遍历和操作XML文件的内容。
但是,DOM解析方式比较消耗内存,因为它需要将整个文件加载到内存中。
3.流解析:流解析方式将XML文件分割为一系列的事件流,应用程序可以通过处理这些事件流来解析XML文件。
这种解析方式比较高效,可以处理大型XML文件。
但是,它不支持随机访问XML文件。
第三方库:1. libxml2:libxml2是一个功能强大且广泛使用的XML解析库。
它支持DOM和SAX两种解析方式,可以在大多数操作系统上运行。
libxml2具有优秀的性能和稳定性,并提供了丰富的API用于XML的解析和操作。
2. Xerces:Xerces是Apache提供的一个XML解析库。
它是用Java 编写的,支持多种编程语言,如C++、Java和Python。
Xerces提供了DOM和SAX两种解析方式,具有很好的性能和稳定性。
3. Expat:Expat是一个轻量级的XML解析库,专门用于高性能的XML解析。
它支持事件驱动的解析方式,适用于处理大型XML文件。
Expat的代码简洁而高效,易于使用和集成到应用程序中。
TinyXml是一个简单而易于使用的C++ XML解析库。
它支持DOM解析方式,可以在内存中构建整个XML文件的树形结构。
TinyXml 的设计目标是提供一种简单、易于学习和快速入门的XML解析解决方案。
它的代码简洁、易于理解,适用于小型项目和嵌入式系统。
4种常见的xml解析方法
查看文章4种常见的xml解析方法2009-11-03 14:40==========================================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");DocumentBuilderFactoryfactory=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();}==========================================2)SAXSAX处理的优点非常类似于流媒体的优点。
XML的四种解析器原理及性能比较
XML的四种解析器原理及性能比较XML(可扩展标记语言)是一种非常常见的数据交换格式,用于在应用程序之间传递和存储数据。
在处理XML数据时,需要使用解析器来读取和解析XML文档。
下面将介绍XML的四种解析器的原理和性能比较。
1. DOM解析器(Document Object Model Parser):DOM解析器将整个XML文档加载到内存中,并将其表示为一个树形结构,每个节点都对应XML文档中的一个元素或属性。
解析器可以通过遍历这个树形结构来访问和操作XML数据。
由于将整个文档加载到内存中,DOM解析器所需的内存较大,适合处理比较小的XML文档。
虽然性能较差,但它提供了灵活的访问和操作XML数据的方法。
2. SAX解析器(Simple API for XML Parser):3. StAX解析器(Streaming API for XML Parser):StAX解析器是一种混合了DOM和SAX解析器的解析器,它允许开发人员以推拉模型访问XML数据。
开发人员可以使用迭代器的形式遍历XML文档,并根据需要拉取或推送事件。
StAX解析器的内存需求较低,同时也具备灵活的操作XML数据的能力。
4. JAXB解析器(Java Architecture for XML Binding):JAXB解析器是一种用于将XML数据绑定到Java对象的解析器。
它可以将XML文档中的元素和属性映射到具体的Java类和对象上,并提供了将Java对象序列化为XML的能力。
相比于前三种解析器,JAXB解析器需要定义Java类和XML的映射关系,稍微复杂一些。
但它提供了方便的对象操作方式,可以更加简洁地处理XML数据。
对于解析性能的比较,DOM解析器的性能最差,因为它需要将整个XML文档加载到内存中。
对于大型XML文档,DOM解析器可能会导致内存不足的问题。
SAX解析器和StAX解析器的性能较好,因为它们是基于事件驱动的解析器,可以逐行读取XML文档,无需将整个文档加载到内存中。
php解析xml 的四种简洁方法(附实例)_
php解析xml 的四种简洁方法(附实例)_ XML处理是开发过程中常常遇到的,PHP对其也有很丰富的支持,本文只是对其中某几种解析技术做简要说明,包括:Xml parser, SimpleXML, XMLReader, DOMDocument。
1。
XML Expat Parser:XML Parser用法Expat XML解析器。
Expat是一种基于大事的解析器,它把XML文档视为一系列大事。
当某个大事发生时,它调用一个指定的函数处理它。
Expat是无验证的解析器,忽视任何链接到文档的DTD。
但是,假如文档的形式不好,则会以一个错误消息结束。
由于它基于大事,且无验证,Expat具有快速并适合web应用程序的特性。
XML Parser的优势是性能好,由于它不是将整个xml文档载入内存后再处理,而是边解析边处理。
但也正由于如此,它不适合那些要对xml结构做动态调整、或基于xml上下文结构做简单操作的需求。
假如你只是要解析处理一个结构良好的xml文档,那么它可以很好的完成任务。
需要留意的是XML Parser只支持三种编码格式:US-ASCII, ISO-8859-1和UTF-8,假如你的xml数据是其他编码,需要先转换成以上三个之一。
XML Parser常用的解析方式大体有两种(其实就是两个函数):xml_parse_into_struct和xml_set_element_handler。
xml_parse_into_struct此方法是将xml数据解析到两个数组中:index数组——包含指向Value 数组中值的位置的指针value数组——包含来自被解析的 XML 的数据这俩数组文字描述起来有点麻烦,还是看个例子吧(来自php官方文档)$simple = "paranotesimple note/note/para";$p = xml_parser_create();xml_parse_into_struct($p, $simple, $vals, $index); xml_parser_free($p);echo "Index array\n";print_r($index);echo "\nVals array\n";print_r($vals);输出:Index arrayArray([PARA] = Array([0] = 0[1] = 2)[NOTE] = Array([0] = 1))Vals arrayArray([0] = Array([tag] = PARA[type] = open[level] = 1)[1] = Array([tag] = NOTE[type] = complete[level] = 2[value] = simple note )[2] = Array([tag] = PARA[type] = close[level] = 1))其中index数组以标签名为key,对应的值是一个数组,里面包括全部此标签在value数组中的位置。
XML解析的三种方法
三种解析XML文件的方法在Android平台上可以使用Simple API for XML(SAX) 、 Document Object Model(DOM)和Android附带的pull解析器解析XML文件。
下面是本例子要解析的XML文件:文件名称:china.xml例子定义了一个javabean用于存放上面解析出来的xml内容,这个javabean为Person,代码:使用SAX读取XML文件SAX是一个解析速度快并且占用内存少的xml解析器,非常适合用于Android等移动设备。
SAX解析XML文件采用的是事件驱动,也就是说,它并不需要解析完整个文档,在按内容顺序解析文档的过程中,SAX会判断当前读到的字符是否合法XML语法中的某部分,如果符合就会触发事件。
所谓事件,其实就是一些回调(callback)方法,这些方法(事件)定义在ContentHandler接口。
下面是一些ContentHandler接口常用的方法:startDocument()当遇到文档的开头的时候,调用这个方法,可以在其中做一些预处理的工作。
endDocument()和上面的方法相对应,当文档结束的时候,调用这个方法,可以在其中做一些善后的工作。
startElement(String namespaceURI, String localName, String qName, Attributes atts) 当读到一个开始标签的时候,会触发这个方法。
namespaceURI就是命名空间,localName 是不带命名空间前缀的标签名,qName是带命名空间前缀的标签名。
通过atts可以得到所有的属性名和相应的值。
要注意的是SAX中一个重要的特点就是它的流式处理,当遇到一个标签的时候,它并不会纪录下以前所碰到的标签,也就是说,在startElement()方法中,所有你所知道的信息,就是标签的名字和属性,至于标签的嵌套结构,上层标签的名字,是否有子元属等等其它与结构相关的信息,都是不得而知的,都需要你的程序来完成。
XML解析——Java中XML的四种解析方式
XML解析——Java中XML的四种解析⽅式XML是⼀种通⽤的数据交换格式,它的平台⽆关性、语⾔⽆关性、系统⽆关性、给数据集成与交互带来了极⼤的⽅便。
XML在不同的语⾔环境中解析⽅式都是⼀样的,只不过实现的语法不同⽽已。
XML的解析⽅式分为四种:1、DOM解析;2、SAX解析;3、JDOM解析;4、DOM4J解析。
其中前两种属于基础⽅法,是官⽅提供的平台⽆关的解析⽅式;后两种属于扩展⽅法,它们是在基础的⽅法上扩展出来的,只适⽤于java平台。
针对以下XML⽂件,会对四种⽅式进⾏详细描述:<?xml version="1.0" encoding="UTF-8"?><bookstore><book id="1"><name>冰与⽕之歌</name><author>乔治马丁</author><year>2014</year><price>89</price></book><book id="2"><name>安徒⽣童话</name><year>2004</year><price>77</price><language>English</language></book></bookstore>⼀、DOM解析DOM的全称是Document Object Model,也即⽂档对象模型。
在应⽤程序中,基于DOM的XML分析器将⼀个XML⽂档转换成⼀个对象模型的集合(通常称DOM树),应⽤程序正是通过对这个对象模型的操作,来实现对XML⽂档数据的操作。
通过DOM接⼝,应⽤程序可以在任何时候访问XML⽂档中的任何⼀部分数据,因此,这种利⽤DOM接⼝的机制也被称作随机访问机制。
Xml 解析.doc
目前在Java中用于解析XML的技术很多,主流的有DOM、SAX、JDOM、DOM4j,下文主要介绍这4种解析XML文档技术的使用、优缺点及性能测试。
一、【基础知识——扫盲】sax、dom是两种对xml文档进行解析的方法(没有具体实现,只是接口),所以只有它们是无法解析xml文档的;jaxp只是api,它进一步封装了sax、dom两种接口,并且提供了DomcumentBuilderFactory/DomcumentBuilder和SAXParserFactory/SAXParser(默认使用xerces解释器)。
二、【DOM、SAX、JDOM、DOM4j简单使用介绍】1、【DOM(Document Object Model) 】由W3C提供的接口,它将整个XML文档读入内存,构建一个DOM树来对各个节点(Node)进行操作。
示例代码:[html]view plaincopy1.<?xml version="1.0"encoding="UTF-8"?>2.<university name="pku">3.<college name="c1">4.<class name="class1">5.<student name="stu1"sex='male'age="21"/>6.<student name="stu2"sex='female'age="20"/>7.<student name="stu3"sex='female'age="20"/>8.</class>9.<class name="class2">10.<student name="stu4"sex='male'age="19"/>11.<student name="stu5"sex='female'age="20"/>12.<student name="stu6"sex='female'age="21"/>13.</class>14.</college>15.<college name="c2">16.<class name="class3">17.<student name="stu7"sex='male'age="20"/>18.</class>19.</college>20.<college name="c3">21.</college>22.</university>后文代码中有使用到text.xml(该文档放在src路径下,既编译后在classes路径下),都是指该xml文档。
xml的四种解析方法及源代码
xml的四种解析方法及源代码(SAX、DOM、JDOM、DOM4J)第一种:SAX解析SAX处理机制:SAX是一种基于事件驱动的API。
利用SAX解析XML文档,牵涉到两个部分:解析器和事件处理器。
解析器负责读取XML文档,并向事件处理器发生事件,如元素开始和元素结束事件;而事件处理器则负责对事件做出响应,对传递的XML数据进行处理。
测试用的xml文件:db.xmlXml代码<?xml version="1.0"encoding="UTF-8"?><!--<!DOCTYPE dbconfig SYSTEM "db.dtd">--><dbconfig><db type="oracle"><driver>oracle.jdbc.driver.OracleDriver</driver><url>jdbc:oracle:thin:@localhost:1521:oracle</url><user>scott</user><password>tiger</password></db></dbconfig><?xml version="1.0" encoding="UTF-8"?><!--<!DOCTYPE dbconfig SYSTEM "db.dtd">--><dbconfig><db type="oracle"><driver>oracle.jdbc.driver.OracleDriver</driver><url>jdbc:oracle:thin:@localhost:1521:oracle</url><user>scott</user><password>tiger</password></db></dbconfig>DTD文件db.dtdXml代码<!ELEMENT dbconfig (db+)><!ELEMENT db (driver,url,user,password)><!ELEMENT driver (#PCDATA)><!ELEMENT url (#PCDATA)><!ELEMENT user (#PCDATA)><!ELEMENT password (#PCDATA)><!ATTLIST db type CDATA #REQUIRED><!ELEMENT dbconfig (db+)><!ELEMENT db (driver,url,user,password)><!ELEMENT driver (#PCDATA)><!ELEMENT url (#PCDATA)><!ELEMENT user (#PCDATA)><!ELEMENT password (#PCDATA)><!ATTLIST db type CDATA #REQUIRED>SAX解析实例一org.xml.sax.DefalutHandler类: 可以扩展该类,给出自己的解析实现SAXPrinter.javaJava代码import java.io.File;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 SAXPrinter extends DefaultHandler{/** *//*** 文档开始事件*/public void startDocument() throws SAXException{System.out.println("<?xml version=\"1.0\" encoding=\"utf-8 \"?>");}/** *//*** 接收处理指令事件*/public void processingInstruction(String target, String data) throws SAXException{System.out.println("<?"+target+" "+data+"?>");}/** *//*** 元素开始事件* 参数说明:* uri - 名称空间 URI,如果元素没有任何名称空间 URI,或者没有正在执行名称空间处理,则为空字符串。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
XML文件学习总结掌握了XML文件解析的常用的4中方式:DOM解析、SAX 解析、STAX解析以及DOM4j解析XML文件。
一、DOM 解析xml文件public List<Student> parse(String url) throws Exception{// 1、创建解析工厂D ocumentBuilderFactory factory =DocumentBuilderFactory.newInstance();//创建工厂是单例模式,不能直接new对象,需要调用newInstance来创建对象。
// 2、创建解析器D ocumentBuilder builder = factory.newDocumentBuilder();// 3、创建解析器的urlF ile file = new File(url);// 4、得到解析后的Document对象D ocument doncument = builder.parse(file);// 5、通过得到节点名字得到所有同名节点的集合NodeListN odeList nodeList = doncument.getElementsByTagName("student");// 6、遍历NodeList集合f or (int i = 0; i < nodeList.getLength(); i++) {// 得到每个节点对象Node studentNode = nodeList.item(i);Student st = new Student();NamedNodeMap map = studentNode.getAttributes();//for(int j=0;j<map.getLength();j++){Attr attr = (Attr)map.item(0);//}st.setId(Integer.parseInt(attr.getValue()));NodeList childList = studentNode.getChildNodes();for(int j=0;j<childList.getLength();j++){Node childNode = childList.item(j);if(childNode.getNodeName().equals("name")){st.setName(childNode.getTextContent());}if(childNode.getNodeName().equals("age")){st.setAge(Integer.parseInt(childNode.getTextContent()));}if(childNode.getNodeName().equals("birthday")){String str2 = childNode.getTextContent();SimpleDateFormat sdf = newSimpleDateFormat("yyyy-MM-dd");Date birthday = sdf.parse(str2);st.setBirthday(birthday);}}studentList.add(st);}r eturn studentList;}Xml文件为:(studen.xml)<?xml version="1.0" encoding="UTF-8"?><students><student id="5"><name>aaa</name><age>20</age><birthday>1990-10-10</birthday></student><student id="2"><name>bbb</name><age>30</age><birthday>1990-10-10</birthday></student><student id="3"><name>ccc</name><age>40</age><birthday>1990-10-10</birthday></student></students>解析后的文件为:5 aaa 20 Wed Oct 10 00:00:00 CST 19902 bbb 30 Wed Oct 10 00:00:00 CST 19903 ccc 40 Wed Oct 10 00:00:00 CST 1990二、Sax XML文件解析:Sax解析XML文件是属于事件请求解析。
主要是回调请求解析,来重写类中的方法来解析XML文件public class TestSAX extends DefaultHandler{private Vector<String> tagName;private Vector<String> tagValue;private int step;//方法重写的部分// 开始解析XML文件public void startDocument() throws SAXException{tagName = new Vector<String>();tagValue = new Vector<String>();step = 0;}// 结束解析XML文件public void endDocument() throws SAXException{for (int i = 0; i < tagName.size(); i++){if (!tagName.get(i).equals("") || tagName.get(i) != null){System.out.println("节点名称:"+ tagName.get(i)+"---------------节点值:" + tagValue.get(i).trim());// System.out.println("节点值:" + tagValue.get(i));}}}/***在解释到一个开始元素时会调用此方法.但是当元素有重复时可以自己写算法来区分*这些重复的元素.qName是什么?<name:page ll=""></name:page>这样写就会抛出SAXException错误*通常情况下qName等于localName*/public void startElement(String uri, String localName, String qName, Attributes attributes) throws SAXException{// 节点名称tagName.add(qName);// 循环输出属性for (int i = 0; i < attributes.getLength(); i++){// 获取属性名称System.out.println("属性名称:" + attributes.getQName(i));// 获取属性值System.out.println("属性值:"+ attributes.getValue(attributes.getQName(i)));}}*在遇到结束标签时调用此方法*/public void endElement(String uri, String localName, String qName) throws SAXException{step = step + 1;}/***读取标签里的值,ch用来存放某行的xml的字符数据,包括标签,初始大小是2048,*每解释到新的字符会把它添加到char[]里。
*注意,这个char字符会自己管理存储的字符,*并不是每一行就会刷新一次char,start,length是由xml的元素数据确定的,*暂时找不到规律,以后看源代码.**这里一个正标签,反标签都会被执行一次characters,所以在反标签时不用获得其中的值*/public void characters(char ch[], int start, int length) throws SAXException{// 只要当前的标签组的长度一至,值就不赋,则反标签不被计划在内if (tagName.size() - 1 == tagValue.size()){tagValue.add(new String(ch, start, length));}}public static void main(String[] args){String filename = "F://student.xml";// String filename = "d:/test.xml";SAXParserFactory spf = SAXParserFactory.newInstance(); //创建SAXParserFactory工厂对象try{SAXParser saxParser = spf.newSAXParser();saxParser.parse(new File(filename), new TestSAX());}catch (Exception e){e.printStackTrace();}}STAX 解析XML文件(事件处理模式解析)package com;import java.io.FileInputStream;import java.io.InputStream;import java.text.SimpleDateFormat;import java.util.ArrayList;import java.util.Date;import java.util.List;import javax.xml.stream.XMLInputFactory;import javax.xml.stream.XMLStreamConstants;import javax.xml.stream.XMLStreamReader;public class STAXTest {public List<Student> parse(String fileName) throws Exception {// STAX// 创建解析器工厂XMLInputFactory factory =XMLInputFactory.newInstance();// 创建解析器InputStream is = new FileInputStream(fileName);XMLStreamReader xsr =factory.createXMLStreamReader(is);List<Student> list = new ArrayList<Student>();Student st = new Student();String flag = "";while (xsr.hasNext()){int event = xsr.next();if (event == XMLStreamConstants.START_ELEMENT) { String tagName = xsr.getLocalName();if ("student".equals(tagName)) {st = new Student();String id = xsr.getAttributeValue(0);st.setId(Integer.parseInt(id));}if ("name".equals(tagName)) {flag = "name";}if ("age".equals(tagName)) {flag = "age";}if ("birthday".equals(tagName)) {flag = "birthday";}}if (event == XMLStreamConstants.CHARACTERS) {String str = xsr.getText();if ("name".equals(flag)) {st.setName(str);}if ("age".equals(flag)&& !"".equals(str.trim())) {st.setAge(Integer.parseInt(str.trim()));}if ("birthday".equals(flag)) {SimpleDateFormat sdf = newSimpleDateFormat("yyyy-MM-dd");try {Date birthday = sdf.parse(str);st.setBirthday(birthday);} catch (Exception e) {}}}if(event == XMLStreamConstants.END_ELEMENT){if("student".equals(xsr.getLocalName())){list.add(st);}}}return list;}public static void main(String[] args) throws Exception {STAXTest st = new STAXTest();List<Student> list = st.parse("student.xml");for(Student s : list){System.out.println(s.getId()+"\t"+s.getName().trim()+" \t"+s.getAge()+"\t"+s.getBirthday());}}}DOM4J解析xml文件:(xml文件的生成,修改,读取、解析)import java.io.BufferedInputStream;import java.io.File;import java.io.FileInputStream;import java.io.FileOutputStream;import java.util.Iterator;import java.util.List;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 Test1 {/** 生成的文件是放在 F://student.xml 目录下*/public void creat(String url){Document document = DocumentHelper.createDocument(); //建立document对象Element books = document.addElement("students"); //建立根节点Element book = null; //建立普通节点对象Element name = null; //建立下属节点nameElement sex = null; //建立下属节点sexElement age = null; //建立下属节点ageElement group = null; //建立下属节点group/** 添加注释*/document.addComment("aaaaaaaaaaaaaaaaaaaaaaaa");books.addComment("###########刘军飞,2012年元月10日#########");/** 学生一*/book = books.addElement("student"); //通过普通节点对象添加普通节点book.addComment("sssssssssssssssssssssssssss");book.addAttribute("show", "yes"); //设置节点中得属性以及设置属性值name = book.addElement("nameinf"); //添加下属节点name.addAttribute("name", "张三");group = name.addElement("班级"); //添加下属节点group.setText("class1");sex = book.addElement("sex");sex.setText("男");age = book.addElement("age");age.setText("22");/** 学生二*/book = books.addElement("student"); //通过普通节点对象添加普通节点book.addAttribute("show", "yes"); //设置节点中得属性以及设置属性值name = book.addElement("nameinf"); //添加下属节点name.addAttribute("name", "李四");group = name.addElement("班级"); //添加下属节点group.setText("class2");sex = book.addElement("sex");sex.setText("男");age = book.addElement("age");age.setText("25");/** 学生三*/book = books.addElement("student"); //通过普通节点对象添加普通节点book.addAttribute("show", "no"); //设置节点中得属性以及设置属性值name = book.addElement("nameinf"); //添加下属节点name.addAttribute("name", "王五");group = name.addElement("班级"); //添加下属节点group.setText("class3");sex = book.addElement("sex");sex.setText("女");age = book.addElement("age");age.setText("25");try {OutputFormat outputFormat =OutputFormat.createPrettyPrint();outputFormat.setEncoding("gbk");File file = new File(url);FileOutputStream fileOutputStream = new FileOutputStream(file);XMLWriter writer = new XMLWriter(fileOutputStream , outputFormat);writer.write(document);writer.close();} catch (Exception e) {e.printStackTrace();}}public void reader(String url){File file = new File(url);System.out.println("生成的XML文件内容是:");//将xml文件打印到控制台try {FileInputStream fis = new FileInputStream(url);BufferedInputStream bis = newBufferedInputStream(fis);int len = 1;byte[] bytes = new byte[100];while(len>0){len = bis.read(bytes);if(len>0)System.out.print(new String(bytes,0,len));}fis.close();bis.close();} catch (Exception e1) {e1.printStackTrace();}System.out.println("\n\nXML解析后的内容是:");//解析xml文件try {SAXReader reader = new SAXReader();Document document = reader.read(file);List list =document.selectNodes("/students/student/* |/students/student/nameinf/*" ); //xpath匹配节点Iterator iter = list.iterator();int a = 0;while(iter.hasNext()){Element element = (Element)iter.next();if(element.getName().equals("nameinf")){System.out.println("["+element.getName().trim()+"] : ["+element.attribute(0).getName().trim()+"]:["+element.attributeValue("name").trim()+"]");}else {System.out.println("["+element.getName().trim()+"] : ["+element.getText().trim()+"]");}}} catch (DocumentException e) {e.printStackTrace();}}/*** XML文件解析*/public static void main(String[] args) {Test1 test = new Test1();test.creat("F://student.xml");test.reader("F://student.xml");}}。