sax dom pull 解析xml

一 sax 解析：注意空格。

1.   Java Sax解析是按照xml文件的顺序一步一步的来解析，在解析xml文件之前，我们要先了解xml文件的节点的种类，一种是ElementNode，一种是TextNode。如下面的这段book.xml

Xml代码  

1. <?xml version="1.0" encoding="UTF-8"?>  
2. <books>  
3.     <book id="12">  
4.         <name>thinking in java</name>  
5.         <price>85.5</price>  
6.     </book>  
7.     <book id="15">  
8.         <name>Spring in Action</name>  
9.         <price>39.0</price>  
10.     </book>  
11. </books>  

其中，像<books>、<book>这种节点就属于ElementNode,而thinking in java、85.5这种就属于TextNode。

下面结合一张图来详细讲解Sax解析。

xml文件被Sax解析器载入，由于Sax解析是按照xml文件的顺序来解析，当读入<?xml.....>时，会调用startDocument()方法，当读入<books>的时候，由于它是个ElementNode，所以会调用startElement(String uri, String localName, String qName, Attributes attributes) 方法，其中第二个参数就是节点的名称，注意：由于有些环境不一样，有时候第二个参数有可能为空，所以可以使用第三个参数，因此在解析前，先调用一下看哪个参数能用，第4个参数是这个节点的属性。这里我们不需要这个节点，所以从<book>这个节点开始，也就是图中1的位置，当读入时，调用startElement(....)方法，由于只有一个属性id，可以通过attributes.getValue(0)来得到，然后在图中标明2的地方会调用characters(char[] ch, int start, int length)方法，不要以为那里是空白，Sax解析器可不那么认为，Sax解析器会把它认为是一个TextNode。但是这个空白不是我们想要的数据，我们是想要<name>节点下的文本信息。这就要定义一个记录当上一节点的名称的TAG，在characters(.....)方法中，判断当前节点是不是name，是再取值，才能取到thinking in java。具体见代码：SaxParseService.java

Java代码  

1. import java.io.InputStream;  
2. import java.util.ArrayList;  
3. import java.util.List;  
4.   
5. import javax.xml.parsers.SAXParser;  
6. import javax.xml.parsers.SAXParserFactory;  
7.   
8. import org.xml.sax.Attributes;  
9. import org.xml.sax.SAXException;  
10. import org.xml.sax.helpers.DefaultHandler;  
11.   
12. import com.xtlh.cn.entity.Book;  
13.   
14. public class SaxParseService extends DefaultHandler{  
15.     private List<Book> books = null;  
16.     private Book book = null;  
17.     private String preTag = null;//作用是记录解析时的上一个节点名称  
18.       
19.     public List<Book> getBooks(InputStream xmlStream) throws Exception{  
20.         SAXParserFactory factory = SAXParserFactory.newInstance();  
21.         SAXParser parser = factory.newSAXParser();  
22.         SaxParseService handler = new SaxParseService();  
23.         parser.parse(xmlStream, handler);  
24.         return handler.getBooks();  
25.     }  
26.       
27.     public List<Book> getBooks(){  
28.         return books;  
29.     }  
30.       
31.     @Override  
32.     public void startDocument() throws SAXException {  
33.         books = new ArrayList<Book>();  
34.     }  
35.   
36.     @Override  
37.     public void startElement(String uri, String localName, String qName, Attributes attributes) throws SAXException {  
38.         if("book".equals(qName)){  
39.             book = new Book();  
40.             book.setId(Integer.parseInt(attributes.getValue(0)));  
41.         }  
42.         preTag = qName;//将正在解析的节点名称赋给preTag  
43.     }  
44.   
45.     @Override  
46.     public void endElement(String uri, String localName, String qName)  
47.             throws SAXException {  
48.         if("book".equals(qName)){  
49.             books.add(book);  
50.             book = null;  
51.         }  
52.         preTag = null;/**当解析结束时置为空。这里很重要，例如，当图中画3的位置结束后，会调用这个方法 
53.         ，如果这里不把preTag置为null，根据startElement(....)方法，preTag的值还是book，当文档顺序读到图 
54.         中标记4的位置时，会执行characters(char[] ch, int start, int length)这个方法，而characters(....)方 
55.         法判断preTag!=null，会执行if判断的代码，这样就会把空值赋值给book，这不是我们想要的。*/  
56.     }  
57.       
58.     @Override  
59.     public void characters(char[] ch, int start, int length) throws SAXException {  
60.         if(preTag!=null){  
61.             String content = new String(ch,start,length);  
62.             if("name".equals(preTag)){  
63.                 book.setName(content);  
64.             }else if("price".equals(preTag)){  
65.                 book.setPrice(Float.parseFloat(content));  
66.             }  
67.         }  
68.     }  
69.       
70. }  

  Book.java如下：主要是用来组装数据

Java代码  

1. public class Book {  
2.     private int id;  
3.     private String name;  
4.     private float price;  
5.     public int getId() {  
6.         return id;  
7.     }  
8.     public void setId(int id) {  
9.         this.id = id;  
10.     }  
11.     public String getName() {  
12.         return name;  
13.     }  
14.     public void setName(String name) {  
15.         this.name = name;  
16.     }  
17.     public float getPrice() {  
18.         return price;  
19.     }  
20.     public void setPrice(float price) {  
21.         this.price = price;  
22.     }  
23.     @Override  
24.     public String toString(){  
25.         return this.id+":"+this.name+":"+this.price;  
26.     }  
27. }  

 测试是用的单元测试，测试代码如下：ParseTest

Java代码  

1. import java.io.InputStream;  
2. import java.util.List;  
3.   
4. import junit.framework.TestCase;  
5.   
6. import com.xtlh.cn.demo.DomParseService;  
7. import com.xtlh.cn.demo.SaxParseService;  
8. import com.xtlh.cn.entity.Book;  
9.   
10. public class ParseTest extends TestCase{  
11.   
12.     public void testSAX() throws Throwable{  
13.         SaxParseService sax = new SaxParseService();  
14.         InputStream input = this.getClass().getClassLoader().getResourceAsStream("book.xml");  
15.         List<Book> books = sax.getBooks(input);  
16.         for(Book book : books){  
17.             System.out.println(book.toString());  
18.         }  
19.     }  
20. }  

 在用Sax解析的时候最需要重视的一点就是不要把那些<节点>之间的空白忽略就好！

二  JAVA使用DOM解析XML: 注意空格，空格也属于子节点。

首先来了解点Java DOM 的 API:
1.解析器工厂类：DocumentBuilderFactory

创建的方法：DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();

2.解析器：DocumentBuilder

创建方法：通过解析器工厂类来获得 DocumentBuilder db = dbf.newDocumentBuilder();

3.文档树模型Document

创建方法：a.通过xml文档 Document doc = db.parse("bean.xml");  b.将需要解析的xml文档转化为输入流InputStream is = new FileInputStream("bean.xml");

 Document doc = db.parse(is); 

Document对象代表了一个XML文档的模型树，所有的其他Node都以一定的顺序包含在Document对象之内，排列成一个树状结构，以后对XML文档的所有操作都与解析器无关，

直接在这个Document对象上进行操作即可；

 包含的方法：

4.节点列表类NodeList

NodeList代表了一个包含一个或者多个Node的列表，根据操作可以将其简化的看做为数组

5.节点类Node

Node对象是DOM中最基本的对象，代表了文档树中的抽象节点。但在实际使用中很少会直接使用Node对象，而是使用Node对象的子对象Element,Attr,Text等

6.元素类Element

是Node类最主要的子对象，在元素中可以包含属性，因而Element中有存取其属性的方法

7.属性类Attr

代表某个元素的属性，虽然Attr继承自Node接口，但因为Attr是包含在Element中的，但并不能将其看做是Element的子对象，因为Attr并不是DOM树的一部分

基本的知识就到此结束，更加具体的大家可以参阅JDK API文档

代码：

1.使用DOM来遍历XML文档中的全部内容并且插入元素：

school.xml文档：

[html] view plaincopyprint?

1. <?xml version = "1.0" encoding = "utf-8"?>  
2. <School>  
3.     <Student>  
4.         <Name>沈浪</Name>  
5.         <Num>1006010022</Num>  
6.         <Classes>信管2</Classes>  
7.         <Address>浙江杭州3</Address>  
8.         <Tel>123456</Tel>  
9.     </Student>  
10.     <Student>  
11.         <Name>沈1</Name>  
12.         <Num>1006010033</Num>  
13.         <Classes>信管1</Classes>  
14.         <Address>浙江杭州4</Address>  
15.         <Tel>234567</Tel>  
16.     </Student>  
17.     <Student>  
18.         <Name>沈2</Name>  
19.         <Num>1006010044</Num>  
20.         <Classes>生工2</Classes>  
21.         <Address>浙江杭州1</Address>  
22.         <Tel>345678</Tel>  
23.     </Student>  
24.     <Student>  
25.         <Name>沈3</Name>  
26.         <Num>1006010055</Num>  
27.         <Classes>电子2</Classes>  
28.         <Address>浙江杭州2</Address>  
29.         <Tel>456789</Tel>  
30.     </Student>  
31. </School>  

DomDemo.java

[java] view plaincopyprint?

1. package xidian.sl.dom;  
2.   
3. import java.io.FileOutputStream;  
4.   
5. import javax.xml.parsers.DocumentBuilder;  
6. import javax.xml.parsers.DocumentBuilderFactory;  
7.   
8. import org.apache.crimson.tree.XmlDocument;  
9. import org.w3c.dom.Document;  
10. import org.w3c.dom.Element;  
11. import org.w3c.dom.NodeList;  
12.   
13.   
14. public class DomDemo {  
15.     /** 
16.      * 遍历xml文档 
17.      * */  
18.     public static void queryXml(){  
19.         try{  
20.             //得到DOM解析器的工厂实例  
21.             DocumentBuilderFactory dbFactory = DocumentBuilderFactory.newInstance();  
22.             //从DOM工厂中获得DOM解析器  
23.             DocumentBuilder dbBuilder = dbFactory.newDocumentBuilder();  
24.             //把要解析的xml文档读入DOM解析器  
25.             Document doc = dbBuilder.parse("src/xidian/sl/dom/school.xml");  
26.             System.out.println("处理该文档的DomImplementation对象  = "+ doc.getImplementation());  
27.             //得到文档名称为Student的元素的节点列表  
28.             NodeList nList = doc.getElementsByTagName("Student");  
29.             //遍历该集合，显示结合中的元素及其子元素的名字  
30.             for(int i = 0; i< nList.getLength() ; i ++){  
31.                 Element node = (Element)nList.item(i);  
32.                 System.out.println("Name: "+ node.getElementsByTagName("Name").item(0).getFirstChild().getNodeValue());  
33.                 System.out.println("Num: "+ node.getElementsByTagName("Num").item(0).getFirstChild().getNodeValue());  
34.                 System.out.println("Classes: "+ node.getElementsByTagName("Classes").item(0).getFirstChild().getNodeValue());  
35.                 System.out.println("Address: "+ node.getElementsByTagName("Address").item(0).getFirstChild().getNodeValue());  
36.                 System.out.println("Tel: "+ node.getElementsByTagName("Tel").item(0).getFirstChild().getNodeValue());  
37.             }  
38.               
39.         }catch (Exception e) {  
40.             // TODO: handle exception  
41.             e.printStackTrace();  
42.         }  
43.     }  
44.     /** 
45.      * 向已存在的xml文件中插入元素 
46.      * */  
47.     public static void insertXml(){  
48.         Element school = null;  
49.         Element student = null;  
50.         Element name = null;  
51.         Element num = null;  
52.         Element classes = null;  
53.         Element address = null;  
54.         Element tel = null;  
55.         try{  
56.             //得到DOM解析器的工厂实例  
57.             DocumentBuilderFactory dbFactory = DocumentBuilderFactory.newInstance();  
58.             //从DOM工厂中获得DOM解析器  
59.             DocumentBuilder dbBuilder = dbFactory.newDocumentBuilder();  
60.             //把要解析的xml文档读入DOM解析器  
61.             Document doc = dbBuilder.parse("src/xidian/sl/dom/school.xml");  
62.             //得到文档名称为Student的元素的节点列表  
63.             NodeList nList = doc.getElementsByTagName("School");  
64.             school = (Element)nList.item(0);  
65.             //创建名称为Student的元素  
66.             student = doc.createElement("Student");  
67.             //设置元素Student的属性值为231  
68.             student.setAttribute("examId", "23");  
69.             //创建名称为Name的元素  
70.             name = doc.createElement("Name");  
71.             //创建名称为 香香 的文本节点并作为子节点添加到name元素中  
72.             name.appendChild(doc.createTextNode("香香"));  
73.             //将name子元素添加到student中  
74.             student.appendChild(name);  
75.             /** 
76.              * 下面的元素依次加入即可 
77.              * */  
78.             num = doc.createElement("Num");  
79.             num.appendChild(doc.createTextNode("1006010066"));  
80.             student.appendChild(num);  
81.               
82.             classes = doc.createElement("Classes");  
83.             classes.appendChild(doc.createTextNode("眼视光5"));  
84.             student.appendChild(classes);  
85.               
86.             address = doc.createElement("Address");  
87.             address.appendChild(doc.createTextNode("浙江温州"));  
88.             student.appendChild(address);  
89.               
90.             tel = doc.createElement("Tel");  
91.             tel.appendChild(doc.createTextNode("123890"));  
92.             student.appendChild(tel);  
93.               
94.             //将student作为子元素添加到树的根节点school  
95.             school.appendChild(student);  
96.             //将内存中的文档通过文件流生成insertSchool.xml,XmlDocument位于crison.jar下  
97.             ((XmlDocument)doc).write(new FileOutputStream("src/xidian/sl/dom/insertSchool.xml"));  
98.             System.out.println("成功");  
99.         }catch (Exception e) {  
100.             // TODO: handle exception  
101.             e.printStackTrace();  
102.         }      
103.     }  
104.     public static void main(String[] args){  
105.         //读取  
106.         DomDemo.queryXml();  
107.         //插入  
108.         DomDemo.insertXml();  
109.     }  
110. }  

运行后结果：

 

然后到目录下查看生成的xml文件：

打开查看内容：

上面添加元素后输出的文件与之前的文件不是同一个文件，如果需要输出到原文件中，那么只要将路径改为原文间路径即可：src/xidian/sl/dom/school.xml

 

2.创建XML过程与插入过程相似，就是Document需要创建

[java] view plaincopyprint?

1. package xidian.sl.dom;  
2.   
3. import java.io.FileOutputStream;  
4.   
5. import javax.xml.parsers.DocumentBuilder;  
6. import javax.xml.parsers.DocumentBuilderFactory;  
7.   
8. import org.apache.crimson.tree.XmlDocument;  
9. import org.w3c.dom.Document;  
10. import org.w3c.dom.Element;  
11.   
12.   
13. public class CreateNewDom {  
14.     /** 
15.      * 创建xml文档 
16.      * */  
17.     public static void createDom(){  
18.         Document doc;  
19.         Element school,student;  
20.         Element name = null;  
21.         Element num = null;  
22.         Element classes = null;  
23.         Element address = null;  
24.         Element tel = null;  
25.         try{  
26.             //得到DOM解析器的工厂实例  
27.             DocumentBuilderFactory dbFactory = DocumentBuilderFactory.newInstance();  
28.             //从DOM工厂中获得DOM解析器  
29.             DocumentBuilder dbBuilder = dbFactory.newDocumentBuilder();  
30.             //创建文档树模型对象  
31.             doc = dbBuilder.newDocument();  
32.             if(doc != null){  
33.                 //创建school元素  
34.                 school = doc.createElement("School");  
35.                 //创建student元素  
36.                 student = doc.createElement("Student");  
37.                 //设置元素Student的属性值为231  
38.                 student.setAttribute("examId", "23");  
39.                 //创建名称为Name的元素  
40.                 name = doc.createElement("Name");  
41.                 //创建名称为 香香 的文本节点并作为子节点添加到name元素中  
42.                 name.appendChild(doc.createTextNode("香香"));  
43.                 //将name子元素添加到student中  
44.                 student.appendChild(name);  
45.                 /** 
46.                  * 下面的元素依次加入即可 
47.                  * */  
48.                 num = doc.createElement("Num");  
49.                 num.appendChild(doc.createTextNode("1006010066"));  
50.                 student.appendChild(num);  
51.                   
52.                 classes = doc.createElement("Classes");  
53.                 classes.appendChild(doc.createTextNode("眼视光5"));  
54.                 student.appendChild(classes);  
55.                   
56.                 address = doc.createElement("Address");  
57.                 address.appendChild(doc.createTextNode("浙江温州"));  
58.                 student.appendChild(address);  
59.                   
60.                 tel = doc.createElement("Tel");  
61.                 tel.appendChild(doc.createTextNode("123890"));  
62.                 student.appendChild(tel);  
63.                   
64.                 //将student作为子元素添加到树的根节点school  
65.                 school.appendChild(student);  
66.                 //添加到文档树中  
67.                 doc.appendChild(school);  
68.                 //将内存中的文档通过文件流生成insertSchool.xml,XmlDocument位于crison.jar下  
69.                 ((XmlDocument)doc).write(new FileOutputStream("src/xidian/sl/dom/createSchool.xml"));  
70.                 System.out.println("创建成功");  
71.             }  
72.         }catch (Exception e) {  
73.             // TODO: handle exception  
74.             e.printStackTrace();  
75.         }  
76.     }  
77.     public static void main(String[] args) {  
78.         CreateNewDom.createDom();  
79.     }  
80. }  

运行结果：

DOM的操作应该还是非常简单明了的，掌握了没哦

三 pull 解析xml：

 XmlPull和Sax类似，是基于流（stream）操作文件，然后根据节点事件回调开发者编写的处理程序。因为是基于流的处理，因此Xmlpull和 Sax都比较节约内存资源，不会象Dom那样要把所有节点以对橡树的形式展现在内存中。 但Xmlpull比Sax更简明，而且不需要扫描完整个流。

     下面来看一个pull解析xml的例子：

      student.xml:

     

[html] view plaincopy

1. <?xml version="1.0" encoding="utf-8"?>    
2.     <root>    
3.         <student id="1" group="1">    
4.             <name>张三</name>    
5.             <sex>男</sex>    
6.             <age>18</age>    
7.             <email>[e-mail]</email>    
8.             <birthday>1987-06-08</birthday>    
9.             <memo>好学生</memo>    
10.         </student>    
11.         <student id="2" group="2">    
12.             <name>李四</name>    
13.             <sex>女</sex>    
14.             <age>18</age>    
15.             <email>[e-mail]</email>    
16.             <birthday>1987-06-08</birthday>    
17.             <memo>好学生</memo>    
18.         </student>    
19.         <student id="3" group="3">    
20.             <name>小王</name>    
21.             <sex>男</sex>    
22.             <age>18</age>    
23.             <email>[e-mail]</email>    
24.             <birthday>1987-06-08</birthday>    
25.             <memo>好学生</memo>    
26.         </student>    
27.         <student id="4" group="4">    
28.             <name>小张</name>    
29.             <sex>男</sex>    
30.             <age>18</age>    
31.             <email>[e-mail]</email>    
32.             <birthday>1987-06-08</birthday>    
33.             <memo>好学生</memo>    
34.         </student>    
35.         <student id="5" group="5">    
36.             <name>小明</name>    
37.             <sex>男</sex>    
38.             <age>18</age>    
39.             <email>[e-mail]</email>    
40.             <birthday>1987-06-08</birthday>    
41.             <memo>好学生</memo>    
42.         </student>    
43.     </root>    

       对应的bean：

    

[html] view plaincopy

1. public class Student {    
2.       
3.     private int id;    
4.     private int group;    
5.     private String name;    
6.     private String sex;    
7.     private int age;    
8.     private String email;    
9.     private String memo;    
10.     private String birthday;    
11.     public int getId() {    
12.         return id;    
13.     }    
14.     public void setId(int id) {    
15.         this.id = id;    
16.     }    
17.     public int getGroup() {    
18.         return group;    
19.     }    
20.     public void setGroup(int group) {    
21.         this.group = group;    
22.     }    
23.     public String getName() {    
24.         return name;    
25.     }    
26.     public void setName(String name) {    
27.         this.name = name;    
28.     }    
29.     public String getSex() {    
30.         return sex;    
31.     }    
32.     public void setSex(String sex) {    
33.         this.sex = sex;    
34.     }    
35.     public int getAge() {    
36.         return age;    
37.     }    
38.     public void setAge(int age) {    
39.         this.age = age;    
40.     }    
41.     public String getEmail() {    
42.         return email;    
43.     }    
44.     public void setEmail(String email) {    
45.         this.email = email;    
46.     }    
47.     public String getMemo() {    
48.         return memo;    
49.     }    
50.     public void setMemo(String memo) {    
51.         this.memo = memo;    
52.     }    
53.     public String getBirthday() {    
54.         return birthday;    
55.     }    
56.     public void setBirthday(String birthday) {    
57.         this.birthday = birthday;    
58.     }    
59.         
60. }    

    主要的解析和现实类：

  

[html] view plaincopy

1. import java.io.InputStream;  
2. import java.util.ArrayList;  
3. import java.util.List;  
4.   
5. import org.xmlpull.v1.XmlPullParser;  
6. import org.xmlpull.v1.XmlPullParserFactory;  
7.   
8. import android.app.Activity;  
9. import android.os.Bundle;  
10. import android.os.Handler;  
11. import android.os.Message;  
12. import android.view.ViewGroup.LayoutParams;  
13. import android.widget.LinearLayout;  
14.   
15. import android.widget.TextView;  
16.   
17. public class PullActivity extends Activity implements Runnable{  
18.   
19.     private TextView pullTextView ;  
20.     private LinearLayout layout;  
21.     private Handler handler=new Handler(){  
22.          public void handleMessage(android.os.Message msg) {  
23.              List<Student> lists=(List<Student>) msg.obj;  
24.              for(int i=0;i<lists.size();i++){  
25.                  Student student=lists.get(i);  
26.                  StringBuffer sb=new StringBuffer();  
27.                  sb.append(student.getId()+"  ").append(student.getName()+"  ")  
28.                  .append(student.getAge()+"  ").append(student.getSex()+" ").append(student.getBirthday()+"  ")  
29.                  .append(student.getEmail()+"  ").append(student.getGroup()+"  ");  
30.                  TextView txt=new TextView(getApplicationContext());  
31.                  txt.setLayoutParams(new LayoutParams(LayoutParams.WRAP_CONTENT, LayoutParams.WRAP_CONTENT));  
32.                  txt.setText(sb.toString());  
33.                  layout.addView(txt);  
34.              }  
35.          };  
36.     };  
37.     @Override  
38.     protected void onCreate(Bundle savedInstanceState) {  
39.         // TODO Auto-generated method stub  
40.         super.onCreate(savedInstanceState);  
41.         setContentView(R.layout.pull);  
42.           
43.         pullTextView=(TextView) this.findViewById(R.id.pullTextView);  
44.         layout=(LinearLayout) this.findViewById(R.id.layout);  
45.         new Thread(this).start();  
46.           
47.            
48.            
49.     }  
50.     //pull解析xml  
51.     public List<Student> pullParseXml(){  
52.         List<Student> lists=null;  
53.         Student student=null;  
54.           
55.         try {  
56.             XmlPullParserFactory factory=XmlPullParserFactory.newInstance();  
57.             //获取XmlPullParser实例  
58.             XmlPullParser pullParser=factory.newPullParser();  
59.             InputStream in=this.getClass().getClassLoader().getResourceAsStream("student.xml");  
60.             pullParser.setInput(in, "UTF-8");  
61.             //开始  
62.             int eventType=pullParser.getEventType();  
63.               
64.             while(eventType!=XmlPullParser.END_DOCUMENT){  
65.                 String nodeName=pullParser.getName();  
66.                 switch (eventType) {  
67.                 //文档开始  
68.                 case XmlPullParser.START_DOCUMENT:  
69.                      lists=new ArrayList<Student>();  
70.                     break;  
71.   
72.                     //开始节点  
73.                 case XmlPullParser.START_TAG:  
74.                     if("student".equals(nodeName)){  
75.                         student=new Student();  
76.                         student.setId(Integer.parseInt(pullParser.getAttributeValue(0)));  
77.                         student.setGroup(Integer.parseInt(pullParser.getAttributeValue(1)));  
78.                     }else if("name".equals(nodeName)){  
79.                         student.setName(pullParser.nextText());  
80.                     }else if("sex".equals(nodeName)){  
81.                         student.setSex(pullParser.nextText());  
82.                     }else if("age".equals(nodeName)){  
83.                         student.setAge(Integer.parseInt(pullParser.nextText()));  
84.                     }else if("email".equals(nodeName)){  
85.                         student.setEmail(pullParser.nextText());  
86.                     }else if("birthday".equals(nodeName)){  
87.                         student.setBirthday(pullParser.nextText());  
88.                     }else if("memo".equals(nodeName)){  
89.                         student.setMemo(pullParser.nextText());  
90.                     }  
91.                     break;  
92.                     //结束节点  
93.                 case XmlPullParser.END_TAG:  
94.                     if("student".equals(nodeName)){  
95.                         lists.add(student);  
96.                         student=null;  
97.                     }  
98.                     break;  
99.                 default:  
100.                     break;  
101.                 }  
102.                  // 手动的触发下一个事件    
103.                 eventType=pullParser.next();  
104.             }  
105.         } catch (Exception e) {  
106.             // TODO Auto-generated catch block  
107.             e.printStackTrace();  
108.         }  
109.         return lists;  
110.           
111.     }  
112.     @Override  
113.     public void run() {  
114.         // TODO Auto-generated method stub  
115.         List<Student> lists=pullParseXml();  
116.         Message msg=handler.obtainMessage();  
117.         msg.obj=lists;  
118.         handler.sendMessage(msg);  
119.     }  
120. }  

      注意xml中的<?xml version="1.0" encoding="utf-8"?>  这句话要顶格显示，不要留空隙，附则错了很难调试的。

     解析后效果：

    

四 三者不同点

对于Android的移动设备而言，因为设备的资源比较宝贵，内存是有限的，所以我们需要选择适合的技术来解析XML，这样有利于提高访问的速度。

DOM在处理XML文件时，将XML文件解析成树状结构并放入内存中进行处理。当XML文件较小时，我们可以选DOM，因为它简单、直观，可以生产，修改xml

SAX则是以事件作为解析XML文件的模式，它将XML文件转化成一系列的事件，由不同的事件处理器来决定如何处理。XML文件较大时，选择SAX技术是比较合理的。虽然代码量有些大，但是它不需要将所有的XML文件加载到内存中。这样对于有限的Android内存更有效，而且Android提供了一种传统的SAX使用方法以及一个便捷的SAX包装器。 使用Android．util．Xml类，从示例中可以看出，会比使用 SAX来得简单，没有修改，生产xml

XML pull解析并未像SAX解析那样监听元素的结束，而是在开始处完成了大部分处理。这有利于提早读取XML文件，可以极大的减少解析时间，这种优化对于连接速度较漫的移动设备而言尤为重要。对于XML文档较大但只需要文档的一部分时，XML Pull解析器则是更为有效的方法，可以生成xml

SAX
优点:①无需将整个文档加载到内存，因而内存消耗少 
     ②推模型允许注册多个ContentHandler
缺点:①没有内置的文档导航支持 
     ②不能够随机访问XML文档 
     ③不支持在原地修改XML 
     ④不支持名字空间作用域
最适合于:只从XML读取数据的应用程（不可用于操作或修改XML文档）
 
 
 
DOM
优点:①易于使用 
     ②丰富的API集合，可用于轻松地导航 
     ③整棵树加载到内存，允许对XML文档进行随机访问
缺点:①整个XML文档必须一次解析完 
     ②将整棵树加载到内存成本较高 
     ③一般的DOM节点对于必须为所有节点创建对象的对象类型绑定不太理想
最适合于:需要修改XML文档的应用程序或XSLT应用程序(不可用于只读XML的应用程序)