java遍歷xml
Ⅰ java xml遍歷
java xml遍歷主要是使用java提供工具類DocumentBuilderFactory
類來解析xml文件和遍歷，如下代碼：
importjavax.xml.parsers.DocumentBuilderFactory;
importjavax.xml.parsers.DocumentBuilder;
importorg.w3c.dom.*;
importjava.io.File;
publicclassTraverseXML
{
publicstaticvoidmain(String[]args)
{
try{
Stringfile="TestData\test.xml";
DocumentBuilderFactorydbf=DocumentBuilderFactory.newInstance();
DocumentBuilderdocBuilder=dbf.newDocumentBuilder();
Documentdoc=docBuilder.parse(newFile(file));
NodeListnodes=doc.getElementsByTagName("person");
System.out.println("總共有"+nodes.getLength()+"個人。");
for(inti=0;i<nodes.getLength();i++)
{
Nodenode=nodes.item(i);
NodeListchildNodes=node.getChildNodes();
System.out.println("person有"+childNodes.getLength()+"個節點。");
for(intj=0;j<childNodes.getLength();j++)
{
NodechildNode=childNodes.item(j);
if(childNode.getNodeType()==Node.ELEMENT_NODE&&childNode.getNodeName().equals("name"))
System.out.println("名字："+childNode.getFirstChild().getNodeValue());
if(childNode.getNodeType()==Node.ELEMENT_NODE&&childNode.getNodeName().equals("age"))
System.out.println("年齡："+childNode.getFirstChild().getNodeValue());
}
System.out.println();
}
}catch(Exceptione){
e.printStackTrace();
}
}
}
Ⅱ JAVA中如何遍歷xml，取出 鍵、值傳進Map里。（考慮xml中的子節點的問題）用遞歸寫。 求救！謝謝了！
我估計是要求按WCF模式下，利用NHibernate的架構方式組合
首先NHibernate裡面有object-relation map 的xml
而WCF可以生成domainService，所以，一個是處於資料庫層，一個是處於數據訪問層
但是這兩種方式的組合，我還沒弄過，就在這里給你提一下吧
仔細看
2.An object-relation map for use by a object-relation system (or a 『decorated』 domain model) such as NHibernate or EntityFramework/LINQ
是說你要講資料庫表，映射成有映射關系的NHibernate 模式，或EntityFramework/LINQ模式，可以任選其一，那麼就可以選擇任意一種模式了
另外,團IDC網上有許多產品團購,便宜有口碑
Ⅲ 在java中解析xml有哪幾種方法
(1)DOM解析
DOM是html和xml的應用程序介面(API)，以層次結構（類似於樹型）來組織節點和信息片段，映射XML文檔的結構，允許獲取
和操作文檔的任意部分，是W3C的官方標准
【優點】
①允許應用程序對數據和結構做出更改。
②訪問是雙向的，可以在任何時候在樹中上下導航，獲取和操作任意部分的數據。
【缺點】
①通常需要載入整個XML文檔來構造層次結構，消耗資源大。
【解析詳解】
①構建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： 元素，可用於獲取屬性參數
(2)SAX(Simple API for XML)解析
流模型中的"推"模型分析方式。通過事件驅動，每發現一個節點就引發一個事件，事件推給事件處理器，通過回調方法
完成解析工作，解析XML文檔的邏輯需要應用程序完成
【優勢】
①不需要等待所有數據都被處理，分析就能立即開始。
②只在讀取數據時檢查數據，不需要保存在內存中。
③可以在某個條件得到滿足時停止解析，不必解析整個文檔。
④效率和性能較高，能解析大於系統內存的文檔。
【缺點】
①需要應用程序自己負責TAG的處理邏輯（例如維護父/子關系等），文檔越復雜程序就越復雜。
②單向導航，無法定位文檔層次，很難同時訪問同一文檔的不同部分數據，不支持XPath。
【原理】
簡單的說就是對文檔進行順序掃描，當掃描到文檔(document)開始與結束、元素(element)開始與結束時通知事件
處理函數(回調函數)，進行相應處理，直到文檔結束
【事件處理器類型】
①訪問XML DTD：DTDHandler
②低級訪問解析錯誤：ErrorHandler
③訪問文檔內容：ContextHandler
【DefaultHandler類】
SAX事件處理程序的默認基類，實現了DTDHandler、ErrorHandler、ContextHandler和EntityResolver介面，通常
做法是，繼承該基類，重寫需要的方法，如startDocument()
【創建SAX解析器】
SAXParserFactory saxf = SAXParserFactory.newInstance();
SAXParser sax = saxf.newSAXParser();
註：關於遍歷
①深度優先遍歷(Depthi-First Traserval)
②廣度優先遍歷(Width-First Traserval)
(3)JDOM(Java-based Document Object Model)
Java特定的文檔對象模型。自身不包含解析器，使用SAX
【優點】
①使用具體類而不是介面，簡化了DOM的API。
②大量使用了Java集合類，方便了Java開發人員。
【缺點】
①沒有較好的靈活性。
②性能較差。
(4)DOM4J(Document Object Model for Java)
簡單易用，採用Java集合框架，並完全支持DOM、SAX和JAXP
【優點】
①大量使用了Java集合類，方便Java開發人員，同時提供一些提高性能的替代方法。
②支持XPath。
③有很好的性能。
【缺點】
①大量使用了介面，API較為復雜。
(5)StAX(Streaming API for XML)
流模型中的拉模型分析方式。提供基於指針和基於迭代器兩種方式的支持,JDK1.6新特性
【和推式解析相比的優點】
①在拉式解析中，事件是由解析應用產生的，因此拉式解析中向客戶端提供的是解析規則，而不是解析器。
②同推式解析相比，拉式解析的代碼更簡單，而且不用那麼多庫。
③拉式解析客戶端能夠一次讀取多個XML文件。
④拉式解析允許你過濾XML文件和跳過解析事件。
【簡介】
StAX API的實現是使用了Java Web服務開發（JWSDP）1.6，並結合了Sun Java流式XML分析器(SJSXP)-它位於
javax.xml.stream包中。XMLStreamReader介面用於分析一個XML文檔，而XMLStreamWriter介面用於生成一個
XML文檔。XMLEventReader負責使用一個對象事件迭代子分析XML事件-這與XMLStreamReader所使用的游標機制
形成對照。
Ⅳ java解析xml的幾種方式哪種最好
(1)DOM解析
DOM是html和xml的應用程序介面(API)，以層次結構（類似於樹型）來組織節點和信息片段，映射XML文檔的結構，允許獲取;
(2)SAX(Simple API for XML)解析
流模型中的"推"模型分析方式。通過事件驅動，每發現一個節點就引發一個事件，事件推給事件處理器，通過回調方法;
Ⅳ 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);
}
}
}
Ⅵ java如何讀取xml文件
xml解析還是用dom4j方便，
importjava.util.List;
importorg.dom4j.Document;
importorg.dom4j.DocumentException;
importorg.dom4j.Element;
importorg.dom4j.io.SAXReader;
publicclassXMLPaser{
publicstaticvoidmain(String[]args){
paserXML();
}
publicstaticvoidpaserXML(){
SAXReaderreader=newSAXReader();
try{
//讀取XML文件
Documentdoc=reader.read("NewFile.xml");
Elementroot=doc.getRootElement();
System.out.println(root.getName());
List<Element>param=root.elements();
for(Elementelement:param){
if(element.attributeValue("name").equals("a")){
System.out.println(element.getText());
}
}
}catch(DocumentExceptione){
e.printStackTrace();
}
}
}
Ⅶ java解析xml的幾種方式哪種最好
(1)DOM解析
DOM是html和xml的應用程序介面(API)，以層次結構（類似於樹型）來組織節點和信息片段，映射XML文檔的結構，允許獲取
和操作文檔的任意部分，是W3C的官方標准
【優點】
①允許應用程序對數據和結構做出更改。
②訪問是雙向的，可以在任何時候在樹中上下導航，獲取和操作任意部分的數據。
【缺點】
①通常需要載入整個XML文檔來構造層次結構，消耗資源大。
【解析詳解】
①構建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： 元素，可用於獲取屬性參數
(2)SAX(Simple API for XML)解析
流模型中的"推"模型分析方式。通過事件驅動，每發現一個節點就引發一個事件，事件推給事件處理器，通過回調方法
完成解析工作，解析XML文檔的邏輯需要應用程序完成
【優勢】
①不需要等待所有數據都被處理，分析就能立即開始。
②只在讀取數據時檢查數據，不需要保存在內存中。
③可以在某個條件得到滿足時停止解析，不必解析整個文檔。
④效率和性能較高，能解析大於系統內存的文檔。
【缺點】
①需要應用程序自己負責TAG的處理邏輯（例如維護父/子關系等），文檔越復雜程序就越復雜。
②單向導航，無法定位文檔層次，很難同時訪問同一文檔的不同部分數據，不支持XPath。
【原理】
簡單的說就是對文檔進行順序掃描，當掃描到文檔(document)開始與結束、元素(element)開始與結束時通知事件
處理函數(回調函數)，進行相應處理，直到文檔結束
【事件處理器類型】
①訪問XML DTD：DTDHandler
②低級訪問解析錯誤：ErrorHandler
③訪問文檔內容：ContextHandler
【DefaultHandler類】
SAX事件處理程序的默認基類，實現了DTDHandler、ErrorHandler、ContextHandler和EntityResolver介面，通常
做法是，繼承該基類，重寫需要的方法，如startDocument()
【創建SAX解析器】
SAXParserFactory saxf = SAXParserFactory.newInstance();
SAXParser sax = saxf.newSAXParser();
註：關於遍歷
①深度優先遍歷(Depthi-First Traserval)
②廣度優先遍歷(Width-First Traserval)
(3)JDOM(Java-based Document Object Model)
Java特定的文檔對象模型。自身不包含解析器，使用SAX
【優點】
①使用具體類而不是介面，簡化了DOM的API。
②大量使用了Java集合類，方便了Java開發人員。
【缺點】
①沒有較好的靈活性。
②性能較差。
(4)DOM4J(Document Object Model for Java)
簡單易用，採用Java集合框架，並完全支持DOM、SAX和JAXP
【優點】
①大量使用了Java集合類，方便Java開發人員，同時提供一些提高性能的替代方法。
②支持XPath。
③有很好的性能。
【缺點】
①大量使用了介面，API較為復雜。
(5)StAX(Streaming API for XML)
流模型中的拉模型分析方式。提供基於指針和基於迭代器兩種方式的支持,JDK1.6新特性
【和推式解析相比的優點】
①在拉式解析中，事件是由解析應用產生的，因此拉式解析中向客戶端提供的是解析規則，而不是解析器。
②同推式解析相比，拉式解析的代碼更簡單，而且不用那麼多庫。
③拉式解析客戶端能夠一次讀取多個XML文件。
④拉式解析允許你過濾XML文件和跳過解析事件。
【簡介】
StAX API的實現是使用了Java Web服務開發（JWSDP）1.6，並結合了Sun Java流式XML分析器(SJSXP)-它位於
javax.xml.stream包中。XMLStreamReader介面用於分析一個XML文檔，而XMLStreamWriter介面用於生成一個
XML文檔。XMLEventReader負責使用一個對象事件迭代子分析XML事件-這與XMLStreamReader所使用的游標機制
形成對照。
Ⅷ java 如何遍歷xml並輸出每個節點的每個屬性
//列印xml文檔
private void parseElement(Element root)
{
//System.out.print(root.getNamespaceURI());
System.out.print("<");
System.out.print(root.getNodeName());
//System.out.print(root.getPrefix());
//System.out.print(":");
//System.out.print(root.getLocalName());
NamedNodeMap nnm = root.getAttributes();
for(int i = 0; i < nnm.getLength(); i++)
{
Attr attr = (Attr)nnm.item(i);
System.out.print(" ");
System.out.print(attr.getName());
System.out.print("=\"");
System.out.print(attr.getValue());
System.out.print("\"");
}
System.out.print(">");
NodeList list = root.getChildNodes();
for(int i = 0; i < list.getLength(); i++)
{
Node node = list.item(i);
if(node instanceof Element)
{
Element e = (Element)node;
parseElement(e);
}
else if(node instanceof Text)
{
Text t = (Text)node;
System.out.print(t.getNodeValue());
}
}
System.out.print("</");
System.out.print(root.getNodeName());
System.out.print(">");
}
private void parseRootName()
{
Element root = doc.getDocumentElement();
System.out.println(root.getNodeName());
}
//工廠
private void getDocument()
{
try
{
DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
factory.setNamespaceAware(true);
DocumentBuilder db = factory.newDocumentBuilder();
doc = db.parse(new File(fileName));
}
catch(Exception ex)
{
ex.printStackTrace();
System.exit(1);
}
}
Ⅸ 如何用java遍歷出xml中每一個attributeValue的值
遞歸讀取法即可
package tool;
import java.util.Scanner;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import org.w3c.dom.Document;
import org.w3c.dom.NamedNodeMap;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
public class XMLTool
{
private static final String XML = "MyXml.xml";
private static Document getDoc ( String xml )
{
DocumentBuilderFactory dbf = null;
DocumentBuilder db = null;
Document doc = null;
try
{
dbf = DocumentBuilderFactory.newInstance ();
db = dbf.newDocumentBuilder ();
doc = null == xml ? db.newDocument () : db.parse (xml);
return doc;
}
catch (Exception e)
{
e.printStackTrace ();
}
return null;
}
private static void readXML ( String xml, String... looks )
{
Document doc = getDoc (xml);
recursionXML (doc, looks);
}
private static void recursionXML ( Node node, String... looks )
{
NodeList nl = node.getChildNodes ();
if (nl.getLength () == 0)
{
return;
}
for ( int i = 0; i < nl.getLength (); i++ )
{
Node n = nl.item (i);
Node parentNode = n.getParentNode ();
NamedNodeMap nnm = parentNode.getAttributes ();
if (
looks.length != 0
&&
parentNode.getNodeName ().equals (looks[0])
&&
nnm.getNamedItem (looks[1]).getNodeValue ().equals (looks[2])
)
{
System.out.println (nnm.getNamedItem ("Status"));
}
recursionXML (n, looks);
}
}
public static void main ( String[] args )
{
System.out.println ("輸入id號進行查詢: (n/N 退出)");
Scanner scanner = new Scanner (System.in);
String[] looks = { "UseTicketResult", "TicketNo", "47" };
String line = null;
while (scanner.hasNextLine ())
{
line = scanner.nextLine ().trim ();
if ("n".equalsIgnoreCase (line))
{
scanner.close ();
break;
}
looks[2] = line;
readXML (XML, looks);
System.out.println ("繼續輸入: ");
}
}
}
Ⅹ 用JAVA訪問XML文檔
<?xml version="1.0" encoding="gb2312"?>
<!DOCTYPE student_main SYSTEM "student.dtd">
<student_main>
<students>
<student xh="s001">
<name>張三</name>
<sex>男</sex>
<age>18</age>
</student>
<student xh="s002">
<name>李四</name>
<sex>女</sex>
<age>19</age>
</student>
<student xh="s003">
<name>王五</name>
<sex>男</sex>
<age>20</age>
</student>
</students>
<electives>
<elective xh="soo1">
<kch>c01</kch>
<score>85</score>
</elective>
<elective xh="soo2">
<kch>c02</kch>
<score>90</score>
</elective>
</electives>
<courses>
<course kch="c01">
<kcm>數據結構</kcm>
<credit>4</credit>
</course>
<course kch="c02">
<kcm>資料庫系統</kcm>
<credit>3</credit>
</course>
</courses>
</student_main>