`

java解析xml的几种方式

 
阅读更多

来源：http://inotgaoshou.iteye.com/blog/1012188

 

第一种：DOM。


DOM的全称是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代码 复制代码 收藏代码
  1. import java.io.File;   
  2.   
  3. import javax.xml.parsers.DocumentBuilder;   
  4. import javax.xml.parsers.DocumentBuilderFactory;   
  5.   
  6. import org.w3c.dom.Document;   
  7. import org.w3c.dom.Element;   
  8. import org.w3c.dom.NodeList;   
  9.   
  10. public class DomTest1   
  11. {   
  12.     public static void main(String[] args) throws Exception   
  13.     {   
  14.         // step 1: 获得dom解析器工厂（工作的作用是用于创建具体的解析器）   
  15.         DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();   
  16.            
  17. //      System.out.println("class name: " + dbf.getClass().getName());   
  18.            
  19.         // step 2:获得具体的dom解析器   
  20.         DocumentBuilder db = dbf.newDocumentBuilder();   
  21.            
  22. //      System.out.println("class name: " + db.getClass().getName());   
  23.            
  24.         // step3: 解析一个xml文档，获得Document对象（根结点）   
  25.         Document document = db.parse(new File("candidate.xml"));   
  26.            
  27.         NodeList list = document.getElementsByTagName("PERSON");   
  28.            
  29.         for(int i = 0; i < list.getLength(); i++)   
  30.         {   
  31.             Element element = (Element)list.item(i);   
  32.                
  33.             String content = element.getElementsByTagName("NAME").item(0).getFirstChild().getNodeValue();   
  34.                
  35.             System.out.println("name:" + content);   
  36.                
  37.             content = element.getElementsByTagName("ADDRESS").item(0).getFirstChild().getNodeValue();   
  38.                
  39.             System.out.println("address:" + content);   
  40.                
  41.             content = element.getElementsByTagName("TEL").item(0).getFirstChild().getNodeValue();   
  42.                
  43.             System.out.println("tel:" + content);   
  44.                
  45.             content = element.getElementsByTagName("FAX").item(0).getFirstChild().getNodeValue();   
  46.                
  47.             System.out.println("fax:" + content);   
  48.                
  49.             content = element.getElementsByTagName("EMAIL").item(0).getFirstChild().getNodeValue();   
  50.                
  51.             System.out.println("email:" + content);   
  52.                
  53.             System.out.println("--------------------------------------");   
  54.         }   
  55.     }   
  56. }  
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 DomTest1
{
	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).getFirstChild().getNodeValue();
			
			System.out.println("name:" + content);
			
			content = element.getElementsByTagName("ADDRESS").item(0).getFirstChild().getNodeValue();
			
			System.out.println("address:" + content);
			
			content = element.getElementsByTagName("TEL").item(0).getFirstChild().getNodeValue();
			
			System.out.println("tel:" + content);
			
			content = element.getElementsByTagName("FAX").item(0).getFirstChild().getNodeValue();
			
			System.out.println("fax:" + content);
			
			content = element.getElementsByTagName("EMAIL").item(0).getFirstChild().getNodeValue();
			
			System.out.println("email:" + content);
			
			System.out.println("--------------------------------------");
		}
	}
}

 

Java代码 复制代码 收藏代码
  1. import java.io.File;   
  2.   
  3. import javax.xml.parsers.DocumentBuilder;   
  4. import javax.xml.parsers.DocumentBuilderFactory;   
  5.   
  6. import org.w3c.dom.Attr;   
  7. import org.w3c.dom.Comment;   
  8. import org.w3c.dom.Document;   
  9. import org.w3c.dom.Element;   
  10. import org.w3c.dom.NamedNodeMap;   
  11. import org.w3c.dom.Node;   
  12. import org.w3c.dom.NodeList;   
  13.   
  14. /**  
  15.  * 使用递归解析给定的任意一个xml文档并且将其内容输出到命令行上  
  16.  * @author zhanglong  
  17.  *  
  18.  */  
  19. public class DomTest3   
  20. {   
  21.     public static void main(String[] args) throws Exception   
  22.     {   
  23.         DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();   
  24.         DocumentBuilder db = dbf.newDocumentBuilder();   
  25.            
  26.         Document doc = db.parse(new File("student.xml"));   
  27.         //获得根元素结点   
  28.         Element root = doc.getDocumentElement();   
  29.            
  30.         parseElement(root);   
  31.     }   
  32.        
  33.     private static void parseElement(Element element)   
  34.     {   
  35.         String tagName = element.getNodeName();   
  36.            
  37.         NodeList children = element.getChildNodes();   
  38.            
  39.         System.out.print("<" + tagName);   
  40.            
  41.         //element元素的所有属性所构成的NamedNodeMap对象，需要对其进行判断   
  42.         NamedNodeMap map = element.getAttributes();   
  43.            
  44.         //如果该元素存在属性   
  45.         if(null != map)   
  46.         {   
  47.             for(int i = 0; i < map.getLength(); i++)   
  48.             {   
  49.                 //获得该元素的每一个属性   
  50.                 Attr attr = (Attr)map.item(i);   
  51.                    
  52.                 String attrName = attr.getName();   
  53.                 String attrValue = attr.getValue();   
  54.                    
  55.                 System.out.print(" " + attrName + "=\"" + attrValue + "\"");   
  56.             }   
  57.         }   
  58.            
  59.         System.out.print(">");   
  60.            
  61.         for(int i = 0; i < children.getLength(); i++)   
  62.         {   
  63.             Node node = children.item(i);   
  64.             //获得结点的类型   
  65.             short nodeType = node.getNodeType();   
  66.                
  67.             if(nodeType == Node.ELEMENT_NODE)   
  68.             {   
  69.                 //是元素，继续递归   
  70.                 parseElement((Element)node);   
  71.             }   
  72.             else if(nodeType == Node.TEXT_NODE)   
  73.             {   
  74.                 //递归出口   
  75.                 System.out.print(node.getNodeValue());   
  76.             }   
  77.             else if(nodeType == Node.COMMENT_NODE)   
  78.             {   
  79.                 System.out.print("<!--");   
  80.                    
  81.                 Comment comment = (Comment)node;   
  82.                    
  83.                 //注释内容   
  84.                 String data = comment.getData();   
  85.                    
  86.                 System.out.print(data);   
  87.                    
  88.                 System.out.print("-->");   
  89.             }   
  90.         }   
  91.            
  92.         System.out.print("</" + tagName + ">");   
  93.     }   
  94. }  
import java.io.File;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;

import org.w3c.dom.Attr;
import org.w3c.dom.Comment;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.NamedNodeMap;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;

/**
 * 使用递归解析给定的任意一个xml文档并且将其内容输出到命令行上
 * @author zhanglong
 *
 */
public class DomTest3
{
	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)
		{
			for(int i = 0; i < map.getLength(); i++)
			{
				//获得该元素的每一个属性
				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 == Node.COMMENT_NODE)
			{
				System.out.print("<!--");
				
				Comment comment = (Comment)node;
				
				//注释内容
				String data = comment.getData();
				
				System.out.print(data);
				
				System.out.print("-->");
			}
		}
		
		System.out.print("</" + tagName + ">");
	}
}

 

 

 


sax：SAX的全称是Simple APIs for XML，也即XML简单应用程序接口。与DOM不同，SAX提供的访问模式是一种顺序模式，这是一种快速读写XML数据的方式。当使用SAX分析器对XML文档进行分析时，会触发一系列事件，并激活相应的事件处理函数，应用程序通过这些事件处理函数实现对XML文档的访问，因而SAX接口也被称作事件驱动接口。

 

 

Java代码 复制代码 收藏代码
  1. import java.io.File;   
  2.   
  3. import javax.xml.parsers.SAXParser;   
  4. import javax.xml.parsers.SAXParserFactory;   
  5.   
  6. import org.xml.sax.Attributes;   
  7. import org.xml.sax.SAXException;   
  8. import org.xml.sax.helpers.DefaultHandler;   
  9.   
  10. public class SaxTest1   
  11. {   
  12.     public static void main(String[] args) throws Exception   
  13.     {   
  14.         //step1： 获得SAX解析器工厂实例   
  15.         SAXParserFactory factory = SAXParserFactory.newInstance();   
  16.            
  17.         //step2: 获得SAX解析器实例   
  18.         SAXParser parser = factory.newSAXParser();   
  19.            
  20.         //step3: 开始进行解析   
  21.         parser.parse(new File("student.xml"), new MyHandler());   
  22.            
  23.     }   
  24. }   
  25.   
  26. class MyHandler extends DefaultHandler   
  27. {   
  28.     @Override  
  29.     public void startDocument() throws SAXException   
  30.     {   
  31.         System.out.println("parse began");   
  32.     }   
  33.        
  34.     @Override  
  35.     public void endDocument() throws SAXException   
  36.     {   
  37.         System.out.println("parse finished");   
  38.     }   
  39.        
  40.     @Override  
  41.     public void startElement(String uri, String localName, String qName,   
  42.             Attributes attributes) throws SAXException   
  43.     {   
  44.         System.out.println("start element");   
  45.     }   
  46.        
  47.     @Override  
  48.     public void endElement(String uri, String localName, String qName)   
  49.             throws SAXException   
  50.     {   
  51.         System.out.println("finish element");   
  52.     }   
  53. }  
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 SaxTest1
{
	public static void main(String[] args) throws Exception
	{
		//step1： 获得SAX解析器工厂实例
		SAXParserFactory factory = SAXParserFactory.newInstance();
		
		//step2: 获得SAX解析器实例
		SAXParser parser = factory.newSAXParser();
		
		//step3: 开始进行解析
		parser.parse(new File("student.xml"), new MyHandler());
		
	}
}

class MyHandler extends DefaultHandler
{
	@Override
	public void startDocument() throws SAXException
	{
		System.out.println("parse began");
	}
	
	@Override
	public void endDocument() throws SAXException
	{
		System.out.println("parse finished");
	}
	
	@Override
	public void startElement(String uri, String localName, String qName,
			Attributes attributes) throws SAXException
	{
		System.out.println("start element");
	}
	
	@Override
	public void endElement(String uri, String localName, String qName)
			throws SAXException
	{
		System.out.println("finish element");
	}
}

 

 

Java代码 复制代码 收藏代码
  1. import java.io.File;   
  2. import java.util.Stack;   
  3.   
  4. import javax.xml.parsers.SAXParser;   
  5. import javax.xml.parsers.SAXParserFactory;   
  6.   
  7. import org.xml.sax.Attributes;   
  8. import org.xml.sax.SAXException;   
  9. import org.xml.sax.helpers.DefaultHandler;   
  10.   
  11. public class SaxTest2   
  12. {   
  13.     public static void main(String[] args) throws Exception   
  14.     {   
  15.         SAXParserFactory factory = SAXParserFactory.newInstance();   
  16.            
  17.         SAXParser parser = factory.newSAXParser();   
  18.            
  19.         parser.parse(new File("student.xml"), new MyHandler2());   
  20.     }   
  21. }   
  22.   
  23. class MyHandler2 extends DefaultHandler   
  24. {   
  25.     private Stack<String> stack = new Stack<String>();   
  26.        
  27.     private String name;   
  28.        
  29.     private String gender;   
  30.        
  31.     private String age;   
  32.        
  33.     @Override  
  34.     public void startElement(String uri, String localName, String qName,   
  35.             Attributes attributes) throws SAXException   
  36.     {   
  37.         stack.push(qName);   
  38.            
  39.         for(int i = 0; i < attributes.getLength(); i++)   
  40.         {   
  41.             String attrName = attributes.getQName(i);   
  42.             String attrValue = attributes.getValue(i);   
  43.                
  44.             System.out.println(attrName + "=" + attrValue);   
  45.         }   
  46.     }   
  47.        
  48.     @Override  
  49.     public void characters(char[] ch, int start, int length)   
  50.             throws SAXException   
  51.     {   
  52.         String tag = stack.peek();   
  53.            
  54.         if("姓名".equals(tag))   
  55.         {   
  56.             name = new String(ch, start,length);   
  57.         }   
  58.         else if("性别".equals(tag))   
  59.         {   
  60.             gender = new String(ch, start, length);   
  61.         }   
  62.         else if("年龄".equals(tag))   
  63.         {   
  64.             age = new String(ch, start, length);   
  65.         }   
  66.     }   
  67.        
  68.     @Override  
  69.     public void endElement(String uri, String localName, String qName)   
  70.             throws SAXException   
  71.     {   
  72.         stack.pop(); //表示该元素已经解析完毕，需要从栈中弹出   
  73.            
  74.         if("学生".equals(qName))   
  75.         {   
  76.             System.out.println("姓名：" + name);   
  77.             System.out.println("性别：" + gender);   
  78.             System.out.println("年龄：" + age);   
  79.                
  80.             System.out.println();   
  81.         }   
  82.            
  83.     }   
  84. }  
import java.io.File;
import java.util.Stack;

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 SaxTest2
{
	public static void main(String[] args) throws Exception
	{
		SAXParserFactory factory = SAXParserFactory.newInstance();
		
		SAXParser parser = factory.newSAXParser();
		
		parser.parse(new File("student.xml"), new MyHandler2());
	}
}

class MyHandler2 extends DefaultHandler
{
	private Stack<String> stack = new Stack<String>();
	
	private String name;
	
	private String gender;
	
	private String age;
	
	@Override
	public void startElement(String uri, String localName, String qName,
			Attributes attributes) throws SAXException
	{
		stack.push(qName);
		
		for(int i = 0; i < attributes.getLength(); i++)
		{
			String attrName = attributes.getQName(i);
			String attrValue = attributes.getValue(i);
			
			System.out.println(attrName + "=" + attrValue);
		}
	}
	
	@Override
	public void characters(char[] ch, int start, int length)
			throws SAXException
	{
		String tag = stack.peek();
		
		if("姓名".equals(tag))
		{
			name = new String(ch, start,length);
		}
		else if("性别".equals(tag))
		{
			gender = new String(ch, start, length);
		}
		else if("年龄".equals(tag))
		{
			age = new String(ch, start, length);
		}
	}
	
	@Override
	public void endElement(String uri, String localName, String qName)
			throws SAXException
	{
		stack.pop(); //表示该元素已经解析完毕，需要从栈中弹出
		
		if("学生".equals(qName))
		{
			System.out.println("姓名：" + name);
			System.out.println("性别：" + gender);
			System.out.println("年龄：" + age);
			
			System.out.println();
		}
		
	}
}

 

JDOM:

 

JDOM是一个开源项目，它基于树型结构，利用纯JAVA的技术对XML文档实现解析、生成、序列化以及多种操作。（http://jdom.org）

•JDOM 直接为JAVA编程服务。它利用更为强有力的JAVA语言的诸多特性（方法重载、集合概念等），把SAX和DOM的功能有效地结合起来。

•JDOM是用Java语言读、写、操作XML的新API函数。在直接、简单和高效的前提下，这些API函数被最大限度的优化。

 

 

jdom创建xml

 

Java代码 复制代码 收藏代码
  1. import java.io.FileWriter;   
  2.   
  3. import org.jdom.Attribute;   
  4. import org.jdom.Comment;   
  5. import org.jdom.Document;   
  6. import org.jdom.Element;   
  7. import org.jdom.output.Format;   
  8. import org.jdom.output.XMLOutputter;   
  9.   
  10. public class JDomTest1   
  11. {   
  12.     public static void main(String[] args) throws Exception   
  13.     {   
  14.         Document document = new Document();   
  15.   
  16.         Element root = new Element("root");   
  17.   
  18.         document.addContent(root);   
  19.   
  20.         Comment comment = new Comment("This is my comments");   
  21.   
  22.         root.addContent(comment);   
  23.   
  24.         Element e = new Element("hello");   
  25.   
  26.         e.setAttribute("sohu", "www.sohu.com");   
  27.   
  28.         root.addContent(e);   
  29.   
  30.         Element e2 = new Element("world");   
  31.   
  32.         Attribute attr = new Attribute("test", "hehe");   
  33.   
  34.         e2.setAttribute(attr);   
  35.   
  36.         e.addContent(e2);   
  37.   
  38.         e2.addContent(new Element("aaa").setAttribute("a", "b")   
  39.                 .setAttribute("x", "y").setAttribute("gg", "hh").setText("text content"));   
  40.   
  41.            
  42.         Format format = Format.getPrettyFormat();   
  43.            
  44.         format.setIndent("    ");   
  45. //      format.setEncoding("gbk");   
  46.            
  47.         XMLOutputter out = new XMLOutputter(format);   
  48.   
  49.         out.output(document, new FileWriter("jdom.xml"));   
  50.            
  51.     }   
  52. }  
import java.io.FileWriter;

import org.jdom.Attribute;
import org.jdom.Comment;
import org.jdom.Document;
import org.jdom.Element;
import org.jdom.output.Format;
import org.jdom.output.XMLOutputter;

public class JDomTest1
{
	public static void main(String[] args) throws Exception
	{
		Document document = new Document();

		Element root = new Element("root");

		document.addContent(root);

		Comment comment = new Comment("This is my comments");

		root.addContent(comment);

		Element e = new Element("hello");

		e.setAttribute("sohu", "www.sohu.com");

		root.addContent(e);

		Element e2 = new Element("world");

		Attribute attr = new Attribute("test", "hehe");

		e2.setAttribute(attr);

		e.addContent(e2);

		e2.addContent(new Element("aaa").setAttribute("a", "b")
				.setAttribute("x", "y").setAttribute("gg", "hh").setText("text content"));

		
		Format format = Format.getPrettyFormat();
		
		format.setIndent("    ");
//		format.setEncoding("gbk");
		
		XMLOutputter out = new XMLOutputter(format);

		out.output(document, new FileWriter("jdom.xml"));
		
	}
}

 

JDOM解析xml

 

Java代码 复制代码 收藏代码
  1. import java.io.File;   
  2. import java.io.FileOutputStream;   
  3. import java.util.List;   
  4.   
  5. import org.jdom.Attribute;   
  6. import org.jdom.Document;   
  7. import org.jdom.Element;   
  8. import org.jdom.input.SAXBuilder;   
  9. import org.jdom.output.Format;   
  10. import org.jdom.output.XMLOutputter;   
  11.   
  12. public class JDomTest2   
  13. {   
  14.     public static void main(String[] args) throws Exception   
  15.     {   
  16.         SAXBuilder builder = new SAXBuilder();   
  17.            
  18.         Document doc = builder.build(new File("jdom.xml"));   
  19.            
  20.         Element element = doc.getRootElement();   
  21.            
  22.         System.out.println(element.getName());   
  23.            
  24.         Element hello = element.getChild("hello");   
  25.            
  26.         System.out.println(hello.getText());   
  27.            
  28.         List list = hello.getAttributes();   
  29.            
  30.         for(int i = 0 ;i < list.size(); i++)   
  31.         {   
  32.             Attribute attr = (Attribute)list.get(i);   
  33.                
  34.             String attrName = attr.getName();   
  35.             String attrValue = attr.getValue();   
  36.                
  37.             System.out.println(attrName + "=" + attrValue);   
  38.         }   
  39.            
  40.         hello.removeChild("world");   
  41.            
  42.         XMLOutputter out = new XMLOutputter(Format.getPrettyFormat().setIndent("    "));   
  43.            
  44.            
  45.         out.output(doc, new FileOutputStream("jdom2.xml"));        
  46.            
  47.     }   
  48. }  
import java.io.File;
import java.io.FileOutputStream;
import java.util.List;

import org.jdom.Attribute;
import org.jdom.Document;
import org.jdom.Element;
import org.jdom.input.SAXBuilder;
import org.jdom.output.Format;
import org.jdom.output.XMLOutputter;

public class JDomTest2
{
	public static void main(String[] args) throws Exception
	{
		SAXBuilder builder = new SAXBuilder();
		
		Document doc = builder.build(new File("jdom.xml"));
		
		Element element = doc.getRootElement();
		
		System.out.println(element.getName());
		
		Element hello = element.getChild("hello");
		
		System.out.println(hello.getText());
		
		List list = hello.getAttributes();
		
		for(int i = 0 ;i < list.size(); i++)
		{
			Attribute attr = (Attribute)list.get(i);
			
			String attrName = attr.getName();
			String attrValue = attr.getValue();
			
			System.out.println(attrName + "=" + attrValue);
		}
		
		hello.removeChild("world");
		
		XMLOutputter out = new XMLOutputter(Format.getPrettyFormat().setIndent("    "));
		
		
		out.output(doc, new FileOutputStream("jdom2.xml"));		
		
	}
}

 

 

Dom4j

 

 

Java代码 复制代码 收藏代码
  1. import java.io.FileOutputStream;   
  2. import java.io.FileWriter;   
  3.   
  4. import org.dom4j.Document;   
  5. import org.dom4j.DocumentHelper;   
  6. import org.dom4j.Element;   
  7. import org.dom4j.io.OutputFormat;   
  8. import org.dom4j.io.XMLWriter;   
  9.   
  10. public class Test1   
  11. {   
  12.     public static void main(String[] args) throws Exception   
  13.     {   
  14.         // 创建文档并设置文档的根元素节点 ：第一种方式   
  15.         // Document document = DocumentHelper.createDocument();   
  16.         //   
  17.         // Element root = DocumentHelper.createElement("student");   
  18.         //   
  19.         // document.setRootElement(root);   
  20.   
  21.         // 创建文档并设置文档的根元素节点 ：第二种方式   
  22.         Element root = DocumentHelper.createElement("student");   
  23.         Document document = DocumentHelper.createDocument(root);   
  24.   
  25.         root.addAttribute("name", "zhangsan");   
  26.   
  27.         Element helloElement = root.addElement("hello");   
  28.         Element worldElement = root.addElement("world");   
  29.   
  30.         helloElement.setText("hello");   
  31.         worldElement.setText("world");   
  32.   
  33.         helloElement.addAttribute("age", "20");   
  34.   
  35.         XMLWriter xmlWriter = new XMLWriter();   
  36.         xmlWriter.write(document);   
  37.            
  38.         OutputFormat format = new OutputFormat("    ", true);   
  39.            
  40.         XMLWriter xmlWriter2 = new XMLWriter(new FileOutputStream("student2.xml"), format);   
  41.         xmlWriter2.write(document);   
  42.            
  43.         XMLWriter xmlWriter3 = new XMLWriter(new FileWriter("student3.xml"), format);   
  44.            
  45.         xmlWriter3.write(document);   
  46.         xmlWriter3.close();   
  47.   
  48.     }   
  49. }  
import java.io.FileOutputStream;
import java.io.FileWriter;

import org.dom4j.Document;
import org.dom4j.DocumentHelper;
import org.dom4j.Element;
import org.dom4j.io.OutputFormat;
import org.dom4j.io.XMLWriter;

public class Test1
{
	public static void main(String[] args) throws Exception
	{
		// 创建文档并设置文档的根元素节点 ：第一种方式
		// Document document = DocumentHelper.createDocument();
		//
		// Element root = DocumentHelper.createElement("student");
		//
		// document.setRootElement(root);

		// 创建文档并设置文档的根元素节点 ：第二种方式
		Element root = DocumentHelper.createElement("student");
		Document document = DocumentHelper.createDocument(root);

		root.addAttribute("name", "zhangsan");

		Element helloElement = root.addElement("hello");
		Element worldElement = root.addElement("world");

		helloElement.setText("hello");
		worldElement.setText("world");

		helloElement.addAttribute("age", "20");

		XMLWriter xmlWriter = new XMLWriter();
		xmlWriter.write(document);
		
		OutputFormat format = new OutputFormat("    ", true);
		
		XMLWriter xmlWriter2 = new XMLWriter(new FileOutputStream("student2.xml"), format);
		xmlWriter2.write(document);
		
		XMLWriter xmlWriter3 = new XMLWriter(new FileWriter("student3.xml"), format);
		
		xmlWriter3.write(document);
		xmlWriter3.close();

	}
}

 

 

Java代码 复制代码 收藏代码
  1. import java.io.File;   
  2. import java.util.Iterator;   
  3. import java.util.List;   
  4.   
  5. import javax.xml.parsers.DocumentBuilder;   
  6. import javax.xml.parsers.DocumentBuilderFactory;   
  7.   
  8. import org.dom4j.Document;   
  9. import org.dom4j.Element;   
  10. import org.dom4j.io.DOMReader;   
  11. import org.dom4j.io.SAXReader;   
  12.   
  13. public class Test2   
  14. {   
  15.     public static void main(String[] args) throws Exception   
  16.     {   
  17.         SAXReader saxReader = new SAXReader();   
  18.            
  19.         Document doc = saxReader.read(new File("student2.xml"));   
  20.            
  21.         Element root = doc.getRootElement();   
  22.            
  23.         System.out.println("root element: " + root.getName());   
  24.            
  25.         List childList = root.elements();   
  26.            
  27.         System.out.println(childList.size());   
  28.            
  29.         List childList2 = root.elements("hello");   
  30.            
  31.         System.out.println(childList2.size());   
  32.            
  33.         Element first = root.element("hello");   
  34.            
  35.         System.out.println(first.attributeValue("age"));   
  36.            
  37.         for(Iterator iter = root.elementIterator(); iter.hasNext();)   
  38.         {   
  39.             Element e = (Element)iter.next();   
  40.                
  41.             System.out.println(e.attributeValue("age"));   
  42.         }   
  43.            
  44.         System.out.println("---------------------------");   
  45.            
  46.         DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();   
  47.         DocumentBuilder db = dbf.newDocumentBuilder();   
  48.         org.w3c.dom.Document document = db.parse(new File("student2.xml"));   
  49.            
  50.         DOMReader domReader = new DOMReader();   
  51.            
  52.         //将JAXP的Document转换为dom4j的Document   
  53.         Document d = domReader.read(document);   
  54.            
  55.         Element rootElement = d.getRootElement();   
  56.            
  57.         System.out.println(rootElement.getName());   
  58.   
  59.     }   
  60. }  
import java.io.File;
import java.util.Iterator;
import java.util.List;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;

import org.dom4j.Document;
import org.dom4j.Element;
import org.dom4j.io.DOMReader;
import org.dom4j.io.SAXReader;

public class Test2
{
	public static void main(String[] args) throws Exception
	{
		SAXReader saxReader = new SAXReader();
		
		Document doc = saxReader.read(new File("student2.xml"));
		
		Element root = doc.getRootElement();
		
		System.out.println("root element: " + root.getName());
		
		List childList = root.elements();
		
		System.out.println(childList.size());
		
		List childList2 = root.elements("hello");
		
		System.out.println(childList2.size());
		
		Element first = root.element("hello");
		
		System.out.println(first.attributeValue("age"));
		
		for(Iterator iter = root.elementIterator(); iter.hasNext();)
		{
			Element e = (Element)iter.next();
			
			System.out.println(e.attributeValue("age"));
		}
		
		System.out.println("---------------------------");
		
		DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
		DocumentBuilder db = dbf.newDocumentBuilder();
		org.w3c.dom.Document document = db.parse(new File("student2.xml"));
		
		DOMReader domReader = new DOMReader();
		
		//将JAXP的Document转换为dom4j的Document
		Document d = domReader.read(document);
		
		Element rootElement = d.getRootElement();
		
		System.out.println(rootElement.getName());

	}
}

 

 

Java代码 复制代码 收藏代码
  1. import java.io.FileWriter;   
  2.   
  3. import org.jdom.Attribute;   
  4. import org.jdom.Document;   
  5. import org.jdom.Element;   
  6. import org.jdom.output.Format;   
  7. import org.jdom.output.XMLOutputter;   
  8.   
  9. public class Test3   
  10. {   
  11.     public static void main(String[] args) throws Exception   
  12.     {   
  13.         Document document = new Document();   
  14.   
  15.         Element root = new Element("联系人列表").setAttribute(new Attribute("公司",   
  16.                 "A集团"));   
  17.   
  18.         document.addContent(root);   
  19.            
  20.         Element contactPerson = new Element("联系人");   
  21.            
  22.         root.addContent(contactPerson);   
  23.   
  24.         contactPerson   
  25.                 .addContent(new Element("姓名").setText("张三"))   
  26.                 .addContent(new Element("公司").setText("A公司"))   
  27.                 .addContent(new Element("电话").setText("021-55556666"))   
  28.                 .addContent(   
  29.                         new Element("地址")   
  30.                                 .addContent(new Element("街道").setText("5街"))   
  31.                                 .addContent(new Element("城市").setText("上海"))   
  32.                                 .addContent(new Element("省份").setText("上海市")));   
  33.   
  34.         XMLOutputter output = new XMLOutputter(Format.getPrettyFormat()   
  35.                 .setIndent("    ").setEncoding("gbk"));   
  36.   
  37.         output.output(document, new FileWriter("contact.xml"));   
  38.   
  39.     }   
  40. }  
分享到：
| ContextLoaderListener作用详解 .
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    java解析XML的四种方式

    ### Java解析XML的四种方式详解 #### 一、DOM（Document Object Model） DOM是一种平台和语言中立的接口，它将XML文档表示为一个树结构，使得程序可以创建、读取、更新或删除树中的元素。DOM实现了W3C的标准，能够...

    java解析XML的4种经典方法

    Java解析XML的四种经典方法主要涵盖DOM、SAX、StAX和JDOM这四种方式，每种方法都有其独特的优势和适用场景。 1）DOM（JAXP Crimson 解析器） DOM（Document Object Model）是W3C推荐的一种XML解析标准，它将XML...

    java解析XML几种方式小结

    【Java解析XML】 在Java中，解析XML文档有多种方式，本文主要总结了四种常见的方法，包括DOM、SAX、StAX以及JAXB。每种方法都有其特点和适用场景，下面逐一介绍。 1. DOM（Document Object Model）解析： DOM是一种...

    java的XML四种解析方法汇总

    JAVA xml 的四种解析方式，(1)Dom生成和解析XML文档 (2)SAX生成和解析XML文档(3)DOM4J生成和解析XML文档 (4)JDOM生成和解析XML

    java解析xml的4种经典方法

    本文将详细介绍四种经典的Java XML解析技术：DOM、SAX、StAX以及JDOM。 1. DOM解析器（Document Object Model） DOM解析器将整个XML文档加载到内存中，创建一个树形结构，允许开发者通过节点遍历和操作XML。这种...

    java 解析XML性能对比分析Demo

    本文将深入探讨几种不同的XML解析方法，并通过实际的“Java解析XML性能对比分析Demo”来展示它们的性能差异。我们将讨论DOM、SAX、JDOM、DOM4J和JAXB这五种解析器，以及它们各自的特点和适用场景。 1. DOM（文档...

    java解析xml——dom

    ### Java解析XML——DOM详解 #### 一、DOM解析概念 **Document Object Model (DOM)**是一种平台和语言中立的接口，它允许程序和脚本动态地访问和更新文档的内容、结构和样式。DOM最初是为HTML设计的，但后来也被...

    解析XML文件的四种方式整合

    本文将详细讲解四种解析XML文件的方法，旨在帮助初学者更好地理解和掌握XML处理技术。 1. DOM解析器（Document Object Model） DOM解析器将整个XML文档加载到内存中，构建一个树形结构，称为DOM树。这个方法的优点...

    Java解析XML.zip

    本压缩包“Java解析XML.zip”包含了两个关键的第三方库：jaxen-1.1.1.jar和dom4j-1.6.1.jar，它们是Java解析XML文件的重要工具。 首先，让我们了解一下**DOM4J**。DOM4J是一个强大的Java XML API，它提供了灵活且高...

    Java解析XML的四种方法比较

    Java解析XML时，主要有四种方法：DOM（Document Object Model）、SAX（Simple API for XML）、StAX（Streaming API for XML）以及JAXB（Java Architecture for XML Binding）。这四种方法各有特点，适用于不同的场景...

    java心电图xml解析.zip

    在Java中，有多种方式可以解析XML文档，主要包括DOM（Document Object Model）、SAX（Simple API for XML）和StAX（Streaming API for XML）。每种方法都有其优缺点，适用于不同的场景。 1. DOM解析：DOM是将整个...

    关于解析XML的几种方式

    DOM方式解析XML文档 DOM（Document Object Model）是一种基于树形结构的XML文档表示方法，它将XML文档转换为一系列可以被Java或其他编程语言操作的对象。DOM解析器会读取整个XML文档，并在内存中创建一个完整的文档...

    java解析xml常用的几种方式总结

    本文将总结Java中解析XML的几种主要方法，包括DOM（文档对象模型）、SAX（简单API for XML）和StAX（流式API for XML）。 ### DOM解析 DOM解析器将整个XML文件加载到内存中，创建一个树形结构表示XML文档。这种...

    Java操作XML几种方法.pdf

    使用JDOM解析XML，首先需要创建`SAXBuilder`，然后解析XML文件生成`Document`对象。之后，可以使用JDOM提供的类和方法直接操作XML，如`Element`、`Attribute`等。 总结，Java操作XML的三种方法各有优缺点。DOM适合...

    几种解析xml方式的比较

    本文将对比几种不同的XML解析方法，包括DOM、SAX、JDOM和DOM4J，帮助开发者了解它们的特点和适用场景。 1. DOM（Document Object Model） DOM是一种基于树形结构的XML解析模型，由W3C定义为官方标准。在DOM解析中，...

    java dom 解析 xml 实例

    Java 中有多种方法可以解析 XML 文档，其中最常用的两种方法是使用基于事件的 XML 简单 API（Simple API for XML，SAX）和基于树和节点的文档对象模型（Document Object Model，DOM）。Sun 公司提供了 Java API for ...

    javaSAX方式解析xml文档

    Java SAX方式解析XML文档是一种高效的处理大型XML文件的方法，它基于事件驱动模型，不将整个XML文档加载到内存中，而是逐个处理XML元素。这种方式非常适合处理大文件，因为它节省了内存，但需要编写更多的代码来处理...

    Java 解析 Xml

    本文将详细介绍Java中解析XML的几种主要方法，并进行对比，以帮助开发者选择最适合自己的解决方案。 1. DOM（Document Object Model）解析器： DOM解析器将整个XML文档加载到内存中，构建一个树形结构的DOM节点模型...

    java xml文件解析

    在Java中，有多种解析XML文件的方式，包括DOM (Document Object Model)、SAX (Simple API for XML) 和 DOM4J。这些方法各有优势和局限性，选择哪一种取决于具体的应用场景和需求。 #### 二、DOM 解析方式 DOM 解析...

    java 解析xml类映射数据库 数据库操作 反射机制 源码

    本程序集的核心是利用Java解析XML文件，将XML中的数据映射到数据库，并通过反射机制进行数据库操作。下面将详细阐述这些知识点。 首先，XML解析在Java中通常有两种方式：DOM（Document Object Model）和SAX（Simple...

Magicbox
Global site tag (gtag.js) - Google Analytics