Android XML解析

DOM解析

常用方法：
Document ：getElementsByTagName（结点名称）：根据结点的名称获得结点
NodeList：getchildNode（）；获得当前节点所有的子节点
getAttributes（）；获得当前结点所有的属性和值
getNodeValue();获得当前结点的值
getTextContent（）；获得当前子节点的文本
getNodeName（）；获得当前节点的名称

Activity代码              

// An highlighted block
public class MainActivity extends AppCompatActivity {
    private ArrayList<BookBean> bookBeans;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        dom();
        Log.e("########list",bookBeans.get(0).toString());
        Log.e("########list",bookBeans.get(1).toString());
    }

    public void dom(){
        bookBeans = new ArrayList<>();
        DocumentBuilderFactory domfactory = DocumentBuilderFactory.newInstance();//获得解析工厂
        try {
            DocumentBuilder builder = domfactory.newDocumentBuilder();//创建builder对象
            InputStream inputStream = getAssets().open("book.xml");//获得xml文件
            Document document = builder.parse(inputStream);//把文件读入到内存中

            NodeList list = document.getElementsByTagName("book");//获得文件中所有节点名为book的内容，并打算将这些内容存入到list里面
            //由于有好多个book结点，所有我们要读list左遍历
            for(int i=0;i<list.getLength();i++){
                 BookBean bookBean =  new BookBean();

                //这样就拿到了其中一个book结点的内容，也就是一个对象，包括5个属性
                Node node = list.item(i);//当i等于0的时候，获得的是第一个book对象，在文件中一共有2个book对象
                //对象的结点找到了就是node，直接从node中获得属性，


                //接下来获得属性
                String id = node.getAttributes().getNamedItem("id").getNodeValue();//这个得到id这个属性
                Log.e("#########id",id);
                bookBean.setId(id);

                NodeList nodeList = node.getChildNodes();
                int length = nodeList.getLength();
                Log.e("#########length",length+"");
                for(int j=0;j<length;j++){
                    Node item = nodeList.item(j);
                    if("name".equals(item.getNodeName())){
                        String name = item.getTextContent();
                        Log.e("#########name",name);
                        bookBean.setName(name);
                    }else if("author".equals(item.getNodeName())){
                        String author = item.getTextContent();
                        Log.e("#########author",author);
                        bookBean.setAuthor(author);
                    }else if("year".equals(item.getNodeName())){
                        String year = item.getTextContent();
                        Log.e("#########year",year);
                        bookBean.setYear(year);
                    }else if("price".equals(item.getNodeName())){
                        String price = item.getTextContent();
                        Log.e("#########price",price);
                        bookBean.setPrice(price);
                    }
                }

                bookBeans.add(bookBean);

            }

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

Pull解析

解析方式类似SaX解析
用法：
四个常量：
START_DOCUMENT
START_TAG
END_DOCUMENT
END_TAG
getEventType：获得当前时间类型
getAttributevalue（下标）:获得该下标的属性值
next:向下移动一个标签
nextText：获得标签的值
getName：获得标签名

// An highlighted block
 public void pull2(){
        try {
            bookBeans4 = new ArrayList<>();
            BookBean bookBean4 = null;

            XmlPullParserFactory factory = XmlPullParserFactory.newInstance();
            XmlPullParser pullParser = factory.newPullParser();
            InputStream open = getAssets().open("book.xml");
            pullParser.setInput(open,"UTF-8");
            int eventType = pullParser.getEventType();

            while(eventType == XmlPullParser.START_DOCUMENT){
                switch (eventType){
                        case XmlPullParser.START_TAG:
                           bookBean4 = new BookBean();
                            if(pullParser.getName().equals("book")) {
                                String id = pullParser.getAttributeValue(0);
                                Log.e("###########id", id);
                            }else if(pullParser.getName().equals("name")){
                                String name = pullParser.nextText();
                                bookBean4.setName(name);
                                Log.e("###########name", name);
                            }else if(pullParser.getName().equals("author")){
                                String author = pullParser.nextText();
                                bookBean4.setAuthor(author);
                                Log.e("###########author", author);
                            }else if(pullParser.getName().equals("year")){
                                String year = pullParser.nextText();
                                bookBean4.setYear(year);
                                Log.e("###########year", year);
                            }else if(pullParser.getName().equals("price")){
                                String price = pullParser.nextText();
                                bookBean4.setPrice(price);
                                Log.e("###########pirce",price);
                            }
                            break;

                        case XmlPullParser.END_TAG:
                            bookBeans4.add(bookBean4);
                            break;
                }
                eventType = pullParser.next();

            }

            Log.e("###########list4",bookBeans4.get(0).toString());
            Log.e("###########list4",bookBeans4.get(1).toString());

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

    }

SAX解析

sax:对文档进行顺序扫描，当扫描到四种情况：
开始文档
结束文档、
开始标签
结束标签
的时候会通知DefaultHandler中的方法，一直重复这个动作，直到文档结束
优点：解析速度快，占用内存少
缺点：解析一个XML文件对应一个handler类，比较麻烦
特点：流式解析，解析是同步的，读到哪里就解析到哪里
用法：
自定义类继承Defaulthandler,重写四个方法
获SAXparerFraserFactory f =SAXParswerFactory.newInstance
获得解析器： p = f.new SAXparser();
设置解析文件和解析方式 p.setparser(文件流，new 自定义类)
开始文档：初始化结合
结束文档：啥也不做
开始标签：初始化对象，获得标签中属性
结束标签：把对象放入集合

Defaulthandler类

// An highlighted block
public class Mysax extends DefaultHandler {
    ArrayList<BookBean> bookBeans;
    BookBean bookBean;
    String tagname;

    @Override
    public void startDocument() throws SAXException {
        super.startDocument();
        Log.e("######start","文档开始解析");
    }

    @Override
    public void startElement(String uri, String localName, String qName, Attributes attributes) throws SAXException {
        super.startElement(uri, localName, qName, attributes);
        Log.e("##########qname",qName);
        if(qName.equals("bookstore")){
            bookBeans = new ArrayList<>();
        }else if(qName.equals("book")){
            bookBean = new BookBean();
            bookBean.setId(attributes.getValue("id"));
        }
        this.tagname = qName;
    }

    @Override
    public void characters(char[] ch, int start, int length) throws SAXException {
        super.characters(ch, start, length);
        String value = new String(ch,start,length);
        Log.e("##########value",value);
        if(this.tagname != null){
            if(this.tagname.equals("name")){
                bookBean.setName(value);
            }else if(this.tagname.equals("author")){
                bookBean.setAuthor(value);
            }else if(this.tagname.equals("year")){
                bookBean.setYear(value);
            }else if(this.tagname.equals("price")){
                bookBean.setPrice(value);
            }
        }
    }

    @Override
    public void endElement(String uri, String localName, String qName) throws SAXException {
        super.endElement(uri, localName, qName);
        if(qName.equals("book")){
             bookBeans.add(bookBean);
        }
        this.tagname = null;
    }

    @Override
    public void endDocument() throws SAXException {
        super.endDocument();
        Log.e("######start","文档解析结束");
    }

Activity

// An highlighted block
public void sax(){
        SAXParserFactory factory = SAXParserFactory.newInstance();
        try {
            SAXParser saxParser = factory.newSAXParser();
            InputStream book = getAssets().open("book.xml");
            Mysax mysax = new Mysax();
            saxParser.parse(book,mysax);
            ArrayList<BookBean> bookBeans3 = mysax.bookBeans;
            Log.e("###########list3 ",bookBeans3.get(0).toString());
            Log.e("###########list3",bookBeans3.get(1).toString());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

实体类代码

// An highlighted block
public class BookBean {
    String id;
    String name;
    String author;
    String year;
    String price;


    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 String getAuthor() {
        return author;
    }

    public void setAuthor(String author) {
        this.author = author;
    }

    public String getYear() {
        return year;
    }

    public void setYear(String year) {
        this.year = year;
    }

    public String getPrice() {
        return price;
    }

    public void setPrice(String price) {
        this.price = price;
    }

    @Override
    public String toString() {
        return "BookBean{" +
                "id='" + id + '\'' +
                ", name='" + name + '\'' +
                ", author='" + author + '\'' +
                ", year='" + year + '\'' +
                ", price='" + price + '\'' +
                '}';
    }