android解析xml的類

㈠ Android灝哖PT鏍煎紡鐨刋ML鏁版嵁瑙ｆ瀽錛屽苟瀹炵幇婕旂ず

涓銆俿imple-xml絎涓夋柟jar鍖呰В鏋恱ml鏍煎紡鏁版嵁
simple-xml鏄涓涓獂ml鍜屽硅薄浜掕漿鎿嶄綔宸ュ叿鍖咃紝瀹樻柟緗戝潃涓猴細http://simple.sourceforge.net/錛宩ar鍖呭彲浠ュ埌瀹樼綉涓婁笅杞斤紝絎旇呬嬌鐢ㄧ殑鏄鐩鍓嶆渶鏂扮増鏈鐨刯ar鍖咃紝鍚嶄負simple-xml-2.7.1.jar錛涘簾璇濅笉澶氳翠簡錛屼唬鐮佹墠鏄鏈鐪熷疄闈犺氨鐨勫姏璇併
涓嬮潰鏄鏁翠釜Demo宸ョ▼鏂囦歡鎴鍥撅紝濡備笅鍥撅細

璇Demo涓昏佹槸閫氳繃simple-xml瑙ｆ瀽assets鐩褰曚腑鐨刣ata.xml鏂囦歡鍐呭規暟鎹錛岀劧鍚庢樉紺哄嚭鏉ワ紱
1.data.xml鏂囦歡鍐呭瑰備笅錛

[html] view plain
<?xml version="1.0" encoding="utf-8"?>
<resources>
<?xml version="1.0" encoding="utf-8"?>
<dataContent>
<group>
<groupID>1</groupID>
<groupName>絎涓緇</groupName>
<member>
<name>寮犱笁</name>
<age>22</age>
</member>
<member>
<name>鏉庡洓</name>
<age>24</age>
</member>
<member>
<name>嬈ч槼闆</name>
<age>18</age>
</member>
</group>
<group>
<groupID>2</groupID>
<groupName>絎浜岀粍</groupName>
<member>
<name>鍙稿緬闈</name>
<age>19</age>
</member>
<member>
<name>鍙剁瑱</name>
<age>26</age>
</member>
<member>
<name>鏉ㄩ</name>
<age>25</age>
</member>
</group>
<group>
<groupID>3</groupID>
<groupName>絎涓夌粍</groupName>
<member>
<name>鐜嬮緳</name>
<age>32</age>
</member>
<member>
<name>瑗塊棬鑳滅敺</name>
<age>21</age>
</member>
<member>
<name>寮犻摤</name>
<age>45</age>
</member>
</group>
</dataContent>

</resources>
閫氳繃涓婇潰鐨勬枃浠跺唴瀹癸紝鎴戜滑鐭ラ亾錛岃繖涓鏂囦歡鍐呭逛富瑕佹湁涓夌粍鏁版嵁錛屾瘡緇勬暟鎹鏈変釜涓変釜鎴愬憳緇勶紝姣忎釜鎴愬憳緇勯兘鏈夊悕瀛楀拰騫撮緞榪欎袱涓瀛愬厓緔犮侱emo涓灝嗚繖浜涜В鏋愬嚭鏉ュ唴瀹歸氳繃ExpandableListView鏄劇ず鍑烘潵銆

2.涓婚〉闈MainActivity浠ｇ爜濡備笅錛

[java] view plain
package com.steven.android.simple.xml.activity;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import org.simpleframework.xml.core.Persister;
import android.app.Activity;
import android.os.Bundle;
import android.text.TextUtils;
import android.util.Log;
import android.view.Menu;
import android.widget.ExpandableListView;
import com.steven.android.simple.xml.adapter.ExpandAdapter;
import com.steven.android.simple.xml.parse.DataParseResponse;
/**
* 鎻忚堪錛氫富欏甸潰
* @author stevenhu223
*
*/
public class MainActivity extends Activity {

private final String TAG = "MainActivity";
private ExpandableListView mExpandableListView;
private ExpandAdapter mAdapter;

@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
mExpandableListView = (ExpandableListView) findViewById(R.id.expanlist_content);
try {
matchAndParseData();
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}

@Override
public boolean onCreateOptionsMenu(Menu menu) {
// Inflate the menu; this adds items to the action bar if it is present.
getMenuInflater().inflate(R.menu.main, menu);
return true;
}

/**
* 鍖歸厤鑾峰彇鍜岃В鏋恱ml鏂囦歡鍐呭
* @throws Exception
*/
private void matchAndParseData() throws Exception {
InputStream inputStream = getResources().getAssets().open("data.xml");
String dataContent = convertStreamToString(inputStream);
String content = "";
//姝ｅ垯琛ㄨ揪寮忓尮閰
Pattern DATA_PATTERN= Pattern.compile("[\\S\\s]*(<dataContent>[\\s\\S]*</dataContent>)[\\s\\S]*");
Matcher matcher = DATA_PATTERN.matcher(dataContent);
if (matcher.matches()) {
//鑾峰彇鍖呭惈dataContent鍏冪礌鐨勫唴瀹
content = matcher.group(1);
}
if (!TextUtils.isEmpty(content)) {
DataParseResponse dataResponse = parseToBean(DataParseResponse.class, content);
mAdapter = new ExpandAdapter(this, dataResponse.mGroupEntities);
mExpandableListView.setAdapter(mAdapter);
}
}

/**
* 灝唜ml鏂囦歡鍐呭硅В鏋愭垚瀹炰綋綾

㈡ android中用xmlpullparser解析xml文件，以及res/raw和assets的不同

XML：可擴展標記語言
讀XML，XML文件的解析

三種解析XML的文件的方式
1.SAX事件驅動不是一次性載入到內存
2.DOM一次載入到內存，性能較差適合伺服器端編程
3.XMLPULL適應嵌入式設備，佔用內存較小API相對簡單

OpenAPI

JSON:相對於XML格式，更節省空間。
1)大括弧開始結束{}
2)內容部分每條數據以「，」分隔
3)每條數據由鍵值對構成，key必須是字元串「」
4)值可以是：String、double、int、long、boolean、
jsonObject、jsonArray

把要解析的XML文件放在assets目錄下，這里解釋下

res/raw和assets的相同點：
兩者目錄下的文件在打包後會原封不動的保存在apk包中，不會被編譯成二進制。
res/raw和assets的不同點：
1.res/raw中的文件會被映射到R.java文件中，訪問的時候直接使用資源ID即R.id.filename；assets文件夾下的文件不會被映射到R.java中，訪問的時候需要AssetManager類。
2.res/raw不可以有目錄結構，而assets則可以有目錄結構，也就是assets目錄下可以再建立文件夾
讀取文件資源：
1.讀取res/raw下的文件資源，通過以下方式獲取輸入流來進行寫操作
·InputStreamis=getResources().openRawResource(R.id.filename);
2.讀取assets下的文件資源，通過以下方式獲取輸入流來進行寫操作
·AssetManageram=null;
·am=getAssets();
·InputStreamis=am.open("filename");
注意1：Google的Android系統處理Assert有個bug，在AssertManager中不能處理單個超過1MB的文件，不然會報異常，raw沒這個限制可以放個4MB的Mp3文件沒問題。

注意2：assets文件夾是存放不進行編譯加工的原生文件，即該文件夾裡面的文件不會像xml，java文件被預編譯，可以存放一些圖片，html，js,css等文件。
解析如下文件


1

2

3

4

5

6

7

8<TextView

android:id="@+id/textView1"

android:layout_width="wrap_content"

android:layout_height="wrap_content"

android:layout_alignParentRight="true"

android:layout_alignTop="@+idtton1"

android:text="LargeText"

android:textAppearance="?android:attr/textAppearanceLarge"/>

代碼如下：


1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20XmlPullParserpullParser=Xml.newPullParser();//得到XML解析器

AssetManagerassetManager=getAssets();//文件保存在assets目錄下，得到assetManager管理器

InputStreamis;

try

{

is=assetManager.open("activity_main.xml");//打開文件，得到輸入流

pullParser.setInput(is,"utf-8");//StringinputEncoding格式

inteventType=pullParser.getEventType();//得到事件類型

while(eventType!=XmlPullParser.END_DOCUMENT)//文檔的末尾

{//遍歷內部的內容

Stringname=pullParser.getName();

if("TextView".equals(name))

{

Stringvalue=pullParser.getAttributeValue(2);//得到屬性值（位置）

textView.setText("顯示結果為："+value);

break;/到就返回

}

eventType=pullParser.next();//讀取下一個標簽

}

}


顯示結果為：

㈢ 關於android下面的xml解析

我用的是PULL解析，SAX，dom感覺都沒PULL好用

public class XmlParseService
{

public static List<Person> pullXML(InputStream in)
{

try
{

//創建一個PULL解析對象
//1)XmlPullParser parse= Xml.newPullParser();

XmlPullParserFactory xmlfactory=XmlPullParserFactory.newInstance();

XmlPullParser parse=xmlfactory.newPullParser();

parse.setInput(in, "utf-8");

int eventCode=parse.getEventType();

Person person = null;

List<Person> list = null;

while(eventCode!=XmlPullParser.END_DOCUMENT)
{

switch(eventCode)
{
//開始解析文檔
case XmlPullParser.START_DOCUMENT:
list = new ArrayList<Person>();
System.out.println("1111111開始文檔的解析");
break;

case XmlPullParser.START_TAG:

System.out.println("2222222開始解析標記");
if("person".equals(parse.getName()))
{
person = new Person();
person.setId(parse.getAttributeValue(0));

}
else
{
if("name".equals(parse.getName()))
{
person.setName(parse.nextText());
}
else if("age".equals(parse.getName()))
{
person.setAge(parse.nextText());
}
}

break;
case XmlPullParser.END_TAG:

System.out.println("33333333結束解析標記");
if("person".equals(parse.getName()))
{
if(person!=null)
{
list.add(person);
person = null;
}
}

break;
}

eventCode = parse.next();

}

in.close();

return list;

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

return null;

}

你自己創建一個XML，我用實體類PERSON封裝的

㈣ 如何用pull解析器解析androidmanifest.xml文件

PULL解析xml：
1、核心類：
XmlPullParserFactory
XmlPullParser
2、核心代碼：
// 實例化一個xml pull解析的工廠
XmlPullParserFactory factory = XmlPullParserFactory.newInstance();
// 實例化一個xml pull解析對象
XmlPullParser pullParser = factory.newPullParser();
// 將xml文件作為流傳入到inputstream
BufferedInputStream bis = new BufferedInputStream(
new FileInputStream("customers.xml"));
// xml解析對象接收輸入流對象
pullParser.setInput(bis, "utf-8");
int event = pullParser.getEventType();
List<Map<String, Object>> list = null;
Map<String, Object> map = null;
while (event != XmlPullParser.END_DOCUMENT) {
switch (event) {
case XmlPullParser.START_DOCUMENT:
list = new ArrayList<>();
break;
case XmlPullParser.START_TAG:
if ("customer".equals(pullParser.getName())) {
map = new HashMap<String, Object>();
}
if (pullParser.getName().equals("name")) {
map.put("name", pullParser.nextText());
}
if (pullParser.getName().equals("tel")) {
map.put("tel", pullParser.nextText());
}
// if (pullParser.getName().equals("email")) {
// map.put("email", pullParser.nextText());
// }
break;
case XmlPullParser.END_TAG:
if (pullParser.getName().equals("customer")) {
list.add(map);
}
break;
}
event = pullParser.next();
}

希望能幫助你！

㈤ android開發從後台獲取xml數據怎麼解析

Android--3種解析XML數據的步驟

採用DOM解析時具體處理步驟是：
1 首先利用DocumentBuilderFactory創建一個DocumentBuilderFactory實例
2 然後利用DocumentBuilderFactory創建DocumentBuilder
3 然後載入XML文檔（Document）,
4 然後獲取文檔的根結點(Element)，
5 然後獲取根結點中所有子節點的列表（NodeList），
6 然後使用再獲取子節點列表中的需要讀取的結點。

採用SAX解析時具體處理步驟是：
1 創建SAXParserFactory對象
2 根據SAXParserFactory.newSAXParser()方法返回一個SAXParser解析器
3 根據SAXParser解析器獲取事件源對象XMLReader
4 實例化一個DefaultHandler對象
5 連接事件源對象XMLReader到事件處理類DefaultHandler中
6 調用XMLReader的parse方法從輸入源中獲取到的xml數據
7 通過DefaultHandler返回我們需要的數據集合。

採用PULL解析基本處理方式：
1：當導航到XmlPullParser.START_DOCUMENT，可以不做處理，當然你可以實例化集合對象等等。
2：當導航到XmlPullParser.START_TAG，則判斷是否是river標簽，如果是，則實例化river對象，並調用getAttributeValue方法獲取標簽中屬性值。
3：當導航到其他標簽，比如Introction時候，則判斷river對象是否為空，如不為空，則取出Introction中的內容，nextText方法來獲取文本節點內容
4：它一定會導航到XmlPullParser.END_TAG的，有開始就要有結束嘛。在這里我們就需要判讀是否是river結束標簽，如果是，則把river對象存進list集合中了，並設置river對象為null.

幾種解析技術的比較與總結：
對於Android的移動設備而言，因為設備的資源比較寶貴，內存是有限的，所以我們需要選擇適合的技術來解析XML，這樣有利於提高訪問的速度。
1 DOM在處理XML文件時，將XML文件解析成樹狀結構並放入內存中進行處理。當XML文件較小時，我們可以選DOM，因為它簡單、直觀。www.2cto.com
2 SAX則是以事件作為解析XML文件的模式，它將XML文件轉化成一系列的事件，由不同的事件處理器來決定如何處理。XML文件較大時，選擇SAX技術是比較合理的。雖然代碼量有些大，但是它不需要將所有的XML文件載入到內存中。這樣對於有限的Android內存更有效，而且Android提供了一種傳統的SAX使用方法以及一個便捷的SAX包裝器。
3 XML pull解析並未像SAX解析那樣監聽元素的結束，而是在開始處完成了大部分處理。這有利於提早讀取XML文件，可以極大的減少解析時間，這種優化對於連接速度較漫的移動設備而言尤為重要。對於XML文檔較大但只需要文檔的一部分時，XML Pull解析器則是更為有效的方法。

。。具體你可以再查看相關資料。

㈥ Android將這xml文件用sax方式解析怎麼弄

在 Android中解析XML文主要有三種方式，分別為Simple API for XML(SAX)、Document Object Model(DOM)和Android附帶的PULL解析器。其中SAX是一個解析速度非常快並且佔用內存少的XML解析器，非常適合Android手機等移動設備。
SAX解析XML文件採用事件驅動的方式進行，也就是說，SAX是逐行掃描文件，遇到符合條件的設定條件後就會觸發特定的事件，回調你寫好的事件處理程序。使用SAX的優勢在於其解析速度較快，佔用內存較少(相對於DOM而言)。而且SAX在解析文件的過程中得到自己需要的信息後可以隨時終止解析，並不一定要等文件全部解析完畢。凡事有利必有弊，其劣勢在於SAX採用的是流式處理方式，當遇到某個標簽的時候，它並不會記錄下以前所遇到的標簽，也就是說，在處理某個標簽的時候，比如在 startElement方法中，所能夠得到的信息就是標簽的名字和屬性，至於標簽內部的嵌套結構，上層標簽、下層標簽以及其兄弟節點的名稱等等與其結構相關的信息都是不得而知的。實際上就是把XML文件的結構信息丟掉了，如果需要得到這些信息的話，只能你自己在程序里進行處理了。所以相對DOM而言，SAX處理XML文檔沒有DOM方便，SAX處理的過程相對DOM而言也比較復雜。
使用SAX解析XML文件一般有以下五個步驟：
1、創建一個SAXParserFactory對象(通過類名很容易得知它利用工廠方法模式實現的)；
2、調用SAXParserFactory中的newSAXParser方法創建一個SAXParser對象；
3、然後在調用SAXParser中的getXMLReader方法獲取一個XMLReader對象；
4、在XMLReader中注冊事件處理介面，一般有ContentHandler、ErrorHandler、DTDHandler、EntityHandler四種；
5、調用XMLReader中的parse方法解析指定的XML字元串對象；
步驟四中提到的四個Handler是事件處理介面，SAX的事件處理函數就定義在這四個介面中，利用SAX解析XML文件需要重寫介面中的方法。其中ContentHandler用來處理XML中的內容，ErrorHandler用來處理錯誤，DTDHandler用來處理DTD，EntityHandler用來處理XML文檔中的實體；最常用的是ContentHandler這個介面，下面是該介面中的一些常用方法：
startDocument()
當遇到文檔的開頭的時候，調用這個方法，可以在其中做一些預處理的工作。
endDocument()
和上面的方法相對應，當文檔結束的時候，調用這個方法，可以在其中做一些善後的工作。
startElement(String uri, String localName, String qName, Attributes atts)
當讀到一個開始標簽的時候，會觸發這個方法。uri是命名空間(通過xmlns聲明)，localName是不帶命名空間前綴的標簽名，qName是帶命名空間前綴的標簽名。通過atts可以得到所有的屬性名和相應的值。注意，如果沒有指定Namespace，則qName可能為空，當然不同的SAX實現會有所不同，比如在Android中qName為空，而J2SE中localName為空，所以想要總是得到標簽名，就需要檢查這兩個參數的值了。
endElement(String uri, String localName, String name)
這個方法和上面的方法相對應，在遇到結束標簽的時候，調用這個方法。
characters(char[] ch, int start, int length)
這個方法用來處理在XML文件中讀到的內容，第一個參數為文件的字元串內容，後面兩個參數是讀到的字元串在這個數組中的起始位置和長度，使用new String(ch,start,length)就可以獲取內容。
下面是利用SAX解析XML文件的DEMO程序，首先定義一個XML文件users.xml，內容如下：
01 <?xml version="1.0" encoding="utf-8"?>
02 <users>
03 <user id="1">
04 <name>wuxianglong</name>
05 <password>199098</password>
06 </user>
07 <long:user id="2">
08 <name>wuwenyuan</name>
09 <password>199189</password>
10 </long:user>
11 </users>

其中第二個user標簽中字元串long就是所謂的前綴，標簽中的id則是該標簽的一個屬性。

然後我們來實現ContentHandler這個介面，並重寫其中的方法來處理上面的XML文件，代碼如下：
01 package sax.test;
02
03 import java.util.ArrayList;
04
05 import org.xml.sax.Attributes;
06 import org.xml.sax.SAXException;
07 import org.xml.sax.helpers.DefaultHandler;
08
09 public class MyHandler extends DefaultHandler {
10 private ArrayList<User> users;
11 private User user;
12 private String content;
13
14 public ArrayList<User> getUsers() {
15 return users;
16 }
17
18 @Override
19 public void startDocument() throws SAXException {
20 super.startDocument();
21 users = new ArrayList<User>();
22 System.out.println("----------Start Parse Document----------" );
23 }
24
25 @Override
26 public void endDocument() throws SAXException {
27 System.out.println("----------End Parse Document----------" );
28 }
29
30 @Override
31 public void characters(char[] ch, int start, int length)
32 throws SAXException {
33 super.characters(ch, start, length);
34 // 獲得標簽中的文本
35 content = new String(ch, start, length);
36 }
37
38 @Override
39 public void startElement(String uri, String localName, String qName,
40 Attributes attributes) throws SAXException {
41 super.startElement(uri, localName, qName, attributes);
42 // 列印出localname和qName
43 System.out.println("LocalName->" + localName);
44 System.out.println("QName->" + qName);
45 if ("user".equals(localName)) {
46 user = new User();
47 user.setId(Integer.parseInt(attributes.getValue("id")));
48 }
49 }
50
51 @Override
52 public void endElement(String uri, String localName, String qName)
53 throws SAXException {
54 super.endElement(uri, localName, qName);
55 if ("name".equals(localName)) {
56 user.setName(content);
57 } else if ("password".equals(localName)) {
58 user.setPassword(content);
59 } else if ("user".equals(localName)) {
60 users.add(user);
61 }
62 }
63 }

最後我們編輯TestSAX這個類，獲取users.xml這個文件中的內容，並利用SAX進行解析，代碼如下：
01 package sax.test;
02
03 import java.io.IOException;
04
05 import javax.xml.parsers.ParserConfigurationException;
06 import javax.xml.parsers.SAXParser;
07 import javax.xml.parsers.SAXParserFactory;
08
09 import org.xml.sax.InputSource;
10 import org.xml.sax.SAXException;
11 import org.xml.sax.XMLReader;
12
13 import android.app.Activity;
14 import android.os.Bundle;
15 import android.widget.TextView;
16
17 public class TestSAX extends Activity {
18 private TextView text;
19
20 /** Called when the activity is first created. */
21 @Override
22 public void onCreate(Bundle savedInstanceState) {
23 super.onCreate(savedInstanceState);
24 setContentView(R.layout.main);
25
26 text = (TextView) findViewById(R.id.result);
27
28 try {
29 // 創建一個工廠對象
30 SAXParserFactory factory = SAXParserFactory.newInstance();
31 // 通過工廠對象得到一個解析器對象
32 SAXParser parser = factory.newSAXParser();
33 // 通過parser得到XMLReader對象
34 XMLReader reader = parser.getXMLReader();
35 // 為reader對象注冊事件處理介面
36 MyHandler handler = new MyHandler();
37 reader.setContentHandler(handler);
38 // 解析指定XML字元串對象
39 reader.parse(newInputSource(TestSAX.class.getClassLoader().getResourceAsStream("users.xml")));
40
41 String usersInfo = "";
42 for (User user : handler.getUsers()) {
43 usersInfo += "ID->" + user.getId() + "\n";
44 usersInfo += "NAME->" + user.getName() + "\n";
45 usersInfo += "PASSWORD->" + user.getPassword() + "\n";
46 usersInfo += "\n\n";
47 }
48 text.setText(usersInfo);
49 } catch (SAXException e) {
50 e.printStackTrace();
51 } catch (ParserConfigurationException e) {
52 e.printStackTrace();
53 } catch (IOException e) {
54 e.printStackTrace();
55 }
56 }
57
58 }

㈦ and android:解析xml，一個節點標簽中，有多個屬性，怎樣解析

定義好對象關系的類。

解析以Course為例子

publicstaticList<Course>getCourseList(InputStreamstream){
List<Course>list=newArrayList<Course>();

//得到DocumentBuilderFactory對象,由該對象可以得到DocumentBuilder對象
DocumentBuilderFactoryfactory=DocumentBuilderFactory.newInstance();

try{
//得到DocumentBuilder對象
DocumentBuilderbuilder=factory.newDocumentBuilder();
//得到代表整個xml的Document對象
Documentdocument=builder.parse(stream);
//得到"根節點"
Elementroot=document.getDocumentElement();
//獲取根節點的所有items的節點
NodeListitems=root.getElementsByTagName("item");
//遍歷所有節點
for(inti=0;i<items.getLength();i++){
Coursecourse=newCourse();
Elementitem=(Element)items.item(i);
course.setName(item.getAttribute("name"));
//再枚舉子節點
list.add(course);
}

}catch(ParserConfigurationExceptione){
e.printStackTrace();
}catch(SAXExceptione){
e.printStackTrace();
}catch(IOExceptione){
e.printStackTrace();
}

returnlist;
}

㈧ android中怎麼解析復雜的xml文件

本文主要講解Android開發中如何對XML文件的解析，由於XML文件具有與平台無關，廣泛應用於數據通信中，因此解析XML文件就顯得很有意義。Android對XML文件解析的方法主要有3種。 通常有三種方式:DOM、SAX和PULL，下面就分別針對這三種方式來進行討論。

文件內容如下所示：
那麼就是要對此XML文件做解析。下面我們就分別用DOM,SAX和PULL三種方式，分別對此XML文件做解析。

DOM方式

DOM方式解析xml是先把xml文檔都讀到內存中，然後再用DOM API來訪問樹形結構，並獲取數據。由DOM解析的方式可以知道，如果XML文件很大的時候，處理效率就會變得比較低，這也是DOM方式的一個缺點。
現在我們來解析上文中提到的有關天氣預報信息相關的xml文件。什麼是解析呢？說的通俗一點，就是將這個帶標簽的XML文件識別出來，並抽取一些相關的，對我們有用的信息來給我們使用。那在這個文件里，時間，天氣，溫度，以及圖標對我們來說是需要得到的。我們要對其做解析。
解析的具體思路是：
1. 將XML文件載入進來。
2. 獲取文檔的根節點
3. 獲取文檔根節點中所有子節點的列表
4. 獲取子節點列表中需要讀取的節點信息
根據這4個步驟，我們進行開發：
首先就是如何載入XML文件，假設此文件來源於網路。

SAX方式

SAX是Simple API for XML的縮寫。是一個包也可以看成是一些介面。
相比於DOM而言SAX是一種速度更快，更有效，佔用內存更少的解析XML文件的方法。它是逐行掃描，可以做到邊掃描邊解析，因此SAX可以在解析文檔的任意時刻停止解析。非常適用於Android等移動設備。
SAX是基於事件驅動的。所謂事件驅動就是說，它不用解析完整個文檔，在按內容順序解析文檔過程中，SAX會判斷當前讀到的字元是否符合XML文件語法中的某部分。如果符合某部分，則會觸發事件。所謂觸發事件，就是調用一些回調方法。當然android的事件機制是基於回調方法的，在用SAX解析xml文檔時候，在讀取到文檔開始和結束標簽時候就會回調一個事件，在讀取到其他節點與內容時候也會回調一個事件。在SAX介面中，事件源是org.xml.sax包中的XMLReader，它通過parser()方法來解析XML文檔，並產生事件。事件處理器是org.xml.sax包中ContentHander、DTDHander、ErrorHandler，以及EntityResolver這4個介面。
這四個介面的詳細說明如下：

事件處理器名稱

事件處理器處理的事件

XMLReader注冊方法

ContentHander

XML文檔的開始與結束，
XML文檔標簽的開始與結束，接收字元數據，跳過實體，接收元素內容中可忽略的空白等。

setContentHandler(ContentHandler h)

DTDHander

處理DTD解析時產生的相應事件

setDTDHandler(DTDHandler h)

ErrorHandler

處理XML文檔時產生的錯誤

setErrorHandler(ErrorHandler h)

EntityResolver

處理外部實體

setEntityResolver(EntityResolver e)

我們用來做內容解析的回調方法一般都定義在ContentHandler介面中。
ContentHandler介面常用的方法：
startDocument()
當遇到文檔的開頭的時候，調用這個方法，可以在其中做一些預處理的工作。
endDocument()
當文檔結束的時候，調用這個方法，可以在其中做一些善後的工作。
startElement(String namespaceURI, String localName,String qName, Attributes atts)
當讀到開始標簽的時候，會調用這個方法。namespaceURI就是命名空間，localName是不帶命名空間前綴的標簽名，qName是帶命名空間前綴的標簽名。通過atts可以得到所有的屬性名和相應的值。
endElement(String uri, String localName, String name)
在遇到結束標簽的時候，調用這個方法。
characters(char[] ch, int start, int length)
這個方法用來處理在XML文件中讀到的內容。例如：<high data="30"/>主要目的是獲取high標簽中的值。
第一個參數用於存放文件的內容，後面兩個參數是讀到的字元串在這個數組中的起始位置和長度，使用new String(ch,start,length)就可以獲取內容。
注意：
SAX的一個重要特點就是它的流式處理，當遇到一個標簽的時候，它並不會紀錄下之前所碰到的標簽，即在startElement()方法中，所有能夠知道的信息，就是標簽的名字和屬性，至於標簽的嵌套結構，上層標簽的名字，是否有子元屬等等其它與結構相關的信息，都是不知道的，都需要你的程序來完成。這使得SAX在編程處理上沒有DOM方便。
現在我們截取一段XML文件來做解析，其調用方法是這樣的：
<?xml version="1.0"?> ----------> startDocument()
<weather> ----------> startElement
<forecast_information> ----------> startElement
<city> ----------> startElement
beijing ----------> characters
</city> ----------> endElement
</forecast_information > ----------> endElement
</weather > ----------> endElement
文檔結束 ----------> endDocument()
SAX的解析步驟：
首先需要注意的是：
SAX還為其制定了一個Helper類：DefaultHandler它實現了ContentHandler這個介面，但是其所有的方法體都為空，在實現的時候，你只需要繼承這個類，然後重載相應的方法即可。
使用SAX解析XML文件一般有以下五個步驟：
1、創建一個SAXParserFactory對象；
2、調用SAXParserFactory中的newSAXParser方法創建一個SAXParser對象；
3、然後在調用SAXParser中的getXMLReader方法獲取一個XMLReader對象；
4、實例化一個DefaultHandler對象
5、連接事件源對象XMLReader到事件處理類DefaultHandler中
6、調用XMLReader的parse方法從輸入源中獲取到的xml數據
7、通過DefaultHandler返回我們需要的數據集合。
我們仍然來解析上述那個天氣預報的XML文件。
編寫代碼如下：

[java] view plain
mySAX.setOnClickListener(new Button.OnClickListener(){
@Override
public void onClick(View v) {
try{
String url = "http://www.google.com/ig/api?&weather=beijing";
DefaultHttpClient client = new DefaultHttpClient();
HttpUriRequest req = new HttpGet(url);
HttpResponse resp = client.execute(req);
HttpEntity ent = resp.getEntity();
InputStream stream = ent.getContent(); //將文件導入流，因此用InputStream

SAXParserFactory saxFactory = SAXParserFactory.newInstance(); //獲取一個對象
SAXParser saxParser = saxFactory.newSAXParser();//利用獲取到的對象創建一個解析器
XMLContentHandler handler = new XMLContentHandler();//設置defaultHandler
saxParser.parse(stream, handler);//進行解析
stream.close();//關閉流
/*XMLReader xmlReader = saxFactory.newSAXParser().getXMLReader(); //獲取一個XMLReader
xmlReader.setContentHandler(handler);
xmlReader.parse(new InputSource(stream));
stream.close();*/
}catch(Exception e){
e.printStackTrace();
}
}
});
}
public class XMLContentHandler extends DefaultHandler {
private static final String TAG = "XMLContentHandler";

@Override
public void characters(char[] ch, int start, int length)
throws SAXException {
Log.i(TAG, "解析內容："+new String(ch,start,length));
}
@Override
public void endDocument() throws SAXException {
super.endDocument();
Log.i(TAG, "文檔解析完畢。");
}
@Override
public void endElement(String uri, String localName, String qName)
throws SAXException {
Log.i(TAG, localName+"解析完畢");
}
@Override
public void startDocument() throws SAXException {
Log.i(TAG, "開始解析... ...");
}
@Override
public void startElement(String uri, String localName, String qName,
Attributes attributes) throws SAXException {
Log.i(TAG, "解析元素："+localName);

if(localName.equals("high")){
Log.i(TAG, "解析元素："+localName);
i++;
if(i==2){
highestTmp.setText(String.valueOf((Integer.parseInt(attributes.getValue(0))-32)*5/9));
}
}
}
}

上面的那段注釋：

[java] view plain
/*XMLReader xmlReader =saxFactory.newSAXParser().getXMLReader(); //獲取一個XMLReader
xmlReader.setContentHandler(handler);
xmlReader.parse(newInputSource(stream));
stream.close();*/

是用XMLReader來做解析的另外一種方法。效果是一樣的。這里可以傳流，也可以傳一個字元串，如下所示：是傳字元串。
[java] view plain
xmlReader.parse(new InputSource(new StringReader(xmlStr)));
PULL方式
除了可以使用 SAX和DOM解析XML文件，也可以使用Android內置的Pull解析器解析XML文件。 Pull解析器的運行方式與 SAX 解析器相似。它也是事件觸發的。Pull解析方式讓應用程序完全控制文檔該怎麼樣被解析。比如開始和結束元素事件，使用parser.next()可以進入下一個元素並觸發相應事件。通過Parser.getEventType()方法來取得事件的代碼值，解析是在開始時就完成了大部分處理。事件將作為數值代碼被發送，因此可以使用一個switch對感興趣的事件進行處理。
Pull解析是一個遍歷文檔的過程，每次調用next()，nextTag(), nextToken()和nextText()都會向前推進文檔，並使Parser停留在某些事件上面，但是不能倒退。然後把文檔設置給Parser。
Android中對Pull方法提供了支持的API，主要是
org.xmlpull.v1.XmlPullParser;
org.xmlpull.v1.XmlPullParserFactory;
二個類，其中主要使用的是XmlPullParser，XmlPullParserFactory是一個工廠，用於構建XmlPullParser對象。
應用程序通過調用XmlPullParser.next()等方法來產生Event，然後再處理Event。
我們仍然拿上述天氣預報的XML文件的一部分來做例子。
例如：需要解析的XML文件是：

[java] view plain
<forecast_conditions>
<day_of_week data="周三"/>
<low data="22"/>
<high data="29"/>
<icon data="/ig/images/weather/chance_of_rain.gif"/>
<condition data="可能有雨"/>
</forecast_conditions>

這部分XML文件中day_of_week,low,high等是TAG，data是ATTRIBUTEA。當然，如果有<></>夾在開始和結束符號之間的部分，則為TXET。
要想解析文檔先要構建一個XmlPullParser對象。

[java] view plain
final XmlPullParserFactory factory = XmlPullParserFactory.newInstance();
factory.setNamespaceAware(true);
final XmlPullParser parser = factory.newPullParser();
parser.setInput(new StringReader("xmlStr");

這里的xmlStr就是上邊的XML文件。
此時，文檔剛被初始化，所以它應該位於文檔的開始，事件為START_DOCUMENT，可以通過XmlPullParser.getEventType()來獲取。然後調用next()會產生
START_TAG，這個事件告訴應用程序一個標簽已經開始了，調用getName()會返回" day_of_week ";若有TEXT，則再next()會產生TEXT事件，調用getText()會返回TEXT，由於此處沒有，所以再next()，會產生END_TAG，這個告訴你一個標簽已經處理完了，再next()直到最後處理完TAG，會產生END_DOCUMENT，它告訴你整個文檔已經處理完成了。除了next()外，nextToken()也可以使用，只不過它會返回更加詳細的事件，比如COMMENT, CDSECT, DOCDECL, ENTITY等等非常詳細的信息。如果程序得到比較底層的信息，可以用nextToken()來驅動並處理詳細的事件。需要注意一點的是TEXT事件是有可能返回空白的White Spaces比如換行符或空格等。
nextTag()--會忽略White Spaces，如果可以確定下一個是START_TAG或END_TAG，就可以調用nextTag()直接跳過去。通常它有二個用處：當START_TAG時，如果能確定這個TAG含有子TAG，那麼就可以調用nextTag()產生子標簽的START_TAG事件；當END_TAG時，如果確定不是文檔結尾，就可以調用nextTag()產生下一個標簽的START_TAG。在這二種情況下如果用next()會有TEXT事件，但返回的是換行符或空白符。
nextText()--只能在START_TAG時調用。當下一個元素是TEXT時，TEXT的內容會返回；當下一個元素是END_TAG時，也就是說這個標簽的內容為空，那麼空字串返回；這個方法返回後，Parser會停在END_TAG上。

小結一下，如果在一個XML文檔中我們只需要前面一部分數據，但是使用SAX方式或DOM方式會對整個文檔進行解析，盡管XML文檔中後面的大部分數據我們其實都不需要解析，因此這樣實際上就浪費了處理資源。使用PULL方式正合適。
當點擊三種方式的任何一個按鈕時，均能夠得到相同的結果

㈨ 在android中怎麼使用pullparse解析.xml文件

Pull解析器的運行方式與 SAX 解析器相似。它提供了類似的事件，如：開始元素和結束元素事件，使用parser.next()可以進入下一個元素並觸發相應事件。跟SAX不同的是， Pull解析器產生的事件是一個數字，而非方法，因此可以使用一個switch對感興趣的事件進行處理。當元素開始解析時，調用parser.nextText()方法可以獲取下一個Text類型節點的值。
下面我們通過Demo例子來介紹如何使用PULL機制來解析XML文件。先看下如下工程的目錄結構：

按以下步驟進行操作：
[1] 新建一個XML文件，命名為student.xml。同時把XML文件放置到assets目錄下。student.xml文件的內容如下：
[html] view plain
<?xml version="1.0" encoding="utf-8"?>
<students>
<student id="20110806100">
<name>小明</name>
<age>22</age>
<sex>男</sex>
</student>
<student id="20110806101">
<name>小李</name>
<age>24</age>
<sex>男</sex>
</student>
<student id="20110806102">
<name>小麗</name>
<age>21</age>
<sex>女</sex>
</student>
</students>

[2] 根據XML文件中的節點目錄，創建一個相對應的實體類，來保存解析的相應信息。在包：com.andyidea.entity下新建Student.java類。
[html] view plain
package com.andyidea.entity;

public class Student {

private String id;
private String name;
private int age;
private String sex;

public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}

}

[3] 定義一個使用PULL解析XML文件的工具類：ParserByPULL.java。
[html] view plain
package com.andyidea.util;

import java.io.InputStream;
import java.util.ArrayList;
import java.util.List;

import org.xmlpull.v1.XmlPullParser;
import org.xmlpull.v1.XmlPullParserFactory;

import android.util.Xml;

import com.andyidea.entity.Student;

public class ParserByPULL {

//採用XmlPullParser來解析XML文件
public static List<Student> getStudents(InputStream inStream) throws Throwable
{
List<Student> students = null;
Student mStudent = null;

//========創建XmlPullParser,有兩種方式=======
//方式一:使用工廠類XmlPullParserFactory
XmlPullParserFactory pullFactory = XmlPullParserFactory.newInstance();
XmlPullParser parser = pullFactory.newPullParser();
//方式二:使用Android提供的實用工具類android.util.Xml
//XmlPullParser parser = Xml.newPullParser();

//解析文件輸入流
parser.setInput(inStream, "UTF-8");
//產生第一個事件
int eventType = parser.getEventType();
//只要不是文檔結束事件，就一直循環
while(eventType!=XmlPullParser.END_DOCUMENT)
{
switch (eventType)
{
//觸發開始文檔事件
case XmlPullParser.START_DOCUMENT:
students = new ArrayList<Student>();
break;
//觸發開始元素事件
case XmlPullParser.START_TAG:
//獲取解析器當前指向的元素的名稱
String name = parser.getName();
if("student".equals(name))
{
//通過解析器獲取id的元素值，並設置student的id
mStudent = new Student();
mStudent.setId(parser.getAttributeValue(0));
}
if(mStudent!=null)
{
if("name".equals(name))
{
//獲取解析器當前指向元素的下一個文本節點的值
mStudent.setName(parser.nextText());
}
if("age".equals(name))
{
//獲取解析器當前指向元素的下一個文本節點的值
mStudent.setAge(new Short(parser.nextText()));
}
if("sex".equals(name))
{
//獲取解析器當前指向元素的下一個文本節點的值
mStudent.setSex(parser.nextText());
}
}
break;
//觸發結束元素事件
case XmlPullParser.END_TAG:
//
if("student".equals(parser.getName()))
{
students.add(mStudent);
mStudent = null;
}
break;
default:
break;
}
eventType = parser.next();
}
return students;
}