java解析与生成xml(三): JDOM

最新推荐文章于 2023-05-11 15:33:43 发布
最新推荐文章于 2023-05-11 15:33:43 发布
阅读量1.4k 收藏 2
点赞数 1
分类专栏： javaee
原创作品，允许转载，转载时请务必以超链接形式标明文章 原始出处 、作者信息和本人声明。否则将追究法律责任。
作者： 永恒の_☆ 地址： http://blog.csdn.net/chenghui0317/article/details/12137845

一、前言

    JDom是一套非常优秀的Java开源api，主要用于读写xml文档，具有性能优异、功能强大、和非常方便使用的特点，并且把jdk自带的解析方式SAX和Dom的功能有效地结合起来。经过实践操作发现dom4j和jdom解析xml的时候有一些相似的地方，故可以比对一下解析的性能和实现方式的效率。


二、准备条件

   jdom.jar

下载地址：http://download.csdn.net/detail/ch656409110/6334543


三、使用JDom实战


1、解析xml文档

实现思路：

   <1>创建SAX创建者对象的实例；

   <2>根据读取的xml路径，传递给SAXBuilder的实例之后 返回一个Document文档对象；

   <3>然后操作这个Document对象，获取下面的节点以及子节点的信息。

具体代码如下：

[java] view plain copy
print ?
  1. import java.io.File;  
  2. import java.io.FileInputStream;  
  3. import java.io.FileNotFoundException;  
  4. import java.io.FileOutputStream;  
  5. import java.io.IOException;  
  6. import java.io.InputStream;  
  7. import java.io.OutputStream;  
  8. import java.util.List;  
  9.   
  10. import org.jdom.DocType;  
  11. import org.jdom.Document;  
  12. import org.jdom.Element;  
  13. import org.jdom.JDOMException;  
  14. import org.jdom.input.SAXBuilder;  
  15. import org.jdom.output.XMLOutputter;  
  16. import org.xml.sax.InputSource;  
  17.   
  18.   
  19. /** 
  20.  * 使用JDom操作xml的简单例子 
  21.  * @author Administrator 
  22.  * 
  23.  */  
  24. public class JDomOperateXmlDemo {  
  25.   
  26.     public void parseXml01(){  
  27.         String xmlPath = "D:\\project\\dynamicWeb\\src\\resource\\document01.xml";    
  28.         String xmlName = xmlPath.substring(xmlPath.lastIndexOf("\\"));   
  29.         try {  
  30.             //创建SAX建造者对象，该类构造方法的重载boolean类型的方法中validate表示是否验证xml文档。  
  31.             SAXBuilder saxBuilder = new SAXBuilder(false);  
  32.             //1、直接指定绝对路径获取文件输入流对象  
  33.             //InputStream inputStream = new FileInputStream(xmlPath);  
  34.             //2、使用类的相对路径查找xml路径  
  35.             //InputStream inputStream = this.getClass().getResourceAsStream(xmlName);  
  36.             //3、也可以指定路径完成InputStream输入流的实例化操作    
  37.             InputStream inputStream = new FileInputStream(new File(xmlPath));    
  38.             //4、使用InputSource输入源作为参数也可以转换xml    
  39.             InputSource inputSource = new InputSource(inputStream);  
  40.             //解析xml文档，返回document文档对象  
  41.             Document document = saxBuilder.build(inputSource);  
  42.             Element rootElement = document.getRootElement();//根节点  
  43.               
  44.             System.out.println("根节点名称：" + rootElement.getName());//获取节点的名称    
  45.             System.out.println("根节点有多少属性：" + rootElement.getAttributes().size());//获取节点属性数目    
  46.             System.out.println("根节点id属性的值：" + rootElement.getAttributeValue("id"));//获取节点的属性id的值    
  47.             System.out.println("根节点内文本：" + rootElement.getText());//如果元素有子节点则返回空字符串，否则返回节点内的文本    
  48.             //rootElement.getText() 之所以会换行是因为 标签与标签之间使用了tab键和换行符布局，这个也算是文本所以显示出来换行的效果。    
  49.             System.out.println("根节点内文本(1)：" + rootElement.getTextTrim());//去掉的是标签与标签之间的tab键和换行符等等，不是内容前后的空格  
  50.             System.out.println("根节点内文本(2)：" + rootElement.getTextNormalize()); //目前发现和getTextTrim()方法效果一样     
  51.             System.out.println("根节点内文本(3)：" + rootElement.getValue());  //返回节点下所有内容  
  52.     
  53.             Element element = rootElement.getChild("Element"); //获取子节点,如果有多个Element节点，那么返回最先读取到的element  
  54.             if(element != null){    
  55.                 System.out.println("子节点的文本：" + element.getText());//因为子节点和根节点都是Element对象所以它们的操作方式都是相同的    
  56.             }   
  57.             //但是有些情况xml比较复杂，规范不统一，某个节点不存在直接java.lang.NullPointerException，所以获取到element对象之后要先判断一下是否为空    
  58.             List<Element> list = rootElement.getChildren("Element");//返回的是List集合  
  59.             for (Element ele : list) {  
  60.             }             
  61.         } catch (JDOMException e) {  
  62.             e.printStackTrace();  
  63.         } catch (IOException e) {  
  64.             e.printStackTrace();  
  65.         }  
  66.     }  
  67.       
  68.     public static void main(String[] args) {  
  69.         JDomOperateXmlDemo demo = new JDomOperateXmlDemo();  
  70.         demo.parseXml01();  
  71.     }  
  72. }  
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.List;

import org.jdom.DocType;
import org.jdom.Document;
import org.jdom.Element;
import org.jdom.JDOMException;
import org.jdom.input.SAXBuilder;
import org.jdom.output.XMLOutputter;
import org.xml.sax.InputSource;


/**
 * 使用JDom操作xml的简单例子
 * @author Administrator
 *
 */
public class JDomOperateXmlDemo {

	public void parseXml01(){
        String xmlPath = "D:\\project\\dynamicWeb\\src\\resource\\document01.xml";  
        String xmlName = xmlPath.substring(xmlPath.lastIndexOf("\\")); 
		try {
			//创建SAX建造者对象，该类构造方法的重载boolean类型的方法中validate表示是否验证xml文档。
			SAXBuilder saxBuilder = new SAXBuilder(false);
			//1、直接指定绝对路径获取文件输入流对象
			//InputStream inputStream = new FileInputStream(xmlPath);
			//2、使用类的相对路径查找xml路径
			//InputStream inputStream = this.getClass().getResourceAsStream(xmlName);
			//3、也可以指定路径完成InputStream输入流的实例化操作  
            InputStream inputStream = new FileInputStream(new File(xmlPath));  
            //4、使用InputSource输入源作为参数也可以转换xml  
            InputSource inputSource = new InputSource(inputStream);
            //解析xml文档，返回document文档对象
            Document document = saxBuilder.build(inputSource);
			Element rootElement = document.getRootElement();//根节点
			
			System.out.println("根节点名称：" + rootElement.getName());//获取节点的名称  
            System.out.println("根节点有多少属性：" + rootElement.getAttributes().size());//获取节点属性数目  
            System.out.println("根节点id属性的值：" + rootElement.getAttributeValue("id"));//获取节点的属性id的值  
            System.out.println("根节点内文本：" + rootElement.getText());//如果元素有子节点则返回空字符串，否则返回节点内的文本  
            //rootElement.getText() 之所以会换行是因为 标签与标签之间使用了tab键和换行符布局，这个也算是文本所以显示出来换行的效果。  
            System.out.println("根节点内文本(1)：" + rootElement.getTextTrim());//去掉的是标签与标签之间的tab键和换行符等等，不是内容前后的空格
            System.out.println("根节点内文本(2)：" + rootElement.getTextNormalize()); //目前发现和getTextTrim()方法效果一样   
            System.out.println("根节点内文本(3)：" + rootElement.getValue());  //返回节点下所有内容
  
            Element element = rootElement.getChild("Element"); //获取子节点,如果有多个Element节点，那么返回最先读取到的element
            if(element != null){  
                System.out.println("子节点的文本：" + element.getText());//因为子节点和根节点都是Element对象所以它们的操作方式都是相同的  
            } 
            //但是有些情况xml比较复杂，规范不统一，某个节点不存在直接java.lang.NullPointerException，所以获取到element对象之后要先判断一下是否为空  
            List<Element> list = rootElement.getChildren("Element");//返回的是List集合
            for (Element ele : list) {
			}			
		} catch (JDOMException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
	
	public static void main(String[] args) {
		JDomOperateXmlDemo demo = new JDomOperateXmlDemo();
		demo.parseXml01();
	}
}
另外上面的xml在src下面，document01.xml具体如下：

[html] view plain copy
print ?
  1. <?xml version="1.0" encoding="UTF-8" ?>  
  2. <Document id="doc01">  
  3.     根节点的内容  
  4.     <Element>子节点的内容</Element>  
  5.  </Document>  
<?xml version="1.0" encoding="UTF-8" ?>
<Document id="doc01">
	根节点的内容
	<Element>子节点的内容</Element>
 </Document>
接下来执行该类的main方法，console效果如下：


根据控制台显示可知：

   <1>如果new SAXBuilder(false)指定为true，指定运行会报错：Document is invalid: no grammar found.  简单的说就是没有导入语法文件，比如dtd文件等等，所以jdom在验证xml规范的时候还是非常严格的；
   <2>这里发现jdom解析xml区分大小写，就是区分指定节点名称，但是dom4j是不区分的；

   <3>有些情况xml比较复杂，规范不统一，某个节点不存在直接报错：java.lang.NullPointerException，所以获取到element对象之后要先判断一下是否为空。


上面只是简单的获取了xml的根目录的元素，接下来使用ArrayList集合循环document文档对象。

具体代码如下：

[java] view plain copy
print ?
  1. public void parseXml02(){  
  2.     String xmlPath = "D:\\project\\dynamicWeb\\src\\resource\\document02.xml";    
  3.     try {  
  4.         //创建SAX建造者对象，该类构造方法的重载boolean类型的方法中validate表示是否验证xml文档。  
  5.         SAXBuilder saxBuilder = new SAXBuilder(false);  
  6.         InputStream inputStream = new FileInputStream(new File(xmlPath));    
  7.         //解析xml文档，返回document文档对象  
  8.         Document document = saxBuilder.build(inputStream);  
  9.         Element rootElement = document.getRootElement();//根节点  
  10.           
  11.         List<Element> elementList = rootElement.getChildren("Element");  
  12.         for (Element element : elementList) {  
  13.             System.out.println("【" + element.getName() + "】：" + element.getTextTrim());//如果有子节点就返回空字符串  
  14.             Element nameElement = element.getChild("name");  
  15.             if(nameElement != null){  
  16.                 System.out.println("   " + nameElement.getName() + "：" + nameElement.getTextTrim());  
  17.             }  
  18.             Element valueElement = element.getChild("value");  
  19.             if(valueElement != null){  
  20.                 System.out.println("   " + valueElement.getName() + "：" + valueElement.getTextTrim());  
  21.             }  
  22.             Element descriptElement = element.getChild("descript");  
  23.             if(descriptElement != null){  
  24.                 System.out.println("   " + descriptElement.getName() + "：" + descriptElement.getTextTrim());  
  25.             }  
  26.         }  
  27.     } catch (JDOMException e) {  
  28.         e.printStackTrace();  
  29.     } catch (IOException e) {  
  30.         e.printStackTrace();  
  31.     }  
  32. }  
	public void parseXml02(){
		String xmlPath = "D:\\project\\dynamicWeb\\src\\resource\\document02.xml";  
		try {
			//创建SAX建造者对象，该类构造方法的重载boolean类型的方法中validate表示是否验证xml文档。
			SAXBuilder saxBuilder = new SAXBuilder(false);
			InputStream inputStream = new FileInputStream(new File(xmlPath));  
			//解析xml文档，返回document文档对象
			Document document = saxBuilder.build(inputStream);
			Element rootElement = document.getRootElement();//根节点
			
			List<Element> elementList = rootElement.getChildren("Element");
			for (Element element : elementList) {
				System.out.println("【" + element.getName() + "】：" + element.getTextTrim());//如果有子节点就返回空字符串
				Element nameElement = element.getChild("name");
				if(nameElement != null){
					System.out.println("   " + nameElement.getName() + "：" + nameElement.getTextTrim());
				}
				Element valueElement = element.getChild("value");
				if(valueElement != null){
					System.out.println("   " + valueElement.getName() + "：" + valueElement.getTextTrim());
				}
				Element descriptElement = element.getChild("descript");
				if(descriptElement != null){
					System.out.println("   " + descriptElement.getName() + "：" + descriptElement.getTextTrim());
				}
			}
		} catch (JDOMException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
另外上面的xml在src下面，document02.xml具体如下：

[html] view plain copy
print ?
  1. <?xml version="1.0" encoding="UTF-8" ?>  
  2. <Document id="doc01">  
  3.     根节点的内容  
  4.     <Element>子节点的内容</Element>  
  5.     <Element id="ele01">  
  6.         <name><![CDATA[节点的名称]]></name>  
  7.         <value><![CDATA[节点的值]]></value>  
  8.         <descript><![CDATA[节点的描述]]></descript>  
  9.     </Element>      
  10.     <Element id="ele02">  
  11.         <name><![CDATA[节点的名称<2>]]></name>  
  12.         <value><![CDATA[节点的值<2>]]></value>  
  13.         <descript><![CDATA[节点的描述<2>]]></descript>  
  14.     </Element>  
  15.  </Document>  
<?xml version="1.0" encoding="UTF-8" ?>
<Document id="doc01">
	根节点的内容
	<Element>子节点的内容</Element>
	<Element id="ele01">
		<name><![CDATA[节点的名称]]></name>
		<value><![CDATA[节点的值]]></value>
		<descript><![CDATA[节点的描述]]></descript>
	</Element>	
	<Element id="ele02">
		<name><![CDATA[节点的名称<2>]]></name>
		<value><![CDATA[节点的值<2>]]></value>
		<descript><![CDATA[节点的描述<2>]]></descript>
	</Element>
 </Document>
接下来执行该类的main方法，console效果如下：


根据控制台显示可知：

   <1>直接解析就会报错：Error on line 11: The content of elements must consist of well-formed character data or markup.  因为标签的内容中包含标签标记符号，使用<![CDATA[]]>标记会被当成文本信息不被解析；
   <2>因为是getChildren("Element");有指定具体元素名称，所以只会获取Element节点，另外节点的子节点包含Element节点不会被获取，所以getChildren("Element");没有递归获取子元素；


jdom不但能够解析xml对象，并且在解析的时候还可以操作document对象，重新构造一个新的Document文档对象。

具体代码如下：

[java] view plain copy
print ?
  1. public void operateXml01(){  
  2.        String xmlPath = "D:\\project\\dynamicWeb\\src\\resource\\document03.xml";    
  3.     try {  
  4.         //创建SAX建造者对象，该类构造方法的重载boolean类型的方法中validate表示是否验证xml文档。  
  5.         SAXBuilder saxBuilder = new SAXBuilder(false);  
  6.         InputStream inputStream = new FileInputStream(new File(xmlPath));    
  7.         //4、使用InputSource输入源作为参数也可以转换xml    
  8.         InputSource inputSource = new InputSource(inputStream);  
  9.         //解析xml文档，返回document文档对象  
  10.         Document document = saxBuilder.build(inputSource);  
  11.         Element rootElement = document.getRootElement();//根节点  
  12.         /* 
  13.         rootElement.setName("root");//支持修改节点名称   
  14.         System.out.println("根节点修改之后的名称：" + rootElement.getName());   
  15.         rootElement.setText("text"); //同样修改标签内的文本也一样   
  16.         System.out.println("根节点修改之后的文本：" + rootElement.getText());   
  17.         */  
  18.         //接下来根据id获取元素 添加子元素或者删除子节点  
  19.         List<Element> elementList = rootElement.getChildren();  
  20.         System.out.println("删除节点前的集合个数："+elementList.size());  
  21.         for (Element element : elementList) {  
  22.             if(element.getAttributeValue("id")!=null){  
  23.                 if(element.getAttributeValue("id").equals("ele01")){  
  24.                     Element element01 = new Element("new_name");  
  25.                     element01.setText("新添加的名称");  
  26.                     Element element02 = new Element("new_value");  
  27.                     element02.setText("新添加的名称");  
  28.                     Element element03 = new Element("new_descript");  
  29.                     element03.setText("新添加的名称");  
  30.                     element.addContent(element01);  
  31.                     element.addContent(element02);  
  32.                     element.addContent(element03);  
  33.                 }else if(element.getAttributeValue("id").equals("ele02")){  
  34.                     /* 
  35.                     rootElement.removeContent(element); 
  36.                     break; 
  37.                     */  
  38.                     element.removeContent();  
  39.                     System.out.println("删除节点后的集合个数："+elementList.size());  
  40.                 }  
  41.             }  
  42.         }  
  43.         elementList = rootElement.getChildren("Element");  
  44.         for (Element element : elementList) {  
  45.             System.out.println("【" + element.getName() + "】：" + element.getTextTrim());//如果有子节点就返回空字符串  
  46.             Element nameElement = element.getChild("new_name");  
  47.             if(nameElement != null){  
  48.                 System.out.println("   " + nameElement.getName() + "：" + nameElement.getTextTrim());  
  49.             }  
  50.             Element valueElement = element.getChild("new_value");  
  51.             if(valueElement != null){  
  52.                 System.out.println("   " + valueElement.getName() + "：" + valueElement.getTextTrim());  
  53.             }  
  54.             Element descriptElement = element.getChild("new_descript");  
  55.             if(descriptElement != null){  
  56.                 System.out.println("   " + descriptElement.getName() + "：" + descriptElement.getTextTrim());  
  57.             }  
  58.         }  
  59.     } catch (JDOMException e) {  
  60.         e.printStackTrace();  
  61.     } catch (IOException e) {  
  62.         e.printStackTrace();  
  63.     }  
  64. }  
	public void operateXml01(){
        String xmlPath = "D:\\project\\dynamicWeb\\src\\resource\\document03.xml";  
		try {
			//创建SAX建造者对象，该类构造方法的重载boolean类型的方法中validate表示是否验证xml文档。
			SAXBuilder saxBuilder = new SAXBuilder(false);
			InputStream inputStream = new FileInputStream(new File(xmlPath));  
			//4、使用InputSource输入源作为参数也可以转换xml  
			InputSource inputSource = new InputSource(inputStream);
			//解析xml文档，返回document文档对象
			Document document = saxBuilder.build(inputSource);
			Element rootElement = document.getRootElement();//根节点
			/*
	        rootElement.setName("root");//支持修改节点名称  
	        System.out.println("根节点修改之后的名称：" + rootElement.getName());  
	        rootElement.setText("text"); //同样修改标签内的文本也一样  
	        System.out.println("根节点修改之后的文本：" + rootElement.getText());  
	        */
	        //接下来根据id获取元素 添加子元素或者删除子节点
	        List<Element> elementList = rootElement.getChildren();
	        System.out.println("删除节点前的集合个数："+elementList.size());
	        for (Element element : elementList) {
	        	if(element.getAttributeValue("id")!=null){
					if(element.getAttributeValue("id").equals("ele01")){
						Element element01 = new Element("new_name");
						element01.setText("新添加的名称");
						Element element02 = new Element("new_value");
						element02.setText("新添加的名称");
						Element element03 = new Element("new_descript");
						element03.setText("新添加的名称");
						element.addContent(element01);
						element.addContent(element02);
						element.addContent(element03);
					}else if(element.getAttributeValue("id").equals("ele02")){
						/*
						rootElement.removeContent(element);
						break;
						*/
						element.removeContent();
						System.out.println("删除节点后的集合个数："+elementList.size());
					}
	        	}
			}
	        elementList = rootElement.getChildren("Element");
			for (Element element : elementList) {
				System.out.println("【" + element.getName() + "】：" + element.getTextTrim());//如果有子节点就返回空字符串
				Element nameElement = element.getChild("new_name");
				if(nameElement != null){
					System.out.println("   " + nameElement.getName() + "：" + nameElement.getTextTrim());
				}
				Element valueElement = element.getChild("new_value");
				if(valueElement != null){
					System.out.println("   " + valueElement.getName() + "：" + valueElement.getTextTrim());
				}
				Element descriptElement = element.getChild("new_descript");
				if(descriptElement != null){
					System.out.println("   " + descriptElement.getName() + "：" + descriptElement.getTextTrim());
				}
			}
		} catch (JDOMException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
另外上面的xml在src下面，document03.xml具体如下：
[html] view plain copy
print ?
  1. <?xml version="1.0" encoding="UTF-8" ?>  
  2. <Document id="doc01">  
  3.     根节点的内容  
  4.     <Element>子节点的内容</Element>  
  5.     <Element id="ele01">  
  6.         <Content>节点内容1</Content>  
  7.     </Element>      
  8.     <Element id="ele02">  
  9.         <Content>节点内容2</Content>  
  10.     </Element>  
  11.  </Document>  
<?xml version="1.0" encoding="UTF-8" ?>
<Document id="doc01">
	根节点的内容
	<Element>子节点的内容</Element>
	<Element id="ele01">
		<Content>节点内容1</Content>
	</Element>	
	<Element id="ele02">
		<Content>节点内容2</Content>
	</Element>
 </Document>
接下来执行该类的main方法，console效果如下：

根据控制台显示可知：

   <1>执行上面的修改根节点操作会影响下面，因为setText()会直接覆盖掉根节点下的子节点；
   <2>开始删除节点使用的是rootElement.removeContent(element);直接删除节点的方法，直接报错：Exception in thread "main" java.util.ConcurrentModificationException  除非删除之后立刻执行break;另外调用element.removeContent();就不会出现这样的问题；

   <3>根据输出节点集合的个数可知，再循环的时候改变集合数量会直接影响循环，因为循环过程中并没有随着数量的修改而改变循环的次数。但element.removeContent(); 不一样，循环至始至终集合数量都没有发生改变，只是将这个节点的引用置为null了。


2、生成xml文档

JDom能够解析xml，同样肯定能生成xml，而且使用起来更加简单方便。

实现思路：

   <1>创建Document对象，添加节点以及节点下的文本、名称和属性值；

   <2>创建XMLOutputter的实例，调用output()方法把document写入磁盘；

具体代码如下：

[java] view plain copy
print ?
  1. public void buildXml01(){  
  2.     //自己封装xml文档对象  
  3.     Element rootElement = new Element("Document");  
  4.     Element element = new Element("Element");  
  5.       
  6.     Element nameElement = new Element("name");  
  7.     nameElement.setText("<名称>");  
  8.     Element valueElement = new Element("value");  
  9.     valueElement.setText("<值 >\"\\");  
  10.     Element descriptionElement = new Element("description");  
  11.     descriptionElement.setText("<描述><![CDATA[<查看是否转义保存>]]>");  
  12.     //添加子节点  
  13.     element.addContent(nameElement);  
  14.     element.addContent(valueElement);  
  15.     element.addContent(descriptionElement);  
  16.       
  17.     rootElement.addContent(element);  
  18.       
  19.     Document document = new Document(rootElement);  
  20.     DocType docType = new DocType("Doctype");  
  21.     document.setDocType(docType);  
  22.       
  23.     XMLOutputter xmloutputter = new XMLOutputter();  
  24.     OutputStream outputStream;  
  25.     try {  
  26.         outputStream = new FileOutputStream("c:\\document.xml");  
  27.         xmloutputter.output(document, outputStream);  
  28.         System.out.println("xml文档生成成功！");  
  29.     } catch (FileNotFoundException e) {  
  30.         e.printStackTrace();  
  31.     } catch (IOException e) {  
  32.         e.printStackTrace();  
  33.     }  
  34. }  
	public void buildXml01(){
		//自己封装xml文档对象
		Element rootElement = new Element("Document");
		Element element = new Element("Element");
		
		Element nameElement = new Element("name");
		nameElement.setText("<名称>");
		Element valueElement = new Element("value");
		valueElement.setText("<值 >\"\\");
		Element descriptionElement = new Element("description");
		descriptionElement.setText("<描述><![CDATA[<查看是否转义保存>]]>");
		//添加子节点
		element.addContent(nameElement);
		element.addContent(valueElement);
		element.addContent(descriptionElement);
		
		rootElement.addContent(element);
		
		Document document = new Document(rootElement);
		DocType docType = new DocType("Doctype");
		document.setDocType(docType);
		
		XMLOutputter xmloutputter = new XMLOutputter();
		OutputStream outputStream;
		try {
			outputStream = new FileOutputStream("c:\\document.xml");
			xmloutputter.output(document, outputStream);
			System.out.println("xml文档生成成功！");
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

接下来执行该类的main方法，console提示生成成功。

然后到c盘根目录寻找document.xml，具体如下：

实践发现：

   <1>如果不指定编码，生成的xml默认是UTF-8编码的；
   <2>节点内的文本内容包含标签标记符都会被转义成&lt; &gt; ,，但是其他特殊符号就不会，比如空格，双引用，单引号，斜杠 等等。


三、几种解析XML方式的比较

前面依次介绍了三种操作xml的方式，分别是：

   Dom4j解析和生成XML文档，  地址：http://blog.csdn.net/chenghui0317/article/details/11486271

   Dom解析和生成XML文档，  地址：http://blog.csdn.net/chenghui0317/article/details/11662667

   SAX解析和生成XML文档，  地址：http://blog.csdn.net/chenghui0317/article/details/11990891 

   <1>Dom4j的xml解析性能最好，目前有许多开源项目都在使用Dom4j解析xml文档，比如hibernate，另外Dom4j解析的时候采用面向对象，所有的节点都是用Element封装之后返回，非常方便使用和调用；

   <2>SAX解析xml性能较好，因为它是采用DefaultHandler事件处理者来解析的，但是不好的地方在于每一个节点的名称，属性和内容都被分开了，也没有使用对象封装，所以在解析之后封装对象上面比较麻烦，稍微不注意就会使空文本覆盖掉应该存放的值；

   <3>JDom在解析xml性能上表现不是很好，虽然JDom 和 Dom4j在解析上有很多相似之后，大多差距都是方法名称不同但是具体含义相同，所以使用起来还是蛮方便的；

   <4>Dom在解析xml性能上表现也不是很好，另外Dom在解析xml使用的时候感觉是最不方便的，Dom并没有把解析的节点封装成对象，并且很容易受到非空内容的节点影响，导致解析抛异常。



nowseeme
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java gettext trim,Java Element.getTextTrim方法代码示例
weixin_36035466的博客
03-09 1044
import org.jdom2.Element; //导入方法依赖的package包/类/*** Parse a traffic matrix file containing a sequence of traffic matrices** @param trafficMatrixFile The name of the traffic matrix file* @return A Traffi...
JAVA 解析XML生成XML文档实例
12-13
JAVA 解析XML和生成XML文档源码。比较全 1.DOM生成和解析XML文档 2.SAX生成和解析XML文档 3.DOM4J生成和解析XML文档 4.JDOM生成和解析XML
java for
daming911230的专栏
10-10 405
JDK 1.5对for语句进行了改进，为更好遍历数组，改进后的for语句格式如下：   for(声明循环变量 : 数组名)   { ...   } 如：   char b[]={'a','b','c','d'};   for(char ch : b)   {    System.out.println(ch);//打印出数组b中的元素   }
jdom操作xml实战
最新发布
baidu_21349635的专栏
05-11 406
最近有个项目用到了xml的写入，其实目前java有很多的方式操作xml，比如之前用到的dom4j，今天推荐个更好用的jdom，目前的版本是2了
XML的四种解析器原理及性能分析比较
11-03 966
               XML的四种解析器原理及性能比较                                                     1: DOMDOM 是用与平台和语言无关的方式表示 XML 文档的官方 W3C 标准。DOM 是以层次结构组织的节点或信息片断的集合。这个层次结构允许开发人员在树中寻找特定信息。分析该结构通常需要 加载整个文档和构造层次结构，然后才
DOM、JDOM、DOM4J解析XML
七一
07-17 776
DOM、JDOM、DOM4J解析XML JAVA解析XML通常有两种方式，DOM和SAX(SAX前面已经示范) DOM:Document Object Model(文档对象模型) DOM的特性： 定义一组JAVA接口，基于对象，与语言和平台无关将XML文档表示为树，在内存中解析和存储XML文档，允许随机访问文档的不同部分 DOM解析XML DOM的优点，由于树在内存中是持久的，因此可以修改后更新，它还可以在任何时候在树中上下导航，API使用起来也比较简单。 解析步骤： DocumentBuilderFact
Java实现XML解析【JDom】
12-25
本资源实现Java中的XML文件解析--【JDom】方法，生成XML文件的数据是从MySQL数据库中来的
android java xml 解析生成jar
06-05
android java开发常用 xml数据格式解析 生成 jdom.jar 有各种实例代码，加压查找即可看到个版本jar 包
Java实现Jdom生成xml
05-14
Java实现Jdom生成解析xml，一般可以用到存储数据。比如我以前做过的ERP系统，权限初始化就用的解析XML，但是现在上传的只是生成XML。如果哪位需要解析XML，留个言。。。。
Java利用JDom解析和传递XML格式数据
12-22
Java利用JDom来解析处理XML数据格式： 　需要的包jdom-1.1.2.jar 　1、将数据转换成XML格式的数据进行传递 Element rootList， firstList， secondItem， thirdItem; //根元素标签名 rootList = new Element...
jdom简介
deadeyegs的专栏
05-25 791
JDOM是一种使用XML的独特Java工具包，用于快速开发XML应用程序。它的设计包含Java语言的语法乃至语义。　　JDOM是两位著名的Java开发人员兼作者，BrettMclaughlin和JasonHunter的创作成果，2000年初在类似于Apache协议的许可下，JDOM作为一个开放源代码项目正式开始研发，JDOM作为一个开放源代码项目正式开始了。它已成长为包含来自广泛的Java开发人员
java中JDOM的基本使用方法
DN金猿的博客
07-27 1814
maven导入JDOM的依赖包: <dependency> <groupId>org.jdom</groupId> <artifactId>jdom</artifactId> <version>2.0.2</version> </dependency> 创建xml文档 //创建根节点 Element dataConfig = new Element("data-config");
java中XML文件的读写操作详解
qq_37481306的博客
10-15 2422
XML文件的读写 XML文件的读写我们需要用到一个第三方写的jar包——“dom4j-2.1.1.jar”，一会儿用到的包都需要从这个jar包里面导，下面是这个jar包的百度网盘链接 链接: https://pan.baidu.com/s/1YHKAe1MpC44CCzJ2LH9R-w 提取码: n7su XML文件的读取（需要自己创建XML文件） 1、导入dom4j-2.1.1.jar 1、如上图，在工程文件夹下面创建一个名为lib的文件夹，然后把dom4j-2.1.1.jar包放到里面 2、现在的ja
java中xml修改_java操作xml增删改查
weixin_39542477的博客
02-25 712
1：DOM4J性能最好，连Sun的JAXM也在用DOM4J.目前许多开源项目中大量采用DOM4J，例如大名鼎鼎的Hibernate也用DOM4J来读取XML配置文件。如果不考虑可移植性，那就采用DOM4J.2：JDOM 和DOM在性能测试时表现不佳，在测试10M文档时内存溢出。在小文档情况下还值得考虑使用DOM和JDOM.虽然JDOM的开发者已经说明他们期望在正式发行版前专注性能问题，但是从性能观...
Java JDOM生成和解析XML
p812438109的专栏
08-18 1万+
JDOM 使用：需要下载jdom对应的jar引入 场景：需要知道整个文档结构是，比dom性能好 优点：解析的树形结构操作比较灵活，比较简便 JDOM常用类 Document：表示整个xml文档，是一个树形结构 Eelment：表示一个xml的元素，提供方法操作其子元素，它的文本，属性和名称空间 Attribute：表示元素的属性 Text：表示xml文本信息 JDOM生成xml ...
getText().trim()方法
热门推荐
qq_42305089的博客
05-31 1万+
getText().trim()的作用是在获得的文本中除去空格.
XML教程
wenxiaoba的博客
04-06 351
XML简单介绍 XML文档内容由一系列标签元素组成 语法： 属性值用双引号包裹 一个元素可以有多个属性 属性值中不能直接包含<、“、&（不建议：‘、>） 示例： <元素名 属性名=“属性值”>元素内容</元素名> 转义符列表 XML解析 DOM：文档对象模型(Document Object Model)，DOM把XML文档映射成一个倒挂的树。具体理...
java jdom 类_JDOM常用类介绍及示例代码
weixin_42361622的博客
02-13 253
JDOM因其简洁易用易懂的API而被广泛的使用。JDOM常用的核心类及它们间的关系如下图所示：Document代表了文档对象，抽象类Content表示文档中的内容元素，各种内容组成了文档对象。常用的内容元素有xml元素Element、xml注释Comment、文本Text。下面以如下片段来说明各类的含义。徐辛波developer1502935722702985457683上述文档用Document...
XML第十九讲：JDOM 实现XML的解析
AHuier_Techblog ：如果我不在写代码，你就 @me
04-01 1485
上一讲我们讲解了JDOM 的一些理论上的内容：JDOM深入详解，现在我们来具体实现一下JDOM是如何解析XML的。 1. 在 JDOM开源的包，可以在 http://www.jdom.org/  中进行下载 2. 将JDOM包 jdom.jar 导入到Eclipse工程中 3.使用JDOM来解析XML过程如下所示： 1)使用JDOM将在内存中构造好的XML结构写到硬
java读取xml 通过jdom
04-03
JDOM是一个用于Java平台的XML处理库。它提供了一种简单的方式来读取、创建和操作XML文档。以下是使用JDOM读取XML的示例代码： ```java import org.jdom2.Document; import org.jdom2.Element; import org.jdom2....

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值