JAVA XML

本文轉載自查看原文 2017-05-19 21:31 5963

JAVA XML

DOM

優缺點：實現 W3C 標准，有多種編程語言支持這種解析方式，並且這種方法本身操作上簡單快捷，十分易於初學者掌握。其處理方式是將 XML 整個作為類似樹結構的方式讀入內存中以便操作及解析，因此支持應用程序對 XML 數據的內容和結構進行修改，但是同時由於其需要在處理開始時將整個 XML 文件讀入到內存中去進行分析，因此其在解析大數據量的 XML 文件時會遇到類似於內存泄露以及程序崩潰的風險，請對這點多加注意。

適用范圍：小型 XML 文件解析、需要全解析或者大部分解析 XML、需要修改 XML 樹內容以生成自己的對象模型

SAX

SAX 從根本上解決了 DOM 在解析 XML 文檔時產生的占用大量資源的問題。其實現是通過類似於流解析的技術，通讀整個 XML 文檔樹，通過事件處理器來響應程序員對於 XML 數據解析的需求。由於其不需要將整個 XML 文檔讀入內存當中，它對系統資源的節省是十分顯而易見的，它在一些需要處理大型 XML 文檔以及性能要求較高的場合有起了十分重要的作用。支持 XPath 查詢的 SAX 使得開發人員更加靈活，處理起 XML 來更加的得心應手。但是同時，其仍然有一些不足之處也困擾廣大的開發人員：首先是它十分復雜的 API 接口令人望而生畏，其次由於其是屬於類似流解析的文件掃描方式，因此不支持應用程序對於 XML 樹內容結構等的修改，可能會有不便之處。

適用范圍：大型 XML 文件解析、只需要部分解析或者只想取得部分 XML 樹內容、有 XPath 查詢需求、有自己生成特定 XML 樹對象模型的需求.

DOM 解析 XML

Java 中的 DOM 接口簡介： JDK 中的 DOM API 遵循 W3C DOM 規范，其中 org.w3c.dom 包提供了 Document、DocumentType、Node、NodeList、Element 等接口，這些接口均是訪問 DOM 文檔所必須的。我們可以利用這些接口創建、遍歷、修改 DOM 文檔。

javax.xml.parsers 包中的 DoumentBuilder 和 DocumentBuilderFactory 用於解析 XML 文檔生成對應的 DOM Document 對象。

javax.xml.transform.dom 和 javax.xml.transform.stream 包中 DOMSource 類和 StreamSource 類，用於將更新后的 DOM 文檔寫入 XML 文件.

DOMParser 的 Parse() 方法負責解析 XML 文件並生成對應的 DOM Document 對象。其中 DocumentBuilderFactory 用於生成 DOM 文檔解析器以便解析 XML 文檔。在獲取了 XML 文件對應的 Document 對象之后，我們可以調用一系列的 API 方便的對文檔對象模型中的元素進行訪問和處理。需要注意的是調用 Element 對象的 getChildNodes() 方法時將返回其下所有的子節點，其中包括空白節點，因此需要在處理子 Element 之前對節點類型加以判斷。

可以看出 DOM 解析 XML 易於開發，只需要通過解析器建立起 XML 對應的 DOM 樹型結構后便可以方便的使用 API 對節點進行訪問和處理，支持節點的刪除和修改等。但是 DOM 解析 XML 文件時會將整個 XML 文件的內容解析成樹型結構存放在內存中，因此不適合用 DOM 解析很大的 XML 文件。

SAX 解析 XML

與 DOM 建立樹形結構的方式不同，SAX 采用事件模型來解析 XML 文檔，是解析 XML 文檔的一種更快速、更輕量的方法。利用 SAX 可以對 XML 文檔進行有選擇的解析和訪問，而不必像 DOM 那樣加載整個文檔，因此它對內存的要求較低。但 SAX 對 XML 文檔的解析為一次性讀取，不創建任何文檔對象，很難同時訪問文檔中的多處數據。

SAX 解析器接口和事件處理器接口定義在 org.xml.sax 包中。主要的接口包括 ContentHandler、DTDHandler、EntityResolver 及 ErrorHandler。其中 ContentHandler 是主要的處理器接口，用於處理基本的文檔解析事件；DTDHandler 和 EntityResolver 接口用於處理與 DTD 驗證和實體解析相關的事件； ErrorHandler 是基本的錯誤處理接口。DefaultHandler 類實現了上述四個事件處理接口。上面的例子中 BookHandler 繼承了 DefaultHandler 類，並覆蓋了其中的五個回調方法 startDocument()、endDocument()、startElement()、endElement() 及 characters() 以加入自己的事件處理邏輯。

其中 DOM 易於上手，程序易於理解，但缺點在於占用內存大，不適合於解析較大的 XML 文件； SAX 基於事件模型占用系統資源少，能夠勝任較大的 XML 文件解析，但解析過程較為繁瑣查找元素不方便.

四種生成和解析XML文檔的方法詳解（介紹+優缺點比較+示例）

眾所周知，現在解析XML的方法越來越多，但主流的方法也就四種，即：DOM、SAX、JDOM和DOM4J

下面首先給出這四種方法的jar包下載地址

DOM：在現在的Java JDK里都自帶了，在xml-apis.jar包里

SAX：http://sourceforge.net/projects/sax/

JDOM：http://jdom.org/downloads/index.html

DOM4J：http://sourceforge.net/projects/dom4j/

一、介紹及優缺點分析

1. DOM（Document Object Model)

DOM是用與平台和語言無關的方式表示XML文檔的官方W3C標准。DOM是以層次結構組織的節點或信息片斷的集合。這個層次結構允許開發人員在樹中尋找特定信息。分析該結構通常需要加載整個文檔和構造層次結構，然后才能做任何工作。由於它是基於信息層次的，因而DOM被認為是基於樹或基於對象的。

【優點】
      ①允許應用程序對數據和結構做出更改。
      ②訪問是雙向的，可以在任何時候在樹中上下導航，獲取和操作任意部分的數據。
【缺點】
      ①通常需要加載整個XML文檔來構造層次結構，消耗資源大。

2. SAX（Simple API for XML)

SAX處理的優點非常類似於流媒體的優點。分析能夠立即開始，而不是等待所有的數據被處理。而且，由於應用程序只是在讀取數據時檢查數據，因此不需要將數據存儲在內存中。這對於大型文檔來說是個巨大的優點。事實上，應用程序甚至不必解析整個文檔；它可以在某個條件得到滿足時停止解析。一般來說，SAX還比它的替代者DOM快許多。

選擇DOM還是選擇SAX？對於需要自己編寫代碼來處理XML文檔的開發人員來說，選擇DOM還是SAX解析模型是一個非常重要的設計決策。 DOM采用建立樹形結構的方式訪問XML文檔，而SAX采用的是事件模型。

DOM解析器把XML文檔轉化為一個包含其內容的樹，並可以對樹進行遍歷。用DOM解析模型的優點是編程容易，開發人員只需要調用建樹的指令，然后利用navigation APIs訪問所需的樹節點來完成任務。可以很容易的添加和修改樹中的元素。然而由於使用DOM解析器的時候需要處理整個XML文檔，所以對性能和內存的要求比較高，尤其是遇到很大的XML文件的時候。由於它的遍歷能力，DOM解析器常用於XML文檔需要頻繁的改變的服務中。

SAX解析器采用了基於事件的模型，它在解析XML文檔的時候可以觸發一系列的事件，當發現給定的tag的時候，它可以激活一個回調方法，告訴該方法制定的標簽已經找到。SAX對內存的要求通常會比較低，因為它讓開發人員自己來決定所要處理的tag.特別是當開發人員只需要處理文檔中所包含的部分數據時，SAX這種擴展能力得到了更好的體現。但用SAX解析器的時候編碼工作會比較困難，而且很難同時訪問同一個文檔中的多處不同數據。

【優勢】
   ①不需要等待所有數據都被處理，分析就能立即開始。
   ②只在讀取數據時檢查數據，不需要保存在內存中。
     ③可以在某個條件得到滿足時停止解析，不必解析整個文檔。
   ④效率和性能較高，能解析大於系統內存的文檔。

【缺點】
     ①需要應用程序自己負責TAG的處理邏輯（例如維護父/子關系等），文檔越復雜程序就越復雜。
     ②單向導航，無法定位文檔層次，很難同時訪問同一文檔的不同部分數據，不支持XPath。

3. JDOM(Java-based Document Object Model)

JDOM的目的是成為Java特定文檔模型，它簡化與XML的交互並且比使用DOM實現更快。由於是第一個Java特定模型，JDOM一直得到大力推廣和促進。正在考慮通過“Java規范請求JSR-102”將它最終用作“Java標准擴展”。從2000年初就已經開始了JDOM開發。

JDOM與DOM主要有兩方面不同。首先，JDOM僅使用具體類而不使用接口。這在某些方面簡化了API，但是也限制了靈活性。第二，API大量使用了Collections類，簡化了那些已經熟悉這些類的Java開發者的使用。

JDOM文檔聲明其目的是“使用20%（或更少）的精力解決80%（或更多）Java/XML問題”（根據學習曲線假定為20%）。JDOM對於大多數Java/XML應用程序來說當然是有用的，並且大多數開發者發現API比DOM容易理解得多。JDOM還包括對程序行為的相當廣泛檢查以防止用戶做任何在XML中無意義的事。然而，它仍需要您充分理解XML以便做一些超出基本的工作（或者甚至理解某些情況下的錯誤）。這也許是比學習DOM或JDOM接口都更有意義的工作。

JDOM自身不包含解析器。它通常使用SAX2解析器來解析和驗證輸入XML文檔（盡管它還可以將以前構造的DOM表示作為輸入）。它包含一些轉換器以將JDOM表示輸出成SAX2事件流、DOM模型或XML文本文檔。JDOM是在Apache許可證變體下發布的開放源碼。

【優點】
①使用具體類而不是接口，簡化了DOM的API。
②大量使用了Java集合類，方便了Java開發人員。

【缺點】
①沒有較好的靈活性。
②性能較差。

4. DOM4J(Document Object Model for Java)
雖然DOM4J代表了完全獨立的開發結果，但最初，它是JDOM的一種智能分支。它合並了許多超出基本XML文檔表示的功能，包括集成的XPath支持、XML Schema支持以及用於大文檔或流化文檔的基於事件的處理。它還提供了構建文檔表示的選項，它通過DOM4J API和標准DOM接口具有並行訪問功能。從2000下半年開始，它就一直處於開發之中。

為支持所有這些功能，DOM4J使用接口和抽象基本類方法。DOM4J大量使用了API中的Collections類，但是在許多情況下，它還提供一些替代方法以允許更好的性能或更直接的編碼方法。直接好處是，雖然DOM4J付出了更復雜的API的代價，但是它提供了比JDOM大得多的靈活性。

在添加靈活性、XPath集成和對大文檔處理的目標時，DOM4J的目標與JDOM是一樣的：針對Java開發者的易用性和直觀操作。它還致力於成為比JDOM更完整的解決方案，實現在本質上處理所有Java/XML問題的目標。在完成該目標時，它比JDOM更少強調防止不正確的應用程序行為。

DOM4J是一個非常非常優秀的Java XML API，具有性能優異、功能強大和極端易用使用的特點，同時它也是一個開放源代碼的軟件。如今你可以看到越來越多的Java軟件都在使用DOM4J來讀寫XML，特別值得一提的是連Sun的JAXM也在用DOM4J.

【優點】
     ①大量使用了Java集合類，方便Java開發人員，同時提供一些提高性能的替代方法。
   ②支持XPath。
   ③有很好的性能。

【缺點】
①大量使用了接口，API較為復雜。

二、比較

1. DOM4J性能最好，連Sun的JAXM也在用DOM4J。目前許多開源項目中大量采用DOM4J，例如大名鼎鼎的Hibernate也用DOM4J來讀取XML配置文件。如果不考慮可移植性，那就采用DOM4J.

2. JDOM和DOM在性能測試時表現不佳，在測試10M文檔時內存溢出，但可移植。在小文檔情況下還值得考慮使用DOM和JDOM.雖然JDOM的開發者已經說明他們期望在正式發行版前專注性能問題，但是從性能觀點來看，它確實沒有值得推薦之處。另外，DOM仍是一個非常好的選擇。DOM實現廣泛應用於多種編程語言。它還是許多其它與XML相關的標准的基礎，因為它正式獲得W3C推薦（與基於非標准的Java模型相對），所以在某些類型的項目中可能也需要它（如在JavaScript中使用DOM）。

3. SAX表現較好，這要依賴於它特定的解析方式－事件驅動。一個SAX檢測即將到來的XML流，但並沒有載入到內存（當然當XML流被讀入時，會有部分文檔暫時隱藏在內存中）。

我的看法：如果XML文檔較大且不考慮移植性問題建議采用DOM4J；如果XML文檔較小則建議采用JDOM；如果需要及時處理而不需要保存數據則考慮SAX。但無論如何，還是那句話：適合自己的才是最好的，如果時間允許，建議大家講這四種方法都嘗試一遍然后選擇一種適合自己的即可。

三、示例

為了節約篇幅，這里暫時不給出這四種建立XML文檔的方法與差異，僅給出解析XML文檔的代碼，如果需要完整工程（建立XML文檔+解析XML+測試比較），可去我的CSDN下載。

這里以下面的XML內容為例進行解析：

<?xml version="1.0" encoding="UTF-8"?> <users> <user id="0"> <name>Alexia</name> <age>23</age> <sex>Female</sex> </user> <user id="1"> <name>Edward</name> <age>24</age> <sex>Male</sex> </user> <user id="2"> <name>wjm</name> <age>23</age> <sex>Female</sex> </user> <user id="3"> <name>wh</name> <age>24</age> <sex>Male</sex> </user> </users>

首先定義XML文檔解析的接口：

 1 /**  2  * @author Alexia  3  *  4  * 定義XML文檔解析的接口  5 */  6 public interface XmlDocument {  7  8 /**  9  * 解析XML文檔 10  * 11  * @param fileName 12  * 文件全路徑名稱 13 */ 14 public void parserXml(String fileName); 15 }

1. DOM示例

package com.xml; import java.io.FileNotFoundException; import java.io.FileOutputStream; import java.io.IOException; import java.io.PrintWriter; import javax.xml.parsers.DocumentBuilder; import javax.xml.parsers.DocumentBuilderFactory; import javax.xml.parsers.ParserConfigurationException; import javax.xml.transform.OutputKeys; import javax.xml.transform.Transformer; import javax.xml.transform.TransformerConfigurationException; import javax.xml.transform.TransformerException; import javax.xml.transform.TransformerFactory; import javax.xml.transform.dom.DOMSource; import javax.xml.transform.stream.StreamResult; import org.w3c.dom.Document; import org.w3c.dom.Element; import org.w3c.dom.Node; import org.w3c.dom.NodeList; import org.xml.sax.SAXException; /** * @author Alexia * * DOM 解析XML文檔 */ public class DomDemo implements XmlDocument { private Document document; public void parserXml(String fileName) { try { DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance(); DocumentBuilder db = dbf.newDocumentBuilder(); Document document = db.parse(fileName); NodeList users = document.getChildNodes(); for (int i = 0; i < users.getLength(); i++) { Node user = users.item(i); NodeList userInfo = user.getChildNodes(); for (int j = 0; j < userInfo.getLength(); j++) { Node node = userInfo.item(j); NodeList userMeta = node.getChildNodes(); for (int k = 0; k < userMeta.getLength(); k++) { if(userMeta.item(k).getNodeName() != "#text") System.out.println(userMeta.item(k).getNodeName() + ":" + userMeta.item(k).getTextContent()); } System.out.println(); } } } catch (FileNotFoundException e) { e.printStackTrace(); } catch (ParserConfigurationException e) { e.printStackTrace(); } catch (SAXException e) { e.printStackTrace(); } catch (IOException e) { e.printStackTrace(); } } }

2. SAX示例

package com.xml; 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.io.StringWriter; import javax.xml.parsers.ParserConfigurationException; import javax.xml.parsers.SAXParser; import javax.xml.parsers.SAXParserFactory; import javax.xml.transform.OutputKeys; import javax.xml.transform.Result; import javax.xml.transform.Transformer; import javax.xml.transform.TransformerConfigurationException; import javax.xml.transform.sax.SAXTransformerFactory; import javax.xml.transform.sax.TransformerHandler; import javax.xml.transform.stream.StreamResult; import org.xml.sax.Attributes; import org.xml.sax.SAXException; import org.xml.sax.helpers.AttributesImpl; import org.xml.sax.helpers.DefaultHandler; /** * @author Alexia * * SAX 解析XML文檔 */ public class SaxDemo implements XmlDocument { public void parserXml(String fileName) { SAXParserFactory saxfac = SAXParserFactory.newInstance(); try { SAXParser saxparser = saxfac.newSAXParser(); InputStream is = new FileInputStream(fileName); saxparser.parse(is, new MySAXHandler()); } catch (ParserConfigurationException e) { e.printStackTrace(); } catch (SAXException e) { e.printStackTrace(); } catch (FileNotFoundException e) { e.printStackTrace(); } catch (IOException e) { e.printStackTrace(); } } } class MySAXHandler extends DefaultHandler { boolean hasAttribute = false; Attributes attributes = null; public void startDocument() throws SAXException { // System.out.println("文檔開始打印了");  } public void endDocument() throws SAXException { // System.out.println("文檔打印結束了");  } public void startElement(String uri, String localName, String qName, Attributes attributes) throws SAXException { if (qName.equals("users")) { return; } if (qName.equals("user")) { return; } if (attributes.getLength() > 0) { this.attributes = attributes; this.hasAttribute = true; } } public void endElement(String uri, String localName, String qName) throws SAXException { if (hasAttribute && (attributes != null)) { for (int i = 0; i < attributes.getLength(); i++) { System.out.print(attributes.getQName(0) + ":" + attributes.getValue(0)); } } } public void characters(char[] ch, int start, int length) throws SAXException { System.out.print(new String(ch, start, length)); } }

3. JDOM示例

package com.xml; import java.io.FileNotFoundException; import java.io.FileOutputStream; import java.io.IOException; import java.util.List; import org.jdom2.Document; import org.jdom2.Element; import org.jdom2.JDOMException; import org.jdom2.input.SAXBuilder; import org.jdom2.output.XMLOutputter; /** * @author Alexia * * JDOM 解析XML文檔 * */ public class JDomDemo implements XmlDocument { public void parserXml(String fileName) { SAXBuilder builder = new SAXBuilder(); try { Document document = builder.build(fileName); Element users = document.getRootElement(); List userList = users.getChildren("user"); for (int i = 0; i < userList.size(); i++) { Element user = (Element) userList.get(i); List userInfo = user.getChildren(); for (int j = 0; j < userInfo.size(); j++) { System.out.println(((Element) userInfo.get(j)).getName() + ":" + ((Element) userInfo.get(j)).getValue()); } System.out.println(); } } catch (JDOMException e) { e.printStackTrace(); } catch (IOException e) { e.printStackTrace(); } } }

4. DOM4J示例

package com.xml; import java.io.File; import java.io.FileWriter; import java.io.IOException; import java.io.Writer; import java.util.Iterator; import org.dom4j.Document; import org.dom4j.DocumentException; import org.dom4j.DocumentHelper; import org.dom4j.Element; import org.dom4j.io.SAXReader; import org.dom4j.io.XMLWriter; /** * @author Alexia * * Dom4j 解析XML文檔 */ public class Dom4jDemo implements XmlDocument { public void parserXml(String fileName) { File inputXml = new File(fileName); SAXReader saxReader = new SAXReader(); try { Document document = saxReader.read(inputXml); Element users = document.getRootElement(); for (Iterator i = users.elementIterator(); i.hasNext();) { Element user = (Element) i.next(); for (Iterator j = user.elementIterator(); j.hasNext();) { Element node = (Element) j.next(); System.out.println(node.getName() + ":" + node.getText()); } System.out.println(); } } catch (DocumentException e) { System.out.println(e.getMessage()); } } }

一、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分析器還是有很廣泛的使用價值的。

　　　　優點：

　　　　　　1、形成了樹結構，有助於更好的理解、掌握，且代碼容易編寫。

　　　　　　2、解析過程中，樹結構保存在內存中，方便修改。

　　　　缺點：

　　　　　　1、由於文件是一次性讀取，所以對內存的耗費比較大。

　　　　　　2、如果XML文件比較大，容易影響解析性能且可能會造成內存溢出.

二、SAX解析

　　SAX的全稱是Simple APIs for XML，也即XML簡單應用程序接口。與DOM不同，SAX提供的訪問模式是一種順序模式，這是一種快速讀寫XML數據的方式。當使用SAX分析器對XML文檔進行分析時，會觸發一系列事件，並激活相應的事件處理函數，應用程序通過這些事件處理函數實現對XML文檔的訪問，因而SAX接口也被稱作事件驅動接口。

　　　　優點：

　　　　　　1、采用事件驅動模式，對內存耗費比較小。

　　　　　　2、適用於只處理XML文件中的數據時。

　　　　缺點：

　　　　　　1、編碼比較麻煩。

　　　　　　2、很難同時訪問XML文件中的多處不同數據。

三、JDOM解析

　　　　特征：

　　　　　　1、僅使用具體類，而不使用接口。

　　　　　　2、API大量使用了Collections類.

4、DOM4J解析

　　　特征：

　　　　　　1、JDOM的一種智能分支，它合並了許多超出基本XML文檔表示的功能。

　　　　　　2、它使用接口和抽象基本類方法。

　　　　　　3、具有性能優異、靈活性好、功能強大和極端易用的特點。

　　　　　　4、是一個開放源碼的文件.

Final：比較總結

　　DOM4J性能最好，連Sun的JAXM也在用DOM4J。目前許多開源項目中大量采用DOM4J，例如大名鼎鼎的hibernate也用DOM4J來讀取XML配置文件。如果不考慮可移植性，那就采用DOM4J。
JDOM和DOM在性能測試時表現不佳，在測試10M文檔時內存溢出。在小文檔情況下還值得考慮使用DOM和JDOM。雖然JDOM的開發者已經說明他們期望在正式發行版前專注性能問題，但是從性能觀點來看，它確實沒有值得推薦之處。另外，DOM仍是一個非常好的選擇。DOM實現廣泛應用於多種編程語言。它還是許多其它與XML相關的標准的基礎，因為它正式獲得W3C推薦（與基於非標准的Java模型相對），所以在某些類型的項目中可能也需要它（如在JavaScript中使用DOM）。
SAX表現較好，這要依賴於它特定的解析方式－事件驅動。一個SAX檢測即將到來的XML流，但並沒有載入到內存（當然當XML流被讀入時，會有部分文檔暫時隱藏在內存中）。

什么是淺復制

淺拷貝是按位拷貝對象，它會創建一個新對象，這個對象有着原始對象屬性值的一份精確拷貝。如果屬性是基本類型，拷貝的就是基本類型的值；如果屬性是內存地址（引用類型），拷貝的就是內存地址，因此如果其中一個對象改變了這個地址，就會影響到另一個對象。

網上資料說：

若不對clone()方法進行改寫，則調用此方法得到的對象即為淺拷貝，下面我們着重談一下深拷貝。

經驗證，引用類型的類是否重寫clone()都不影響淺復制。這個不是關鍵點。以下是完整代碼，感興趣的同學可以驗證。

深復制

什么是深復制

深拷貝會拷貝所有的屬性,並拷貝屬性指向的動態分配的內存。當對象和它所引用的對象一起拷貝時即發生深拷貝。深拷貝相比於淺拷貝速度較慢並且花銷較大。

結論

深復制是完全復制一個對象，類似新建一個對象！淺復制只是復制引用類型的內存地址。
淺復制、深復制的主要差別在引用類型的復制上。
基本數據類型在深復制、淺復制中直接復制了值。

擴展

序列化也可以實現深復制，是通過IO流實現的，開銷比較大。有大神寫了個類直接繼承就可以實現深復制。這種方法可以提高代碼的復用。

詳解Java解析XML的方法

XML現在已經成為一種通用的數據交換格式,平台的無關性使得很多場合都需要用到XML。本文將詳細介紹用Java解析XML的四種方法。

XML現在已經成為一種通用的數據交換格式,它的平台無關性,語言無關性,系統無關性,給數據集成與交互帶來了極大的方便。對於XML本身的語法知識與技術細節,需要閱讀相關的技術文獻,這里面包括的內容有DOM(Document Object Model),DTD(Document Type Definition),SAX(Simple API for XML),XSD(Xml Schema Definition),XSLT(Extensible Stylesheet Language Transformations),具體可參閱w3c官方網站文檔http://www.w3.org獲取更多信息。

XML在不同的語言里解析方式都是一樣的,只不過實現的語法不同而已。基本的解析方式有兩種,一種叫SAX，另一種叫DOM。SAX是基於事件流的解析,DOM是基於XML文檔樹結構的解析。假設我們XML的內容和結構如下:

<?xml version="1.0" encoding="UTF-8"?> 
<employees> 
<employee> 
<name>ddviplinux</name> 
<sex>m</sex> 
<age>30</age> 
</employee> 
</employees>

本文使用JAVA語言來實現DOM與SAX的XML文檔生成與解析。
首先定義一個操作XML文檔的接口XmlDocument 它定義了XML文檔的建立與解析的接口。

package com.alisoft.facepay.framework.bean; 
/** 
* 
* @author hongliang.dinghl 
* 定義XML文檔建立與解析的接口 
*/ 
public interface XmlDocument { 
/** 
* 建立XML文檔 
* @param fileName 文件全路徑名稱 
*/ 
public void createXml(String fileName); 
/** 
* 解析XML文檔 
* @param fileName 文件全路徑名稱 
*/ 
public void parserXml(String fileName); 
}

1.DOM生成和解析XML文檔

為 XML 文檔的已解析版本定義了一組接口。解析器讀入整個文檔，然后構建一個駐留內存的樹結構，然后代碼就可以使用 DOM 接口來操作這個樹結構。優點：整個文檔樹在內存中，便於操作；支持刪除、修改、重新排列等多種功能；缺點：將整個文檔調入內存（包括無用的節點），浪費時間和空間；使用場合：一旦解析了文檔還需多次訪問這些數據；硬件資源充足（內存、CPU）。

package com.alisoft.facepay.framework.bean; 
import java.io.FileInputStream; 
import java.io.FileNotFoundException; 
import java.io.FileOutputStream; 
import java.io.IOException; 
import java.io.InputStream; 
import java.io.PrintWriter; 
import javax.xml.parsers.DocumentBuilder; 
import javax.xml.parsers.DocumentBuilderFactory; 
import javax.xml.parsers.ParserConfigurationException; 
import javax.xml.transform.OutputKeys; 
import javax.xml.transform.Transformer; 
import javax.xml.transform.TransformerConfigurationException; 
import javax.xml.transform.TransformerException; 
import javax.xml.transform.TransformerFactory; 
import javax.xml.transform.dom.DOMSource; 
import javax.xml.transform.stream.StreamResult; 
import org.w3c.dom.Document; 
import org.w3c.dom.Element; 
import org.w3c.dom.Node; 
import org.w3c.dom.NodeList; 
import org.xml.sax.SAXException; 
/** 
* 
* @author hongliang.dinghl 
* DOM生成與解析XML文檔 
*/ 
public class DomDemo implements XmlDocument { 
private Document document; 
private String fileName; 
public void init() { 
try { 
DocumentBuilderFactory factory = DocumentBuilderFactory 
.newInstance(); 
DocumentBuilder builder = factory.newDocumentBuilder(); 
this.document = builder.newDocument(); 
} catch (ParserConfigurationException e) { 
System.out.println(e.getMessage()); 
} 
} 
public void createXml(String fileName) { 
Element root = this.document.createElement("employees"); 
this.document.appendChild(root); 
Element employee = this.document.createElement("employee"); 
Element name = this.document.createElement("name"); 
name.appendChild(this.document.createTextNode("丁宏亮")); 
employee.appendChild(name); 
Element sex = this.document.createElement("sex"); 
sex.appendChild(this.document.createTextNode("m")); 
employee.appendChild(sex); 
Element age = this.document.createElement("age"); 
age.appendChild(this.document.createTextNode("30")); 
employee.appendChild(age); 
root.appendChild(employee); 
TransformerFactory tf = TransformerFactory.newInstance(); 
try { 
Transformer transformer = tf.newTransformer(); 
DOMSource source = new DOMSource(document); 
transformer.setOutputProperty(OutputKeys.ENCODING, "gb2312"); 
transformer.setOutputProperty(OutputKeys.INDENT, "yes"); 
PrintWriter pw = new PrintWriter(new FileOutputStream(fileName)); 
StreamResult result = new StreamResult(pw); 
transformer.transform(source, result); 
System.out.println("生成XML文件成功!"); 
} catch (TransformerConfigurationException e) { 
System.out.println(e.getMessage()); 
} catch (IllegalArgumentException e) { 
System.out.println(e.getMessage()); 
} catch (FileNotFoundException e) { 
System.out.println(e.getMessage()); 
} catch (TransformerException e) { 
System.out.println(e.getMessage()); 
} 
} 
public void parserXml(String fileName) { 
try { 
DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance(); 
DocumentBuilder db = dbf.newDocumentBuilder(); 
Document document = db.parse(fileName); 
NodeList employees = document.getChildNodes(); 
for (int i = 0; i < employees.getLength(); i++) { 
Node employee = employees.item(i); 
NodeList employeeInfo = employee.getChildNodes(); 
for (int j = 0; j < employeeInfo.getLength(); j++) { 
Node node = employeeInfo.item(j); 
NodeList employeeMeta = node.getChildNodes(); 
for (int k = 0; k < employeeMeta.getLength(); k++) { 
System.out.println(employeeMeta.item(k).getNodeName() 
+ ":" + employeeMeta.item(k).getTextContent()); 
} 
} 
} 
System.out.println("解析完畢"); 
} catch (FileNotFoundException e) { 
System.out.println(e.getMessage()); 
} catch (ParserConfigurationException e) { 
System.out.println(e.getMessage()); 
} catch (SAXException e) { 
System.out.println(e.getMessage()); 
} catch (IOException e) { 
System.out.println(e.getMessage()); 
} 
} 
}

2.SAX生成和解析XML文檔

為解決DOM的問題，出現了SAX。SAX ，事件驅動。當解析器發現元素開始、元素結束、文本、文檔的開始或結束等時，發送事件，程序員編寫響應這些事件的代碼，保存數據。優點：不用事先調入整個文檔，占用資源少；SAX解析器代碼比DOM解析器代碼小，適於Applet，下載。缺點：不是持久的；事件過后，若沒保存數據，那么數據就丟了；無狀態性；從事件中只能得到文本，但不知該文本屬於哪個元素；使用場合：Applet;只需XML文檔的少量內容，很少回頭訪問；機器內存少；

Java代碼

package com.alisoft.facepay.framework.bean;   
import java.io.FileInputStream;   
import java.io.FileNotFoundException;   
import java.io.IOException;   
import java.io.InputStream;   

import javax.xml.parsers.ParserConfigurationException;   
import javax.xml.parsers.SAXParser;   
import javax.xml.parsers.SAXParserFactory;   

import org.xml.sax.Attributes;   
import org.xml.sax.SAXException;   
import org.xml.sax.helpers.DefaultHandler;   
/**  
*   
* @author hongliang.dinghl  
* SAX文檔解析  
*/  
public class SaxDemo implements XmlDocument {   

public void createXml(String fileName) {   
System.out.println("<<"+filename+">>");   
}   

public void parserXml(String fileName) {   
SAXParserFactory saxfac = SAXParserFactory.newInstance();   

try {   

SAXParser saxparser = saxfac.newSAXParser();   

InputStream is = new FileInputStream(fileName);   

saxparser.parse(is, new MySAXHandler());   

} catch (ParserConfigurationException e) {   

e.printStackTrace();   

} catch (SAXException e) {   

e.printStackTrace();   

} catch (FileNotFoundException e) {   

e.printStackTrace();   

} catch (IOException e) {   

e.printStackTrace();   

}   

}   

}   

class MySAXHandler extends DefaultHandler {   

boolean hasAttribute = false;   

Attributes attributes = null;   

public void startDocument() throws SAXException {   

System.out.println("文檔開始打印了");   

}   

public void endDocument() throws SAXException {   

System.out.println("文檔打印結束了");   

}   

public void startElement(String uri, String localName, String qName,   

Attributes attributes) throws SAXException {   

if (qName.equals("employees")) {   

return;   

}   

if (qName.equals("employee")) {   

System.out.println(qName);   

}   

if (attributes.getLength() > 0) {   

this.attributes = attributes;   

this.hasAttribute = true;   

}   

}   

public void endElement(String uri, String localName, String qName)   

throws SAXException {   

if (hasAttribute && (attributes != null)) {   

for (int i = 0; i < attributes.getLength(); i++) {   

System.out.println(attributes.getQName(0)   
+ attributes.getValue(0));   

}   

}   

}   

public void characters(char[] ch, int start, int length)   

throws SAXException {   

System.out.println(new String(ch, start, length));   

}   

}  
package com.alisoft.facepay.framework.bean; 
import java.io.FileInputStream; 
import java.io.FileNotFoundException; 
import java.io.IOException; 
import java.io.InputStream; 
import javax.xml.parsers.ParserConfigurationException; 
import javax.xml.parsers.SAXParser; 
import javax.xml.parsers.SAXParserFactory; 
import org.xml.sax.Attributes; 
import org.xml.sax.SAXException; 
import org.xml.sax.helpers.DefaultHandler; 
/** 
* 
* @author hongliang.dinghl 
* SAX文檔解析 
*/ 
public class SaxDemo implements XmlDocument { 
public void createXml(String fileName) { 
System.out.println("<<"+filename+">>"); 
} 
public void parserXml(String fileName) { 
SAXParserFactory saxfac = SAXParserFactory.newInstance(); 
try { 
SAXParser saxparser = saxfac.newSAXParser(); 
InputStream is = new FileInputStream(fileName); 
saxparser.parse(is, new MySAXHandler()); 
} catch (ParserConfigurationException e) { 
e.printStackTrace(); 
} catch (SAXException e) { 
e.printStackTrace(); 
} catch (FileNotFoundException e) { 
e.printStackTrace(); 
} catch (IOException e) { 
e.printStackTrace(); 
} 
} 
} 
class MySAXHandler extends DefaultHandler { 
boolean hasAttribute = false; 
Attributes attributes = null; 
public void startDocument() throws SAXException { 
System.out.println("文檔開始打印了"); 
} 
public void endDocument() throws SAXException { 
System.out.println("文檔打印結束了"); 
} 
public void startElement(String uri, String localName, String qName, 
Attributes attributes) throws SAXException { 
if (qName.equals("employees")) { 
return; 
} 
if (qName.equals("employee")) { 
System.out.println(qName); 
} 
if (attributes.getLength() > 0) { 
this.attributes = attributes; 
this.hasAttribute = true; 
} 
} 
public void endElement(String uri, String localName, String qName) 
throws SAXException { 
if (hasAttribute && (attributes != null)) { 
for (int i = 0; i < attributes.getLength(); i++) { 
System.out.println(attributes.getQName(0) 
+ attributes.getValue(0)); 
} 
} 
} 
public void characters(char[] ch, int start, int length) 
throws SAXException { 
System.out.println(new String(ch, start, length)); 
} 
}

3.DOM4J生成和解析XML文檔

DOM4J 是一個非常非常優秀的Java XML API，具有性能優異、功能強大和極端易用使用的特點，同時它也是一個開放源代碼的軟件。如今你可以看到越來越多的 Java 軟件都在使用 DOM4J 來讀寫 XML，特別值得一提的是連 Sun 的 JAXM 也在用 DOM4J。

Java代碼

package com.alisoft.facepay.framework.bean;   
import java.io.File;   
import java.io.FileWriter;   
import java.io.IOException;   
import java.io.Writer;   
import java.util.Iterator;   

import org.dom4j.Document;   
import org.dom4j.DocumentException;   
import org.dom4j.DocumentHelper;   
import org.dom4j.Element;   
import org.dom4j.io.SAXReader;   
import org.dom4j.io.XMLWriter;   
/**  
*   
* @author hongliang.dinghl  
* Dom4j 生成XML文檔與解析XML文檔  
*/  
public class Dom4jDemo implements XmlDocument {   

public void createXml(String fileName) {   
Document document = DocumentHelper.createDocument();   
Element employees=document.addElement("employees");   
Element employee=employees.addElement("employee");   
Element name= employee.addElement("name");   
name.setText("ddvip");   
Element sex=employee.addElement("sex");   
sex.setText("m");   
Element age=employee.addElement("age");   
age.setText("29");   
try {   
Writer fileWriter=new FileWriter(fileName);   
XMLWriter xmlWriter=new XMLWriter(fileWriter);   
xmlWriter.write(document);   
xmlWriter.close();   
} catch (IOException e) {   

System.out.println(e.getMessage());   
}   


}   


public void parserXml(String fileName) {   
File inputXml=new File(fileName);   
SAXReader saxReader = new SAXReader();   
try {   
Document document = saxReader.read(inputXml);   
Element employees=document.getRootElement();   
for(Iterator i = employees.elementIterator(); i.hasNext();){   
Element employee = (Element) i.next();   
for(Iterator j = employee.elementIterator(); j.hasNext();){   
Element node=(Element) j.next();   
System.out.println(node.getName()+":"+node.getText());   
}   

}   
} catch (DocumentException e) {   
System.out.println(e.getMessage());   
}   
System.out.println("dom4j parserXml");   
}   
}

4.JDOM生成和解析XML

為減少DOM、SAX的編碼量，出現了JDOM；優點：20-80原則，極大減少了代碼量。使用場合：要實現的功能簡單，如解析、創建等，但在底層，JDOM還是使用SAX（最常用）、DOM、Xanan文檔。

package com.alisoft.facepay.framework.bean;   

import java.io.FileNotFoundException;   
import java.io.FileOutputStream;   
import java.io.IOException;   
import java.util.List;   

import org.jdom.Document;   
import org.jdom.Element;   
import org.jdom.JDOMException;   
import org.jdom.input.SAXBuilder;   
import org.jdom.output.XMLOutputter;   
/**  
*   
* @author hongliang.dinghl  
* JDOM 生成與解析XML文檔  
*   
*/  
public class JDomDemo implements XmlDocument {   

public void createXml(String fileName) {   
Document document;   
Element  root;   
root=new Element("employees");   
document=new Document(root);   
Element employee=new Element("employee");   
root.addContent(employee);   
Element name=new Element("name");   
name.setText("ddvip");   
employee.addContent(name);   
Element sex=new Element("sex");   
sex.setText("m");   
employee.addContent(sex);   
Element age=new Element("age");   
age.setText("23");   
employee.addContent(age);   
XMLOutputter XMLOut = new XMLOutputter();   
try {   
XMLOut.output(document, new FileOutputStream(fileName));   
} catch (FileNotFoundException e) {   
e.printStackTrace();   
} catch (IOException e) {   
e.printStackTrace();   
}   

}   

public void parserXml(String fileName) {   
SAXBuilder builder=new SAXBuilder(false);    
try {   
Document document=builder.build(fileName);   
Element employees=document.getRootElement();    
List employeeList=employees.getChildren("employee");   
for(int i=0;iElement employee=(Element)employeeList.get(i);   
List employeeInfo=employee.getChildren();   
for(int j=0;jSystem.out.println(((Element)employeeInfo.get(j)).getName()+":"+((Element)employeeInfo.get(j)).getValue());   

}   
}   
} catch (JDOMException e) {   

e.printStackTrace();   
} catch (IOException e) {   

e.printStackTrace();   
}    

}   
}

免責聲明！

本站轉載的文章為個人學習借鑒使用，本站對版權不負任何法律責任。如果侵犯了您的隱私權益，請聯系本站郵箱yoyou2525@163.com刪除。

猜您在找 Java的XML解析 java對象轉為xml Java對象和XML轉換 java對xml文件的操作 java解析XML java操作XML文件 Java解析和生成XML JAVA對XML文件的讀寫 Xml轉換Java Bean Java xml object 互轉

JAVA XML

DOM

適用范圍：小型 XML 文件解析、需要全解析或者大部分解析 XML、需要修改 XML 樹內容以生成自己的對象模型

SAX

適用范圍：大型 XML 文件解析、只需要部分解析或者只想取得部分 XML 樹內容、有 XPath 查詢需求、有自己生成特定 XML 樹對象模型的需求.

DOM 解析 XML

Java 中的 DOM 接口簡介： JDK 中的 DOM API 遵循 W3C DOM 規范，其中 org.w3c.dom 包提供了 Document、DocumentType、Node、NodeList、Element 等接口， 這些接口均是訪問 DOM 文檔所必須的。我們可以利用這些接口創建、遍歷、修改 DOM 文檔。

javax.xml.parsers 包中的 DoumentBuilder 和 DocumentBuilderFactory 用於解析 XML 文檔生成對應的 DOM Document 對象。

javax.xml.transform.dom 和 javax.xml.transform.stream 包中 DOMSource 類和 StreamSource 類，用於將更新后的 DOM 文檔寫入 XML 文件.

SAX 解析 XML

其中 DOM 易於上手，程序易於理解，但缺點在於占用內存大，不適合於解析較大的 XML 文件； SAX 基於事件模型占用系統資源少，能夠勝任較大的 XML 文件解析，但解析過程較為繁瑣查找元素不方便.

四種生成和解析XML文檔的方法詳解（介紹+優缺點比較+示例）

一、DOM解析

優點：

1、形成了樹結構，有助於更好的理解、掌握，且代碼容易編寫。

2、解析過程中，樹結構保存在內存中，方便修改。

缺點：

1、由於文件是一次性讀取，所以對內存的耗費比較大。

2、如果XML文件比較大，容易影響解析性能且可能會造成內存溢出.

二、SAX解析

優點：

1、采用事件驅動模式，對內存耗費比較小。

2、適用於只處理XML文件中的數據時。

缺點：

1、編碼比較麻煩。

2、很難同時訪問XML文件中的多處不同數據。

三、JDOM解析

特征：

1、僅使用具體類，而不使用接口。

2、API大量使用了Collections類.

4、DOM4J解析

特征：

1、JDOM的一種智能分支，它合並了許多超出基本XML文檔表示的功能。

2、它使用接口和抽象基本類方法。

3、具有性能優異、靈活性好、功能強大和極端易用的特點。

4、是一個開放源碼的文件.

Final：比較總結

什么是淺復制

深復制

什么是深復制

結論

擴展

詳解Java解析XML的方法

免責聲明！

Java 中的 DOM 接口簡介： JDK 中的 DOM API 遵循 W3C DOM 規范，其中 org.w3c.dom 包提供了 Document、DocumentType、Node、NodeList、Element 等接口，這些接口均是訪問 DOM 文檔所必須的。我們可以利用這些接口創建、遍歷、修改 DOM 文檔。

　　　　優點：

　　　　　　1、形成了樹結構，有助於更好的理解、掌握，且代碼容易編寫。

　　　　　　2、解析過程中，樹結構保存在內存中，方便修改。

　　　　缺點：

　　　　　　1、由於文件是一次性讀取，所以對內存的耗費比較大。

　　　　　　2、如果XML文件比較大，容易影響解析性能且可能會造成內存溢出.

　　　　優點：

　　　　　　1、采用事件驅動模式，對內存耗費比較小。

　　　　　　2、適用於只處理XML文件中的數據時。

　　　　缺點：

　　　　　　1、編碼比較麻煩。

　　　　　　2、很難同時訪問XML文件中的多處不同數據。

　　　　特征：

　　　　　　1、僅使用具體類，而不使用接口。

　　　　　　2、API大量使用了Collections類.

　　　特征：

　　　　　　1、JDOM的一種智能分支，它合並了許多超出基本XML文檔表示的功能。

　　　　　　2、它使用接口和抽象基本類方法。

　　　　　　3、具有性能優異、靈活性好、功能強大和極端易用的特點。

　　　　　　4、是一個開放源碼的文件.