文档章节

Java在android中xml文件解析效率比较分析

tinydot
 tinydot
发布于 2016/10/10 23:21
字数 2006
阅读 26
收藏 0

在Android中,常见的XML解析器分别为SAX解析器、DOM解析器和PULL解析器,下面,我将一一向大家详细介绍。

SAX解析器:

SAX(Simple API for XML)解析器是一种基于事件的解析器,它的核心是事件处理模式,主要是围绕着事件源以及事件处理器来工作的。当事件源产生事件后,调用事件处理器相应的处理方法,一个事件就可以得到处理。在事件源调用事件处理器中特定方法的时候,还要传递给事件处理器相应事件的状态信息,这样事件处理器才能够根据提供的事件信息来决定自己的行为。

SAX解析器的优点是解析速度快,占用内存少。非常适合在Android移动设备中使用。

DOM解析器:

DOM是基于树形结构的的节点或信息片段的集合,允许开发人员使用DOM API遍历XML树、检索所需数据。分析该结构通常需要加载整个文档和构造树形结构,然后才可以检索和更新节点信息。

由于DOM在内存中以树形结构存放,因此检索和更新效率会更高。但是对于特别大的文档,解析和加载整个文档将会很耗资源。

PULL解析器:

PULL解析器的运行方式和SAX类似,都是基于事件的模式。不同的是,在PULL解析过程中,我们需要自己获取产生的事件然后做相应的操作,而不像SAX那样由处理器触发一种事件的方法,执行我们的代码。PULL解析器小巧轻便,解析速度快,简单易用,非常适合在Android移动设备中使用,Android系统内部在解析各种XML时也是用PULL解析器。

 

<?xml version="1.0" encoding="UTF-8"?>  
<persons>  
    <person id="1">  
        <name>sax</name>  
        <age>30</age>  
    </person>  
    <person id="2">  
        <name>dom</name>  
        <age>40</age>  
    </person>  
    <person id="3">  
        <name>pull</name>  
        <age>50</age>  
    </person>  
    <person id="4">  
        <name>ouyangpeng</name>  
        <age>60</age>  
    </person>  
    <person id="5">  
        <name>chengming</name>  
        <age>70</age>  
    </person>  
    <person id="6">  
        <name>just for test</name>  
        <age>80</age>  
    </person>  
</persons>  
public class Person {  
    private Integer id;  
    private String name;  
    private Integer age;  
      
    public Integer getId() {  
        return id;  
    }  
    public void setId(Integer id) {  
        this.id = id;  
    }  
    public String getName() {  
        return name;  
    }  
    public void setName(String name) {  
        this.name = name;  
    }  
    public Integer getAge() {  
        return age;  
    }  
    public void setAge(Integer age) {  
        this.age = age;  
    }  
      
    @Override    
       public String toString() {    
           return "id:" + id + ", name:" + name + ", age:" + age;    
       }    
}  
import java.io.InputStream;  
import java.io.OutputStream;  
import java.util.List;  
  
import cn.roco.xml.domain.Person;  
  
public interface IPersonService {  
    /** 
     * 获取数据 
     * @param is  输入方向 
     * @return   数据 
     * @throws Exception 
     */  
    public List<Person> parse(InputStream is) throws Exception;  
    /** 
     * 保存数据 
     * @param persons  数据 
     * @param out  输出方向 
     * @throws Exception 
     */  
    public void serialize(List<Person> persons, OutputStream out)  
            throws Exception;  
}  

SAX解析

import java.io.InputStream;  
import java.io.OutputStream;  
import java.util.ArrayList;  
import java.util.List;  
  
import javax.xml.parsers.SAXParser;  
import javax.xml.parsers.SAXParserFactory;  
import javax.xml.transform.OutputKeys;  
import javax.xml.transform.Result;  
import javax.xml.transform.Transformer;  
import javax.xml.transform.TransformerFactory;  
import javax.xml.transform.sax.SAXTransformerFactory;  
import javax.xml.transform.sax.TransformerHandler;  
import javax.xml.transform.stream.StreamResult;  
  
import org.xml.sax.Attributes;  
import org.xml.sax.SAXException;  
import org.xml.sax.helpers.AttributesImpl;  
import org.xml.sax.helpers.DefaultHandler;  
  
import cn.roco.xml.domain.Person;  
import cn.roco.xml.service.IPersonService;  
  
public class PersonServiceImpBySax implements IPersonService {  
  
    @Override  
    public void serialize(List<Person> persons, OutputStream out)  
            throws Exception {  
        SAXTransformerFactory factory = (SAXTransformerFactory) TransformerFactory  
                .newInstance();// 取得SAXTransformerFactory实例  
        TransformerHandler handler = factory.newTransformerHandler(); // 从factory获取TransformerHandler实例  
        Transformer transformer = handler.getTransformer(); // 从handler获取Transformer实例  
        transformer.setOutputProperty(OutputKeys.ENCODING, "UTF-8"); // 设置输出采用的编码方式  
        transformer.setOutputProperty(OutputKeys.INDENT, "yes"); // 是否自动添加额外的空白  
        transformer.setOutputProperty(OutputKeys.OMIT_XML_DECLARATION, "no"); // 是否忽略XML声明  
  
        Result result=new StreamResult(out);  
        handler.setResult(result);  
          
        String uri = ""; // 代表命名空间的URI 当URI无值时 须置为空字符串  
        String localName = ""; // 命名空间的本地名称(不包含前缀) 当没有进行命名空间处理时 须置为空字符串  
          
        handler.startDocument();  
        handler.startElement(uri, localName, "persons", null);  
  
        AttributesImpl attrs = new AttributesImpl(); // 负责存放元素的属性信息  
        char[] ch = null;  
        for (Person person : persons) {  
            attrs.clear();// 清空属性列表  
            attrs.addAttribute(uri, localName, "id", "string",  
                    String.valueOf(person.getId()));// 添加一个名为id的属性(type影响不大,这里设为string)  
            handler.startElement(uri, localName, "person", attrs); // 开始一个person元素  
                                                                    // 关联上面设定的id属性  
            handler.startElement(uri, localName, "name", null); // 开始一个name元素   没有属性  
            ch = String.valueOf(person.getName()).toCharArray();  
            handler.characters(ch, 0, ch.length); // 设置name元素的文本节点  
            handler.endElement(uri, localName, "name");  
              
            handler.startElement(uri, localName, "age", null); // 开始一个name元素   没有属性  
            ch = String.valueOf(person.getAge()).toCharArray();  
            handler.characters(ch, 0, ch.length); // 设置name元素的文本节点  
            handler.endElement(uri, localName, "age");  
              
            handler.endElement(uri, localName, "person");  
        }  
        handler.endElement(uri, localName, "persons");  
        handler.endDocument();  
    }  
  
    @Override  
    public List<Person> parse(InputStream is) throws Exception {  
        SAXParserFactory factory = SAXParserFactory.newInstance();// 取得SAXParserFactory实例  
        SAXParser saxParser = factory.newSAXParser(); // 从factory获取SAXParser实例  
        MyHandler handler = new MyHandler();// 实例化自定义Handler  
        saxParser.parse(is, handler); // 根据自定义Handler规则解析输入流  
        return handler.getPersons();  
    }  
  
    private final class MyHandler extends DefaultHandler {  
        private List<Person> persons;  
        private Person person;  
        private StringBuilder builder;  
  
        public List<Person> getPersons() {  
            return persons;  
        }  
  
        @Override  
        public void startDocument() throws SAXException {  
            super.startDocument();  
            persons = new ArrayList<Person>();  
            builder = new StringBuilder();  
        }  
  
        @Override  
        public void startElement(String uri, String localName, String qName,  
                Attributes attributes) throws SAXException {  
            super.startElement(uri, localName, qName, attributes);  
            if ("person".equals(localName)) {  
                person = new Person();  
                Integer id = Integer.parseInt(attributes.getValue(0));  
                person.setId(id);  
            }  
            builder.setLength(0);// 将字符长度设置为0 以便重新开始读取元素内的字符节点  
        }  
  
        @Override  
        public void characters(char[] ch, int start, int length)  
                throws SAXException {  
            super.characters(ch, start, length);  
            builder.append(ch, start, length); // 将读取的字符数组追加到builder中  
        }  
  
        @Override  
        public void endElement(String uri, String localName, String qName)  
                throws SAXException {  
            super.endElement(uri, localName, qName);  
            if ("name".equals(localName)) {  
                person.setName(builder.toString());  
            } else if ("age".equals(localName)) {  
                person.setAge(Integer.parseInt(builder.toString()));  
            } else if ("person".equals(localName)) {  
                persons.add(person);  
            }  
        }  
    }  
  
}  

 

import java.io.FileOutputStream;  
import java.io.InputStream;  
import java.util.List;  
  
import cn.roco.xml.domain.Person;  
import cn.roco.xml.service.IPersonService;  
import cn.roco.xml.service.imp.PersonServiceImpByDom;  
import cn.roco.xml.service.imp.PersonServiceImpByPull;  
import cn.roco.xml.service.imp.PersonServiceImpBySax;  
import android.app.Activity;  
import android.content.Context;  
import android.os.Bundle;  
import android.view.View;  
import android.widget.Button;  
import android.widget.TextView;  
import android.widget.Toast;  
  
public class MainActivity extends Activity {  
  
    TextView display;  
    List<Person> persons = null;  
    IPersonService personService = null;  
  
    /** Called when the activity is first created. */  
    @Override  
    public void onCreate(Bundle savedInstanceState) {  
        super.onCreate(savedInstanceState);  
        setContentView(R.layout.main);  
        // 指定IPersonService由PersonServiceImpByPull实现  
//       personService = new PersonServiceImpByPull();  
  
        // 指定IPersonService由PersonServiceImpBySax实现  
        personService = new PersonServiceImpBySax();  
          
        // 指定IPersonService由PersonServiceImpByDom实现  
//      personService = new PersonServiceImpByDom();  
          
  
        Button readButton = (Button) findViewById(R.id.readButton);  
        Button saveButton = (Button) findViewById(R.id.saveButton);  
        display = (TextView) findViewById(R.id.display);  
        readButton.setOnClickListener(new ReadButtonOnClickListener());  
        saveButton.setOnClickListener(new SaveButtonOnClickListener());  
    }  
  
    private final class SaveButtonOnClickListener implements  
            View.OnClickListener {  
        @Override  
        public void onClick(View view) {  
            try {  
                FileOutputStream out = openFileOutput("persons_backup.xml",  
                        Context.MODE_PRIVATE);  
                personService.serialize(persons, out);  
                Toast.makeText(getApplicationContext(), R.string.save_succ, 1)  
                        .show();  
            } catch (Exception e) {  
                Toast.makeText(getApplicationContext(), R.string.save_fail, 1)  
                        .show();  
                e.printStackTrace();  
            }  
        }  
    }  
  
    private final class ReadButtonOnClickListener implements  
            View.OnClickListener {  
        @Override  
        public void onClick(View v) {  
            InputStream xml = this.getClass().getClassLoader()  
                    .getResourceAsStream("person.xml");  
            try {  
                persons = personService.parse(xml);  
            } catch (Exception e) {  
                Toast.makeText(getApplicationContext(), R.string.read_fail, 1)  
                        .show();  
                e.printStackTrace();  
            }  
            display.setText("");  
            for (Person person : persons) {  
                display.append(person.toString() + "\n");  
            }  
        }  
    }  
}  

 

 

Dom解析

import java.io.InputStream;  
import java.io.OutputStream;  
import java.util.ArrayList;  
import java.util.List;  
  
import javax.xml.parsers.DocumentBuilder;  
import javax.xml.parsers.DocumentBuilderFactory;  
import javax.xml.parsers.SAXParser;  
import javax.xml.parsers.SAXParserFactory;  
import javax.xml.transform.OutputKeys;  
import javax.xml.transform.Result;  
import javax.xml.transform.Source;  
import javax.xml.transform.Transformer;  
import javax.xml.transform.TransformerFactory;  
import javax.xml.transform.dom.DOMSource;  
import javax.xml.transform.sax.SAXTransformerFactory;  
import javax.xml.transform.sax.TransformerHandler;  
import javax.xml.transform.stream.StreamResult;  
  
import org.w3c.dom.Attr;  
import org.w3c.dom.Document;  
import org.w3c.dom.Element;  
import org.w3c.dom.Node;  
import org.w3c.dom.NodeList;  
import org.xml.sax.Attributes;  
import org.xml.sax.SAXException;  
import org.xml.sax.helpers.AttributesImpl;  
import org.xml.sax.helpers.DefaultHandler;  
  
import android.R.bool;  
  
import cn.roco.xml.domain.Person;  
import cn.roco.xml.service.IPersonService;  
  
public class PersonServiceImpByDom implements IPersonService {  
  
    @Override  
    public void serialize(List<Person> persons, OutputStream out)  
            throws Exception {  
        DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();  
        DocumentBuilder builder = factory.newDocumentBuilder();  
        Document doc = builder.newDocument(); // 由builder创建新文档  
  
        Element rootElement = doc.createElement("persons");  
        for (Person person : persons) {  
            Element personElement = doc.createElement("person");  
            Attr id=doc.createAttribute("id"); //创建Id属性节点  
            id.setValue( person.getId().toString()); //给属性赋值  
            personElement.setAttributeNode(id);//把id属性节点追加到person  
          
              
            Element nameElement = doc.createElement("name");  
            nameElement.setTextContent(person.getName());  
            personElement.appendChild(nameElement);  
  
            Element ageElement = doc.createElement("age");  
            ageElement.setTextContent(person.getAge().toString());  
            personElement.appendChild(ageElement);  
              
            rootElement.appendChild(personElement);  
        }  
        doc.appendChild(rootElement);  
        TransformerFactory transFactory = TransformerFactory.newInstance();// 取得TransformerFactory实例  
        Transformer transformer = transFactory.newTransformer(); // 从transFactory获取Transformer实例  
        transformer.setOutputProperty(OutputKeys.ENCODING, "UTF-8"); // 设置输出采用的编码方式  
        transformer.setOutputProperty(OutputKeys.INDENT, "yes"); // 是否自动添加额外的空白  
        transformer.setOutputProperty(OutputKeys.OMIT_XML_DECLARATION, "no"); // 是否忽略XML声明  
  
        Source source=new DOMSource(doc);  
        Result result=new StreamResult(out);  
        transformer.transform(source, result);  
    }  
  
    @Override  
    public List<Person> parse(InputStream is) throws Exception {  
        List<Person> persons = new ArrayList<Person>();  
        DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance(); // 取得DocumentBuilderFactory实例  
        DocumentBuilder builder = factory.newDocumentBuilder(); // 从factory获取DocumentBuilder实例  
        Document doc = builder.parse(is); // 解析输入流 得到Document实例  
        Element rootElement = doc.getDocumentElement();  
  
        NodeList items = rootElement.getElementsByTagName("person");  
        for (int i = 0; i < items.getLength(); i++) {  
            Element item = (Element) items.item(i);  
            Person person = new Person();  
            person.setId(Integer.parseInt(item.getAttribute("id")));  
  
            NodeList properties = item.getChildNodes();  
            for (int j = 0; j < properties.getLength(); j++) {  
                if (properties.item(j).getNodeType() == Node.ELEMENT_NODE) {  
                    Node property = properties.item(j);  
                    String nodeName = property.getNodeName();  
                    if ("name".equals(nodeName)) {  
                        person.setName(property.getFirstChild().getNodeValue());  
                    } else if ("age".equals(nodeName)) {  
                        person.setAge(Integer.parseInt(property.getFirstChild()  
                                .getNodeValue()));  
                    }  
                }  
            }  
            persons.add(person);  
        }  
        return persons;  
    }  
}  

 

PULL解析

import java.io.InputStream;  
import java.io.OutputStream;  
import java.util.ArrayList;  
import java.util.List;  
  
import org.xmlpull.v1.XmlPullParser;  
import org.xmlpull.v1.XmlSerializer;  
  
import android.util.Xml;  
  
import cn.roco.xml.domain.Person;  
import cn.roco.xml.service.IPersonService;  
  
public class PersonServiceImpByPull implements IPersonService {  
  
 
    public void serialize(List<Person> persons, OutputStream out)  
            throws Exception {  
        XmlSerializer serializer = Xml.newSerializer(); // 由android.util.Xml创建一个XmlSerializer实例  
        serializer.setOutput(out, "UTF-8");  
        serializer.startDocument("UTF-8", true);  
        serializer.startTag(null, "persons");  
        for (Person person : persons) {  
            serializer.startTag(null, "person");  
            serializer.attribute(null, "id", person.getId().toString());  
  
            serializer.startTag(null, "name");  
            serializer.text(person.getName());  
            serializer.endTag(null, "name");  
  
            serializer.startTag(null, "age");  
            serializer.text(person.getAge().toString());  
            serializer.endTag(null, "age");  
  
            serializer.endTag(null, "person");  
        }  
        serializer.endTag(null, "persons");  
        serializer.endDocument();  
        out.flush();  
        out.close();  
    }  
  
  
    public List<Person> parse(InputStream is) throws Exception {  
        List<Person> persons = null;  
        Person person = null;  
  
        // XmlPullParserFactory factory = XmlPullParserFactory.newInstance();  
        // XmlPullParser pullParser = factory.newPullParser();  
        XmlPullParser pullParser = Xml.newPullParser();// 由android.util.Xml创建一个XmlPullParser实例  
        pullParser.setInput(is, "UTF-8");// 设置输入流 并指明编码方式  
        int eventType = pullParser.getEventType();  
        while (eventType != XmlPullParser.END_DOCUMENT) {  
            switch (eventType) {  
            case XmlPullParser.START_DOCUMENT:  
                persons = new ArrayList<Person>();  
                break;  
            case XmlPullParser.START_TAG:  
                if ("person".equals(pullParser.getName())) {  
                    person = new Person();  
                    person.setId(Integer.parseInt(pullParser  
                            .getAttributeValue(0)));  
                }  
                if ("name".equals(pullParser.getName())) {  
                    person.setName(pullParser.nextText());  
                }  
                if ("age".equals(pullParser.getName())) {  
                    person.setAge(Integer.parseInt(pullParser.nextText()));  
                }  
                break;  
            case XmlPullParser.END_TAG:  
                if ("person".equals(pullParser.getName())) {  
                    persons.add(person);  
                    person = null;  
                }  
                break;  
            }  
            eventType = pullParser.next();  
        }  
        return persons;  
    }  
}  

 

© 著作权归作者所有

tinydot
粉丝 3
博文 21
码字总数 12201
作品 0
深圳
QA/测试工程师
私信 提问
Android读写XML(上)

注明:本文转自http://www.moandroid.com. 原文地址: http://www.moandroid.com/?p=508 XML 经常用作 Internet 上的一种数据格式,其文件格式想必大家都比较清楚,在这里我结合Android平台,...

晨曦之光
2012/03/01
404
0
转载分享:Android APP二次打包操作步骤介绍

看到好的技术教程就想转载一下,不喜勿喷!谢谢配合,仅供菜鸟学习研究,不要做坏事哦\(^o^)/~ 关于Android APP 二次打包现象已经屡见不鲜,为何“打包党”就吃准了Android平台,二次打包的操...

科技创造
2015/08/26
1K
2
一份关于 Java、Kotlin 与 Android 的学习笔记

JavaKotlinAndroidLearn 这是一份关于 Java 、Kotlin 、Android 的学习笔记,既包含对基础知识点的介绍,也包含对一些重要知识点的源码解析,笔记的大纲如下所示: Java 重拾Java(0)-基础知...

叶应是叶
2018/08/08
0
0
Android中visibility属性VISIBLE、INVISIBLE、GONE的区别

其在XML文件和Java代码中设置如下: 可见(visible) XML文件:android:visibility="visible" Java代码:view.setVisibility(View.VISIBLE); 不可见(invisible) XML文件:android:visibilit......

____追梦人
2015/06/05
285
0
Android———利用JDBC连接服务器数据库

1、Android平台下与服务器数据库通信的方法 在Android平台下,连接电脑服务器的MySQL、PostgreSQL、Oracle、Sybase、Microsoft SQLServer等数据库管理系统DBMS(database management system),...

xiahuawuyu
2012/10/10
1K
1

没有更多内容

加载失败,请刷新页面

加载更多

PhotoShop 高级应用:USM锐化/S锐化/防抖

、 高反差锐化+混合模式:叠加模式 【将更多的边缘细节添加到图像中】

东方墨天
25分钟前
6
0
Python数据可视化之matplotlib

常用模块导入 import numpy as npimport matplotlibimport matplotlib.mlab as mlabimport matplotlib.pyplot as pltimport matplotlib.font_manager as fmfrom mpl_toolkits.mplot3d i......

松鼠大帝
昨天
5
0
我用Bash编写了一个扫雷游戏

我在编程教学方面不是专家,但当我想更好掌握某一样东西时,会试着找出让自己乐在其中的方法。比方说,当我想在 shell 编程方面更进一步时,我决定用 Bash 编写一个扫雷游戏来加以练习。 我在...

老孟的Linux私房菜
昨天
7
0
Go语言Hello world(GOPATH和Go Module版)

本文是「vangoleo的Go语言学习笔记」系列文章之一。 官网: http://www.vangoleo.com/go/go-hello-world-02/ 往期回顾: Go语言入门-你好,Go语言 Go语言入门-Hello World(Go Playground版) 上...

vangoleo
昨天
9
0
C++虚函数以及虚函数表

在了解虚函数之前先了解下对象模型: 对象模型: 在C++中,有两种数据成员(class data members):static 和nonstatic,以及三种类成员函数(class member functions):static、nonstatic和v...

黑白双键
昨天
9
0

没有更多内容

加载失败,请刷新页面

加载更多

返回顶部
顶部