javaxml操作
1. java解析xml有幾種方法
DOM（Document Object Model）解析
優點
允許應用程序對數據和結構做出更改
訪問是雙向的，可以在任何時候在樹中上、下導航獲取、操作任意部分的數據
缺點
解析XML文檔的需要載入整個文檔來構造層次結構，消耗內存資源大。
應用范圍
遍歷能力強，常應用於XML文檔需要頻繁改變的服務中。
解析步驟
創建一個 DocumentBuilderFactory 對象
創建一個 DocumentBuilder 對象
通過 DocumentBuilder 的 parse() 方法載入 XML 到當前工程目錄下
通過 getElementsByTagName() 方法獲取所有 XML 所有節點的集合
遍歷所有節點
通過 item() 方法獲取某個節點的屬性
通過 getNodeName() 和 getNodeValue() 方法獲取屬性名和屬性值
通過 getChildNodes() 方法獲取子節點，並遍歷所有子節點
通過 getNodeName() 和 getTextContent() 方法獲取子節點名稱和子節點值
package Paint;
import java.io.IOException;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import org.w3c.dom.Document;
import org.w3c.dom.NamedNodeMap;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.xml.sax.SAXException;
public class DOMTest {
public static void main(String[] args) {
DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
try {
DocumentBuilder db = dbf.newDocumentBuilder();
Document document = db.parse("./src/Paint/hello.xml");
NodeList bookList = document.getElementsByTagName("book"); //節點集
int bookCnt = bookList.getLength();
System.err.println("一共獲取到" + bookCnt +"本書");
for(int i=0; i Node book = bookList.item(i);
NamedNodeMap attrs = book.getAttributes();
for(int j=0; j Node attr = attrs.item(j);
System.err.println(attr.getNodeName()+"---"+attr.getNodeValue());//id
}
NodeList childNodes = book.getChildNodes();
for(int k=0; k if(childNodes.item(k).getNodeType() == Node.ELEMENT_NODE){
System.out.println(childNodes.item(k).getNodeName()+"---" + childNodes.item(k).getTextContent());
}
}
}
} catch (ParserConfigurationException e) {
e.printStackTrace();
} catch (SAXException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
}
SAX（Simple API for XML）解析
優點
不需要等待所有的數據被處理，解析就可以開始
只在讀取數據時檢查數據，不需要保存在內存中
可以在某一個條件滿足時停止解析，不必要解析整個文檔
效率和性能較高，能解析大於系統內存的文檔
缺點
解析邏輯復雜，需要應用層自己負責邏輯處理，文檔越復雜程序越復雜
單向導航，無法定位文檔層次，很難同時同時訪問同一文檔的不同部分數據，不支持 XPath
解析步驟
獲取一個 SAXParserFactory 的實例
通過 factory() 獲取 SAXParser 實例
創建一個 handler() 對象
通過 parser 的 parse() 方法來解析 XML
SAXTest.java
package Paint;
import java.io.IOException;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.parsers.SAXParser;
import javax.xml.parsers.SAXParserFactory;
import org.xml.sax.SAXException;
public class SAXTest {
public static void main(String[] args) {
// 獲取實例
SAXParserFactory factory = SAXParserFactory.newInstance();
try {
SAXParser parser = factory.newSAXParser();
SAXParserHandler handler = new SAXParserHandler();
parser.parse("./src/Paint/hello.xml", handler);
System.err.println("共有"+ handler.getBookList().size()+ "本書");
for(Book book : handler.getBookList()){
System.out.println(book.getName());
System.out.println("id=" + book.getId());
System.out.println(book.getAuthor());
System.out.println(book.getYear());
System.out.println(book.getPrice());
System.out.println(book.getLanguage());
}
} catch (ParserConfigurationException e) {
e.printStackTrace();
} catch (SAXException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
}
SAXParserHandler.java
package Paint;
import java.util.ArrayList;
import org.xml.sax.Attributes;
import org.xml.sax.SAXException;
import org.xml.sax.helpers.DefaultHandler;
public class SAXParserHandler extends DefaultHandler {
String value = null;
Book book = null;
private ArrayList bookList = new ArrayList();
public ArrayList getBookList() {
return bookList;
}
/*
* XML 解析開始
*/
public void startDocument() throws SAXException {
super.startDocument();
System.out.println("xml 解析開始");
}
/*
* XML 解析結束
*/
public void endDocument() throws SAXException {
super.endDocument();
System.out.println("xml 解析結束");
}
/*
* 解析 XML 元素開始
*/
public void startElement(String uri, String localName, String qName,
Attributes attributes) throws SAXException {
super.startElement(uri, localName, qName, attributes);
if(qName.equals("book")){
book = new Book();
for(int i=0; i System.out.println(attributes.getQName(i)+"---"+attributes.getValue(i));
if(attributes.getQName(i).equals("id")){
book.setId(attributes.getValue(i));
}
}
}else if(!qName.equals("bookstore")){
System.out.print("節點名："+ qName + "---");
}
}
/*
*解析 XML 元素結束
*/
public void endElement(String uri, String localName, String qName)
throws SAXException {
super.endElement(uri, localName, qName);
if(qName.equals("book")){
bookList.add(book);
book = null;
}
else if(qName.equals("name")){
book.setName(value);
}else if(qName.equals("year")){
book.setYear(value);
}else if(qName.equals("author")){
book.setAuthor(value);
}else if(qName.equals("price")){
book.setPrice(value);
}else if(qName.equals("language")){
book.setLanguage(value);
}
}
public void characters(char[] ch, int start, int length)
throws SAXException {
super.characters(ch, start, length);
// 獲取節點值數組
value = new String(ch, start, length);
if(!value.trim().equals("")){
System.out.println("節點值："+value);
}
}
}
2. XML文件的java操作有哪些
解析xml的方式方法有很多種
DOM方式解析XMLDom解析是將xml文件全部載入到內存，組裝成一顆dom樹，然後通過節點以及節點之間的關系來解析xml文件,與平台無關,java提供的一種基礎的解析XML文件的API,理解較簡單，但是由於整個文檔都需要載入內存,不適用於文檔較大時。2.SAX方式解析XML基於事件驅動,逐條解析,適用於只處理xml數據，不易編碼,而且很難同時訪問同一個文檔中的多處不同數據3.JDOM方式解析XML簡化與XML的交互並且比使用DOM實現更快,僅使用具體類而不使用介面因此簡化了API,並且易於使用4.DOM4j方式解析XMLJDOM的一種智能分支,功能較強大，建議熟練使用
但是要注意你解析xml的場景，dom這種解析方式是吧整個文檔載入到內存，解析、修改都比較方便，但是比較耗內存
sax方式基於事件驅動，解析不耗內存，
3. Java解析XML的幾種方法
DOM解析
①構建Document對象：
DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
DocumentBuilder db = bdf.newDocumentBuilder();
InputStream is = Thread.currentThread().getContextClassLoader().getResourceAsStream(xml文件);
Document doc = bd.parse(is);
②遍歷DOM對象
Document： XML文檔對象，由解析器獲取
NodeList： 節點數組
Node： 節點(包括element、#text)
Element： 元素，可用於獲取屬性參數
SAX(Simple API for XML)解析
【DefaultHandler類】
SAX事件處理程序的默認基類，實現了DTDHandler、ErrorHandler、ContextHandler和EntityResolver介面，通常
做法是，繼承該基類，重寫需要的方法，如startDocument()
【創建SAX解析器】
SAXParserFactory saxf = SAXParserFactory.newInstance();
SAXParser sax = saxf.newSAXParser();
註：關於遍歷
①深度優先遍歷(Depthi-First Traserval)
②廣度優先遍歷(Width-First Traserval)JDOM(Java-based Document Object Model)
DOM4J(Document Object Model for Java)
StAX(Streaming API for XML)
4. 通過java如何操作xml向其節點中添加內容比如<say>想添加的內容</say>
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import org.w3c.dom.*;
import org.xml.sax.SAXException;
import javax.xml.parsers.*;
import javax.xml.transform.*;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.*;
import javax.xml.xpath.*;
public class Test {
public static void main(String[] args) {
DocumentBuilderFactory factory=DocumentBuilderFactory.newInstance();
Element theBook=null, theElem=null, root=null;
try {
factory.(true);
DocumentBuilder db=factory.newDocumentBuilder();
Document xmldoc=db.parse(new File("Test1.xml"));
root=xmldoc.getDocumentElement();
theBook=(Element) selectSingleNode("/books/book[name='哈里波特']", root);
System.out.println("--- 查詢找《哈里波特》 ----");
Element nameNode=(Element)theBook.getElementsByTagName("price").item(0);
String name=nameNode.getFirstChild().getNodeValue();
System.out.println(name);
output(theBook);
System.out.println("=============selectSingleNode(books/book[name='哈里波特'], root)==================");
//--- 新建一本書開始 ----
theBook=xmldoc.createElement("book");
theElem=xmldoc.createElement("name");
theElem.setTextContent("新書");
theBook.appendChild(theElem);
theElem=xmldoc.createElement("price");
theElem.setTextContent("20");
theBook.appendChild(theElem);
theElem=xmldoc.createElement("memo");
theElem.setTextContent("新書的更好看。");
theBook.appendChild(theElem);
root.appendChild(theBook);
System.out.println("--- 新建一本書開始 ----");
output(xmldoc);
System.out.println("==============================");
//--- 新建一本書完成 ----
//--- 下面對《哈里波特》做一些修改。 ----
//--- 查詢找《哈里波特》----
//--- 此時修改這本書的價格 -----
theBook.getElementsByTagName("price").item(0).setTextContent("15");//getElementsByTagName返回的是NodeList，所以要跟上item(0)。另外，getElementsByTagName("price")相當於xpath的".//price"。
System.out.println("--- 此時修改這本書的價格 ----");
output(theBook);
//--- 另外還想加一個屬性id，值為B01 ----
theBook.setAttribute("id", "B01");
System.out.println("--- 另外還想加一個屬性id，值為B01 ----");
output(theBook);
//--- 對《哈里波特》修改完成。 ----
//--- 要用id屬性刪除《三國演義》這本書 ----
theBook=(Element) selectSingleNode("/books/book[@id='B02']", root);
System.out.println("--- 要用id屬性刪除《三國演義》這本書 ----");
output(theBook);
theBook.getParentNode().removeChild(theBook);
System.out.println("--- 刪除後的XML ----");
output(xmldoc);
//--- 再將所有價格低於10的書刪除 ----
NodeList someBooks=selectNodes("/books/book[price<10]", root);
System.out.println("--- 再將所有價格低於10的書刪除 ---");
System.out.println("--- 符合條件的書有"+someBooks.getLength()+"本。 ---");
for(int i=0;i<someBooks.getLength();i++) {
someBooks.item(i).getParentNode().removeChild(someBooks.item(i));
}
output(xmldoc);
saveXml("Test1_Edited.xml", xmldoc);
} catch (ParserConfigurationException e) {
e.printStackTrace();
} catch (SAXException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
public static void output(Node node) {//將node的XML字元串輸出到控制台
TransformerFactory transFactory=TransformerFactory.newInstance();
try {
Transformer transformer = transFactory.newTransformer();
transformer.setOutputProperty("encoding", "gb2312");
transformer.setOutputProperty("indent", "yes");
DOMSource source=new DOMSource();
source.setNode(node);
StreamResult result=new StreamResult();
result.setOutputStream(System.out);
transformer.transform(source, result);
} catch ( e) {
e.printStackTrace();
} catch (TransformerException e) {
e.printStackTrace();
}
}
public static Node selectSingleNode(String express, Object source) {//查找節點，並返回第一個符合條件節點
Node result=null;
XPathFactory xpathFactory=XPathFactory.newInstance();
XPath xpath=xpathFactory.newXPath();
try {
result=(Node) xpath.evaluate(express, source, XPathConstants.NODE);
} catch (XPathExpressionException e) {
e.printStackTrace();
}
return result;
}
public static NodeList selectNodes(String express, Object source) {//查找節點，返回符合條件的節點集。
NodeList result=null;
XPathFactory xpathFactory=XPathFactory.newInstance();
XPath xpath=xpathFactory.newXPath();
try {
result=(NodeList) xpath.evaluate(express, source, XPathConstants.NODESET);
} catch (XPathExpressionException e) {
e.printStackTrace();
}
return result;
}
public static void saveXml(String fileName, Document doc) {//將Document輸出到文件
TransformerFactory transFactory=TransformerFactory.newInstance();
try {
Transformer transformer = transFactory.newTransformer();
transformer.setOutputProperty("indent", "yes");
DOMSource source=new DOMSource();
source.setNode(doc);
StreamResult result=new StreamResult();
result.setOutputStream(new FileOutputStream(fileName));
transformer.transform(source, result);
} catch ( e) {
e.printStackTrace();
} catch (TransformerException e) {
e.printStackTrace();
} catch (FileNotFoundException e) {
e.printStackTrace();
}
}
}
XML：
<?xml version="1.0" encoding="GBK"?>
<books>
<book>
<name>哈里波特</name>
<price>10</price>
<memo>這是一本很好看的書。</memo>
</book>
<book id="B02">
<name>三國演義</name>
<price>10</price>
<memo>四大名著之一。</memo>
</book>
<book id="B03">
<name>水滸</name>
<price>6</price>
<memo>四大名著之一。</memo>
</book>
<book id="B04">
<name>紅樓</name>
<price>5</price>
<memo>四大名著之一。</memo>
</book>
</books>
5. 在java中xml有哪些解析技術
1.DOM生成和解析XML文檔
為 XML 文檔的已解析版本定義了一組介面。解析器讀入整個文檔，然後構建一個駐留內存的樹結構，然後代碼就可以使用 DOM
介面來操作這個樹結構。優點：整個文檔樹在內存中，便於操作；支持刪除、修改、重新排列等多種功能；缺點：將整個文檔調入內存（包括無用的節點），浪費時間和空間；使用場合：一旦解析了文檔還需多次訪問這些數據；硬體資源充足（內存、CPU）。
2.SAX生成和解析XML文檔
為解決DOM的問題，出現了SAX。SAX
，事件驅動。當解析器發現元素開始、元素結束、文本、文檔的開始或結束等時，發送事件，程序員編寫響應這些事件的代碼，保存數據。優點：不用事先調入整個文檔，佔用資源少；SAX解析器代碼比DOM解析器代碼小，適於Applet，下載。缺點：不是持久的；事件過後，若沒保存數據，那麼數據就丟了；無狀態性；從事件中只能得到文本，但不知該文本屬於哪個元素；使用場合：Applet;只需XML文檔的少量內容，很少回頭訪問；機器內存少；
3.DOM4J生成和解析XML文檔
DOM4J 是一個非常非常優秀的Java XML
API，具有性能優異、功能強大和極端易用使用的特點，同時它也是一個開放源代碼的軟體。如今你可以看到越來越多的 Java 軟體都在使用 DOM4J 來讀寫
XML，特別值得一提的是連 Sun 的 JAXM 也在用 DOM4J。
4.JDOM生成和解析XML
為減少DOM、SAX的編碼量，出現了JDOM；優點：20-80原則，極大減少了代碼量。使用場合：要實現的功能簡單，如解析、創建等，但在底層，JDOM還是使用SAX（最常用）、DOM、Xanan文檔。
新技術目前還木有，就是有了也不穩定，你也不敢用阿。
6. Java操作DB2 XML數據實踐
Java操作DB XML數據實踐
自學了 分鍾的DB XQuery 還不很熟悉 就要在項目中用了 心裡很不踏實 還是先跑個CRUD的Demo看看 以免走彎路
代碼很粗糙 主要目的是看看JDBC是否能很好的執行這種新sql 呵呵
另外 在此之前 看到Oracle老大已經開始實現一個操作XML數據的規范 目前還沒有正式出台 希望Sun能盡快跟進 將標準的API介面定出來 以支持廣大的Java社區 項目有期限 我們也沒時間等Sun給我們做好任何東西 自己動手實現吧
下面是我做的一個Demo 希望能給正在研究這一塊的朋友一點參考 XQuery SQL代碼參考了DB 官方文檔
一 實現一個簡單的資料庫工具import java sql *
* 簡單的數據連接工具 * File: DBUtils java * User: leimin * Date: : : */ public class DBUtils { public static final String url = jdbc:db :// : /lavasoft ; public static final String username = lavasoft ; public static final String password = lavasoftdb ; public static final String driverClassName = ibm db jcc DB Driver ;
/** * 獲取資料庫連接Connection * * @return 資料庫連接Connection */ public static Connection makeConnection() { Connection conn = null; try { Class forName(driverClassName); } catch (ClassNotFoundException e) { e printStackTrace(); } try { conn = DriverManager getConnection(url username password); } catch (SQLException e) { e printStackTrace(); } return conn; }
public static void main(String args[]) { testConnection(); }
/** * 測試連接方法 */ public static void testConnection() { Connection conn = makeConnection(); try { Statement stmt = conn createStatement(); ResultSet rs = stmt executeQuery( SELECT * FROM DM_HYML ); while (rs next()) { String s = rs getString( ); String s = rs getString( ); System out println(s + s ); } rs close(); stmt close(); } catch (SQLException e) { e printStackTrace(); } finally { try { conn close(); } catch (SQLException e) { e printStackTrace(); } } } }
二 寫一個簡單的測試類執行各種XQuery SQL
import mon utils DBUtils;
import java sql *; import java io ByteArrayInputStream; import java io InputStream; import java io IOException;
/** * DB XML數據操作測試 * File: TestXMLDAO java * User: leimin * Date: : : */ public class TestDB XML {
/** * 預刪除表Customer * * @throws SQLException */ public static void testDropXMLTable() throws SQLException { String drop_sql = DROP TABLE Customer ; Connection conn = DBUtils makeConnection(); Statement stmt = conn createStatement(); stmt executeUpdate(drop_sql); stmt close(); conn close(); }
/**
* 創建表 * * @throws SQLException */ public static void testCreateXMLTable() throws SQLException { String ct_sql = CREATE TABLE Customer (Cid BIGINT NOT NULL PRIMARY KEY Info XML) ; Connection conn = DBUtils makeConnection(); Statement stmt = conn createStatement(); stmt executeUpdate(ct_sql); stmt close(); conn close(); }
/** * 插入數據 * * @throws SQLException * @throws IOException */ public static void testInsertXMLTable() throws SQLException IOException { String xml = <customerinfo xmlns= Cid= > + <name>Robert Shoemaker</name> + <addr country= Canada > + <street> Baseline</street> + <city>zhengzhou</city> + <prov state>Ontario</prov state> + <pcode zip>N X F </pcode zip> + </addr> + <phone type= work > </phone> + </customerinfo> ; String ins_sql = INSERT INTO CUSTOMER (CID INFO) VALUES ( ?) ; Connection conn = DBUtils makeConnection(); conn setAutoCommit(false); PreparedStatement pstmt = conn prepareStatement(ins_sql); byte[] b = xml getBytes(); InputStream ins = new ByteArrayInputStream(b); pstmt setBinaryStream( ins b length); pstmt executeUpdate(); mit(); ins close(); pstmt close(); conn close(); }
/** * XQuery查詢數據 * * @throws SQLException */ public static void testQueryXMLTable() throws SQLException { String query_sql = SELECT XMLQUERY ( + declare default element namespace ; + for $d in $doc/customerinfo + return <out>{$d/name}</out> + passing INFO as doc ) + FROM Customer as c + WHERE XMLEXISTS ( declare default element namespace ; + $i/customerinfo/addr[city= zhengzhou ] passing c INFO as i ) ; Connection conn = DBUtils makeConnection(); Statement stmt = conn createStatement(); ResultSet rs = stmt executeQuery(query_sql); StringBuffer xmls = new StringBuffer(); while (rs next()) { xmls append(rs getString( )) append( ); } System out println(xmls toString()); stmt close(); conn close(); }
/** * XQuery更新數據 * * @throws SQLException * @throws IOException */ public static void testUpdateXMLTable() throws SQLException IOException { String xml = <customerinfo xmlns= Cid= > + <name>Jim Noodle</name> + <addr country= Canada > + <street> Maple Drive</street> + <city>Newtown</city> + <prov state>Ontario</prov state> + <pcode zip>Z Z P </pcode zip> + </addr> + <phone type= work > </phone> + </customerinfo> ; String up_sql = UPDATE customer SET info =? + WHERE XMLEXISTS ( + declare default element namespace ; + $doc/customerinfo[@Cid = ] + passing INFO as doc ) ;
Connection conn = DBUtils makeConnection(); conn setAutoCommit(false); PreparedStatement pstmt = conn prepareStatement(up_sql); byte[] b = xml getBytes(); InputStream ins = new ByteArrayInputStream(b); pstmt setBinaryStream( ins b length); pstmt executeUpdate(); mit(); ins close(); pstmt close(); conn close(); }
* 查詢xml列數據 用於驗證 * * @throws SQLException */ public static void testQueryXMLColumn() throws SQLException { String query_sql = SELECT INFO FROM Customer ; Connection conn = DBUtils makeConnection(); Statement stmt = conn createStatement(); ResultSet rs = stmt executeQuery(query_sql); StringBuffer xmls = new StringBuffer(); while (rs next()) { xmls append(rs getString( )) append( ); } System out println(xmls toString()); stmt close(); conn close(); }
/** * 測試入口 方法組調用 * * @param rags * @throws Exception */ public static void main(String rags[]) throws Exception { testDropXMLTable(); testCreateXMLTable(); testInsertXMLTable(); testQueryXMLTable(); testUpdateXMLTable(); testQueryXMLColumn(); } }
三 運行結果
<out xmlns= Robert > ><name>Robert Shoemaker</name></out>
<customerinfo xmlns= Cid= ><name>Jim Noodle</name><addr country= Canada ><street> Maple Drive</street><city>Newtown</city><prov state>Ontario</prov state><pcode zip>Z Z P </pcode zip></addr><phone type= work > </phone></customerinfo>
Process finished with exit code
lishixin/Article/program/Java/hx/201311/25786
7. 請教下java操作XML配置問題是怎麼實現的
.介紹
1）DOM（JAXP Crimson解析器）
DOM是用與平台和語言無關的方式表示XML文檔的官方W3C標准。DOM是以層次結構組織的節點或信息片斷的集合。這個層次結構允許開發人員在樹中尋找特定信息。分析該結構通常需要載入整個文檔和構造層次結構，然後才能做任何工作。由於它是基於信息層次的，因而DOM被認為是基於樹或基於對象的。DOM以及廣義的基於樹的處理具有幾個優點。首先，由於樹在內存中是持久的，因此可以修改它以便應用程序能對數據和結構作出更改。它還可以在任何時候在樹中上下導航，而不是像SAX那樣是一次性的處理。DOM使用起來也要簡單得多。
2）SAX
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解析器的時候編碼工作會比較困難，而且很難同時訪問同一個文檔中的多處不同數據。
3）JDOM http://www.jdom.org
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許可證變體下發布的開放源碼。
4）DOM4J http://dom4j.sourceforge.net
雖然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.
2、比較
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流被讀入時，會有部分文檔暫時隱藏在內存中）。
3.四種XML操作方式的基本使用方法
xml文件：
＜?xml version="1.0" encoding="GB2312"?＞
＜RESULT＞
＜VALUE＞
＜NO＞A1234＜/NO＞
＜ADDR＞四川省XX縣XX鎮XX路X段XX號＜/ADDR＞
＜/VALUE＞
＜VALUE＞
＜NO＞B1234＜/NO＞
＜ADDR＞四川省XX市XX鄉XX村XX組＜/ADDR＞
＜/VALUE＞
＜/RESULT＞
1）DOM
import java.io.*;
import java.util.*;
import org.w3c.dom.*;
import javax.xml.parsers.*;
public class MyXMLReader{
public static void main(String arge[]){
long lasting =System.currentTimeMillis();
try{
File f=new File("data_10k.xml");
DocumentBuilderFactory factory=DocumentBuilderFactory.newInstance();
DocumentBuilder builder=factory.newDocumentBuilder();
Document doc = builder.parse(f);
NodeList nl = doc.getElementsByTagName("VALUE");
for (int i=0;i＜nl.getLength();i++){
System.out.print("車牌號碼:" +
doc.getElementsByTagName("NO").item(i).getFirstChild().getNodeValue());
System.out.println("車主地址:" +
doc.getElementsByTagName("ADDR").item(i).getFirstChild().getNodeValue());
}
}catch(Exception e){
e.printStackTrace();
}
2）SAX
import org.xml.sax.*;
import org.xml.sax.helpers.*;
import javax.xml.parsers.*;
public class MyXMLReader extends DefaultHandler {
java.util.Stack tags = new java.util.Stack();
public MyXMLReader() {
super();
}
public static void main(String args[]) {
long lasting = System.currentTimeMillis();
try {
SAXParserFactory sf = SAXParserFactory.newInstance();
SAXParser sp = sf.newSAXParser();
MyXMLReader reader = new MyXMLReader();
sp.parse(new InputSource("data_10k.xml"), reader);
} catch (Exception e) {
e.printStackTrace();
}
System.out.println("運行時間：" + (System.currentTimeMillis() - lasting) + "毫秒");}
public void characters(char ch[], int start, int length) throws SAXException {
String tag = (String) tags.peek();
if (tag.equals("NO")) {
System.out.print("車牌號碼：" + new String(ch, start, length));
}
if (tag.equals("ADDR")) {
System.out.println("地址:" + new String(ch, start, length));
}
}
public void startElement(String uri,String localName,String qName,Attributes attrs) {
tags.push(qName);}
}
3）JDOM
import java.io.*;
import java.util.*;
import org.jdom.*;
import org.jdom.input.*;
public class MyXMLReader {
public static void main(String arge[]) {
long lasting = System.currentTimeMillis();
try {
SAXBuilder builder = new SAXBuilder();
Document doc = builder.build(new File("data_10k.xml"));
Element foo = doc.getRootElement();
List allChildren = foo.getChildren();
for(int i=0;i＜allChildren.size();i++) {
System.out.print("車牌號碼:" +
((Element)allChildren.get(i)).getChild("NO").getText());
System.out.println("車主地址:" +
((Element)allChildren.get(i)).getChild("ADDR").getText());
}
} catch (Exception e) {
e.printStackTrace();
}
}
4）DOM4J
import java.io.*;
import java.util.*;
import org.dom4j.*;
import org.dom4j.io.*;
public class MyXMLReader {
public static void main(String arge[]) {
long lasting = System.currentTimeMillis();
try {
File f = new File("data_10k.xml");
SAXReader reader = new SAXReader();
Document doc = reader.read(f);
Element root = doc.getRootElement();
Element foo;
for (Iterator i = root.elementIterator("VALUE"); i.hasNext() {
foo = (Element) i.next();
System.out.print("車牌號碼:" + foo.elementText("NO"));
System.out.println("車主地址:" + foo.elementText("ADDR"));
}
} catch (Exception e) {
e.printStackTrace();
}
8. java的xml的解析方式有什麼，他們的解析流程是怎麼樣的，有什麼區別
答：4種。（或者說是兩種，因為JDOM和DOM4J是DOM的兩個特殊情況）
1.SAX解析
解析方式是事件驅動機制！
SAX解析器，逐行讀取XML文件解析，每當解析到一個標簽的開始/結束/內容/屬性時，觸發事件。
可以在這些事件發生時，編寫程序進行相應的處理。
優點：
分析能夠立即開始，而不是等待所有的數據被處理。
逐行載入，節省內存，有助於解析大於系統內存的文檔。
有時不必解析整個文檔，它可以在某個條件得到滿足時停止解析。
缺點：
1.單向解析，無法定位文檔層次，無法同時訪問同一個文檔的不同部分數據（因為逐行解析，當解析第n行時，第n-1行）已經被釋放了，無法再對其進行操作）。
2. 無法得知事件發生時元素的層次, 只能自己維護節點的父/子關系。
3. 只讀解析方式, 無法修改XML文檔的內容。
2. DOM解析
是用與平台和語言無關的方式表示XML文檔的官方W3C標准，分析該結構通常需要載入整個 文檔和內存中建立文檔樹模型。程序員可以通過操作文檔樹, 來完成數據的獲取 修改 刪除等。
優點:
文檔在內存中載入, 允許對數據和結構做出更改。訪問是雙向的，可以在任何時候在樹中雙向解析數據。
缺點:
文檔全部載入在內存中 , 消耗資源大。
3. JDOM解析
目的是成為Java特定文檔模型，它簡化與XML的交互並且比使用DOM實現更快。由於是第一 個Java特定模型，JDOM一直得到大力推廣和促進。
JDOM文檔聲明其目的是「使用20%（或更少）的精力解決80%（或更多）Java/XML問題」 （根據學習曲線假定為20%）
優點:
使用具體類而不是介面，簡化了DOM的API。
大量使用了Java集合類，方便了Java開發人員。
缺點:
沒有較好的靈活性。
性能不是那麼優異。
4. DOM4J解析
它是JDOM的一種智能分支。它合並了許多超出基本XML文檔表示的功能，包括集成的XPath 支持、XML Schema支持以及用於大文檔或流化文檔的基於事件的處理。它還提供了構建文檔表示的選項， DOM4J是一個非常優秀的Java XML API，具有性能優異、功能強大和極端易用使用的特點，同時它也是一 個開放源代碼的軟體。如今你可以看到越來越多的Java軟體都在使用DOM4J來讀寫XML。
目前許多開源項目中大量採用DOM4J , 例如:Hibernate。
9. java解析xml的幾種方式哪種最好
在java中解析xml有哪幾種方法?
1、JDOM生成和解析XML
為減少DOM、SAX的編碼量,出現了JDOM
優點:20-80原則,極大減少了代碼量。
使用場合:要實現的功能簡單,如解析、創建等,但在底層,JDOM還是使用SAX(最常用)、DOM、Xanan文檔。
2、SAX生成和解析XML文檔
為解決DOM的問題,出現了SAX,SAX
事件驅動。當解析器發現元素開始、元素結束、文本、文檔的開始或結束等時發送事件,程序員編寫響應這些事件的代碼,保存數據。
優點:不用事先調入整個文檔,佔用資源少。SAX解析器代碼比DOM解析器代碼小,適於Applet下載。
缺點:不是持久的,事件過後若沒保存數據,那麼數據就丟了。無狀態性,從事件中只能得到文本,但不知該文本屬於哪個元素。
使用場合:Applet。只需XML文檔的少量內容,很少回頭訪問,機器內存少。
3、DOM生成和解析XML文檔
為XML文檔的已解析版本定義了一組介面。解析器讀入整個文檔,然後構建一個駐留內存的樹結構,然後代碼就可以使用 DOM 介面來操作這個樹結構。
優點:整個文檔樹在內存中,便於操作,支持刪除、修改、重新排列等多種功能。
缺點:將整個文檔調入內存(包括無用的節點),浪費時間和空間。
使用場合:一旦解析了文檔還需多次訪問這些數據,硬體資源充足(內存、CPU)。
10. java怎樣讀寫和修改XML文件
xml:
<?xml version="1.0" encoding="UTF-8"?>
<users>
<Messages>
<sendName>sendUsers</sendName>
<receiveName>snake</receiveName>
<date>2007-12-04 12:20:00</date>
<status>0</status>
<message>this is Content</message>
</Messages>
</users>
java:
package com.lianxi.DAO;
import java.io.File;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.transform.Transformer;
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.Node;
import org.w3c.dom.NodeList;
public class UpdateXml {
public static boolean doc2XmlFile(Document document,String filename)
{
boolean flag = true;
try
{
/** 將document中的內容寫入文件中 */
TransformerFactory tFactory = TransformerFactory.newInstance();
Transformer transformer = tFactory.newTransformer();
/** 編碼 */
//transformer.setOutputProperty(OutputKeys.ENCODING, "GB2312");
DOMSource source = new DOMSource(document);
StreamResult result = new StreamResult(new File(filename));
transformer.transform(source, result);
}catch(Exception ex)
{
flag = false;
ex.printStackTrace();
}
return flag;
}
public static Document load(String filename)
{
Document document = null;
try
{
DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
DocumentBuilder builder=factory.newDocumentBuilder();
document=builder.parse(new File(filename));
document.normalize();
}
catch (Exception ex){
ex.printStackTrace();
}
return document;
}
/**
* 演示修改文件的具體某個節點的值
*/
public static void xmlUpdateDemo()
{
Document document = load("c://Message.xml");
Node root=document.getDocumentElement();
/** 如果root有子元素 */
if(root.hasChildNodes())
{
/** ftpnodes */
NodeList ftpnodes = root.getChildNodes();
/** 循環取得ftp所有節點 */
for (int i=0;i<ftpnodes.getLength();i++)
{
NodeList ftplist = ftpnodes.item(i).getChildNodes();
for (int k=0;k<ftplist.getLength();k++)
{
Node subnode = ftplist.item(k);
/** 刪除ftp-chn節點 */
// if (subnode.getNodeType()==Node.ELEMENT_NODE&&subnode.getNodeName()=="ftp-chn")
// {
// ftpnodes.item(i).removeChild(subnode);
// }
/** 修改ftp-host的值為 192.168.0.1 */
if (subnode.getNodeType()==Node.ELEMENT_NODE&&subnode.getNodeName()=="status")
{
subnode.getFirstChild().setNodeValue("1");
}
}
}
}
doc2XmlFile(document,"c://Message.xml");
}
public static void main(String args[])throws Exception
{
UpdateXml.xmlUpdateDemo();
}
}