精华内容
下载资源
问答
  • java解析XML文件

    2010-08-10 23:08:01
    java解析XML文件java解析XML文件java解析XML文件java解析XML文件java解析XML文件java解析XML文件
  • Java解析XML文件

    2013-03-09 20:26:03
    Java解析XML文件
  • Java 解析xml文档

    2012-08-30 17:21:30
    Java 解析xml文档(SAX,DOM,DOM4J)工程源代码。
  • Java解析XML文档

    2014-05-17 22:26:26
    Java解析XML文档,XML在不同的语言里解析

    用Java解析XML文档,XML在不同的语言里解析方式都是一样的,只不过实现的语法不同而已。最常用的有两中方法:使用基事件的XML简单API(Simple API for XML)称为SAX和基于树与节点的文档对象模型(Document Object Module)称为DOM。SAX是基于事件流的解析,DOM是基于XML文档树结构的解析。Sun公司提供了Java API for XML Parsing (JAXP)来同时支持SAX和DOM,通过JAXP,我们可以使用任何与JAXP兼容的XML解析器。

    1.DOM生成和解析XML文档

    DOM是W3C的推荐标准。DOM文档对象模型是一个使程序和脚本有能力动态地访问和更新文档的内容、结构,以及样式的平台和语言中立的接口。

    W3C DOM被分为三种不同的部分/级别:(1)核心DOM;用于任何结构化文档的标准模型;(2)XML DOM:用于XML文档的标准模型;(3)HTML DOM:用于HTML文档的标准模型。

    DOM定义了所有文档元素的对象和属性,以及访问他们的方法(接口)。解析器读入整个文档,接着构建一个驻留内存的树结构,然后代码就可以使用DOM接口来操作操作这个树结构。优点是整个文档树在内存中,便于操作;支持删除、修改、重新排列等多种功能;缺点是将整个文档调入内存(包括无用的节点),浪费时间和空间,所以DOM的使用场合一般是一旦解析了文档还需要多次访问这些数据,其次还要硬件资源充足(内存、CPU)。

    2.SAX生成和解析XML文档

    为了解决DOM在解析XML中的性能问题,出现了SAX,基于事件驱动,当解析器发现元素开始、元素结束、文本、文档的开始或者结束等,发送事件,开发人员编写的相应事件的代码,保存数据。

    展开全文
  • java解析xml文件

    2013-05-31 15:44:32
    本附件是一个带main的java小程序,主要作用是解析xml文件,就是对xml根据戒掉内容进行解析
  • Java解析Xml文件

    2008-12-17 15:03:00
    JAVA DOM方式解析XML文件 我是用Jubilder2005写的 希望对大家有帮助...
  • java解析xml文档方式

    2012-03-16 23:49:38
    好资料大家用。java解析xml文件的几种方式
  •  用Java解析XML文档,最常用的有两种方法:使用基于事件的XML简单API(Simple API for XML)称为SAX和基于树和节点的文档对象模型(Document Object Module)称为DOM。Sun公司提供了Java API for XML Parsing(JAXP...
    一、前言
      
      用Java解析XML文档,最常用的有两种方法:使用基于事件的XML简单API(Simple API for XML)称为SAX和基于树和节点的文档对象模型(Document Object Module)称为DOM。Sun公司提供了Java API for XML Parsing(JAXP)接口来使用SAX和DOM,通过JAXP,我们可以使用任何与JAXP兼容的XML解析器。
      
      JAXP接口包含了三个包:
      
      (1)org.w3c.dom W3C推荐的用于XML标准规划文档对象模型的接口。
      
      (2)org.xml.sax  用于对XML进行语法分析的事件驱动的XML简单API(SAX)
      
      (3)javax.xml.parsers解析器工厂工具,程序员获得并配置特殊的特殊语法分析器。
      
       二、前提
      
      DOM编程不要其它的依赖包,因为JDK里自带的JDK里含有的上面提到的org.w3c.dom、org.xml.sax 和javax.xml.parsers包就可以满意条件了。
      
       三、使用DOM解析XML文档
      

      我们现在来看看DOM是如何解析XML的吧!下面是一个简单的XML文件:


    F:\book.xml

    <?xml version="1.0" encoding="gb2312"?>
    <books>
     <book author="kok">
      <name>java编程思想</name>
      <price>108</price>
     </book>
    </books>

    基本的 根元素、属性、子节点都有,下面用JAVA解析这个XML

    package com.donen.test;
    
    import javax.xml.parsers.DocumentBuilder;
    import javax.xml.parsers.DocumentBuilderFactory;
    
    import org.w3c.dom.Document;
    import org.w3c.dom.Element;
    import org.w3c.dom.Node;
    import org.w3c.dom.NodeList;
    
    public class ReadXml {
    	
    	public static void main(String[] args) throws Exception
    	{
    		//得到DOM解析器的工厂实例
    		DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
    		//从DOM工厂获得DOM解析器
    		DocumentBuilder db = dbf.newDocumentBuilder();
    		/*
    		 * 解析XML文档的输入流,得到一个Document。有三个常用的重载方法
    		 * db.parse(File f) 文件
    		 * db.parse(InputStream is) 流
    		 * db.parse(String uri) 直接填写网页url 或者 本地文件路径  F:\\book.xml
    		 */
    		Document d = db.parse("F:\\test.xml");
    		//得到XML文档的根节点
    		Element root = d.getDocumentElement();
    		//得到节点
    		NodeList nl = root.getChildNodes();
    		//得到节点的子节点
    		for (int i = 0; i < nl.getLength(); i++) {
    			Node book = nl.item(i);
    			//轮循子节点
    			for (Node node = book.getFirstChild(); node != null; node = node.getNextSibling()) {
    				//节点的属性都是为Node.ELEMENT_NODE
    				if(node.getNodeType() == Node.ELEMENT_NODE)
    					//DOM把<name>java编程思想</name>也当作是两层结构的节点,其父节点是<name>,子节点java编程思想才是我们真正想得到的。所以去的值使用:book.getFirstChild().getNodeValue()
    					System.out.println(node.getNodeName() + "---" + node.getFirstChild().getNodeValue());
    			}
    		}
    	}
    }
    


    展开全文
  • JAVA解析XML文件

    千次阅读 2016-06-02 11:22:56
    .xml文件,树形结构 标准XML文档示例: bookStore> book id="1"> name>冰与火之歌name> author>乔治马丁author> year>2014year> price>99price> book> book id="2">
    .xml文件,树形结构
    

    标准XML文档示例:

    <?xml version="1.0" encoding="UTF-8"?>
    <bookStore>
        <book id="1">
                <name>冰与火之歌</name>
                <author>乔治马丁</author>
                <year>2014</year>
                <price>99</price>
        </book>
        <book id="2">
                <name>秦腔</name>
                <author>贾平凹</author>
                <price>90</price>
        </book>
    </bookStore>

    Why?:
    1、不同应用程序之间的通信问题(订票软件和支付软件);
    2、不同平台间的通信(MAC和windows);
    3、不同平台间共享数据(PC端和移动端)

    JAVA读取XML(解析)
    目的:
    获取节点名、节点值、属性名、属性值。解析后JAVA程序能够得到XML文件的所有数据

    四种方式:
    DOM(官方)
    SAX(官方)
    DOM4J(需要导jar包)
    JDOM(需要导jar包)

    books.xml文件练习:
    DOM解析
    将xml文件全部加载到内存,然后逐个解析。

    常用节点类型
    这里写图片描述

    解析方法:

    package DomTest;
    
    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对象
            DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
            // 创建一个DocumentBuilder的对象
            try {
                // 创建DocumentBuilder对象
                DocumentBuilder db = dbf.newDocumentBuilder();
                // 通过DocumentBuilder对象的parse方法加载books.xml文件
                // 到当前项目下
                Document document = db.parse("books.xml");
                // 获取所有book节点的集合
                NodeList bookList = document.getElementsByTagName("book");
                //通过nodeList的getLength()方法获取bookLIst的长度
                System.out.println("一共有:"+bookList.getLength()+"本书");
                //便利各个book节点
                for (int i = 0; i < bookList.getLength(); i++) {
                    System.out.println("开始遍历第"+(i+1)+"本书");
                    //通过 item(i)获取一个book节点,nodeList
                    Node book=bookList.item(i);
                    //获取book的属性的集合
                    NamedNodeMap attrs=book.getAttributes();
                    System.out.println("第"+(i+1)+"本书共有"+attrs.getLength()+"个属性");
                    //便利book的属性
                    for (int j = 0; j < attrs.getLength(); j++) {
                        //通过item()方法获取book节点的某一个属性
                        Node attr=attrs.item(j);
                        //获取属性名
                        System.out.println("属性名:"+attr.getNodeName());
                        //获取属性值
                        System.out.println("属性值:"+attr.getNodeValue());
                    }
                    System.out.println("结束遍历第"+(i+1)+"本书");
                }
    
            } catch (SAXException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            } catch (ParserConfigurationException e) {
                e.printStackTrace();
            }
        }
    
    }

    输出:
    一共有:2本书
    开始遍历第1本书
    第1本书共有1个属性
    属性名:id
    属性值:1
    结束遍历第1本书
    开始遍历第2本书
    第2本书共有1个属性
    属性名:id
    属性值:2
    结束遍历第2本书

    已知节点属性名称的情况下的遍历:

    package DomTest;
    
    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.Element;
    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对象
            DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
            // 创建一个DocumentBuilder的对象
            try {
                // 创建DocumentBuilder对象
                DocumentBuilder db = dbf.newDocumentBuilder();
                // 通过DocumentBuilder对象的parse方法加载books.xml文件
                // 到当前项目下
                Document document = db.parse("books.xml");
                // 获取所有book节点的集合
                NodeList bookList = document.getElementsByTagName("book");
                //通过nodeList的getLength()方法获取bookLIst的长度
                System.out.println("一共有:"+bookList.getLength()+"本书");
                //便利各个book节点
                for (int i = 0; i < bookList.getLength(); i++) {
                    System.out.println("++++++++++++开始遍历第"+(i+1)+"本书+++++++++++");
                    //方式一,不知道有多少节点,通过循环来遍历所有节点。
    
    //              //通过 item(i)获取一个book节点,nodeList
    //              Node book=bookList.item(i);
    //              //获取book的属性的集合
    //              NamedNodeMap attrs=book.getAttributes();
    //              System.out.println("第"+(i+1)+"本书共有"+attrs.getLength()+"个属性");
    //              //便利book的属性
    //              for (int j = 0; j < attrs.getLength(); j++) {
    //                  //通过item()方法获取book节点的某一个属性
    //                  Node attr=attrs.item(j);
    //                  //获取属性名
    //                  System.out.println("属性名:"+attr.getNodeName());
    //                  //获取属性值
    //                  System.out.println("属性值:"+attr.getNodeValue());
    //              }
    
    
                    //方式二,知道有且只有一个节点。并且知道属性的名称为“id”
                    //强制类型转换将book节点类型转换为Element类型
                    Element book =(Element) bookList.item(i);
    
                    //通过getAttribute(“id”)方法获取到属性的值
                    String attrValue=book.getAttribute("id");
                    System.out.println("id的属性的属性值为"+attrValue);
    
    //              //解析book节点的子节点,需要用到方式一中创建的book对象
    //              //获取子节点的集合
    //              NodeList childNodes=book.getChildNodes();
    //              
    //              //遍历childNodes获取每个子节点的节点名和节点值
    //              System.out.println("第"+(i+1)+"本书共有"+childNodes.getLength()+"个子节点");
    //              
                    System.out.println("++++++++++++结束遍历第"+(i+1)+"本书++++++++++++");
                }
    
            } catch (SAXException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            } catch (ParserConfigurationException e) {
                e.printStackTrace();
            }
        }
    
    }
    

    输出:
    一共有:2本书
    ++++++++++++开始遍历第1本书+++++++++++
    id的属性的属性值为1
    ++++++++++++结束遍历第1本书++++++++++++
    ++++++++++++开始遍历第2本书+++++++++++
    id的属性的属性值为2
    ++++++++++++结束遍历第2本书++++++++++++

    解析book节点下的所有子节点:

    package DomTest;
    
    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.Element;
    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对象
            DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
            // 创建一个DocumentBuilder的对象
            try {
                // 创建DocumentBuilder对象
                DocumentBuilder db = dbf.newDocumentBuilder();
                // 通过DocumentBuilder对象的parse方法加载books.xml文件
                // 到当前项目下
                Document document = db.parse("books.xml");
                // 获取所有book节点的集合
                NodeList bookList = document.getElementsByTagName("book");
                //通过nodeList的getLength()方法获取bookLIst的长度
                System.out.println("一共有:"+bookList.getLength()+"本书");
                //便利各个book节点
                for (int i = 0; i < bookList.getLength(); i++) {
                    System.out.println("++++++++++++开始遍历第"+(i+1)+"本书+++++++++++");
                    //方式一,不知道有多少节点,通过循环来遍历所有节点。
    
                    //通过 item(i)获取一个book节点,nodeList
                    Node book=bookList.item(i);
                    //获取book的属性的集合
                    NamedNodeMap attrs=book.getAttributes();
                    System.out.println("第"+(i+1)+"本书共有"+attrs.getLength()+"个属性");
                    //便利book的属性
                    for (int j = 0; j < attrs.getLength(); j++) {
                        //通过item()方法获取book节点的某一个属性
                        Node attr=attrs.item(j);
                        //获取属性名
                        System.out.println("属性名:"+attr.getNodeName());
                        //获取属性值
                        System.out.println("属性值:"+attr.getNodeValue());
                    }
    
    
    //              //方式二,知道有且只有一个节点。并且知道属性的名称为“id”
    //              //强制类型转换将book节点类型转换为Element类型
    //              Element book =(Element) bookList.item(i);
    //              
    //              //通过getAttribute(“id”)方法获取到属性的值
    //              String attrValue=book.getAttribute("id");
    //              System.out.println("id的属性的属性值为"+attrValue);
    
    
                    //解析book节点的子节点,需要用到方式一中创建的book对象
                    //获取子节点的集合
                    NodeList childNodes=book.getChildNodes();
    
                    //遍历childNodes获取每个子节点的节点名和节点值
                    System.out.println("第"+(i+1)+"本书共有"+childNodes.getLength()+"个子节点");
                    //循环遍历
                    for (int j = 0; j < childNodes.getLength(); j++) {
                        //区分text类型的node和element类型的node
                        if(childNodes.item(j).getNodeType()==Node.ELEMENT_NODE){
                            //输出了element类型节点的节点名
                            System.out.println("第"+(j+1)+"个节点名:"+childNodes.item(j).getNodeName());
                            //输出element类型节点的节点值
                            //需先获取当前节点的首个子节点,否则获取的是《name》标签的值NULL
    
                            //方式一:如果<name>节点下有多个子节点,此方法只输出确定的某个子节点的值
                            //同样要注意,<name>节点的第一个子节点的值是第一子节点的类型的值,还是NULL
                            System.out.println("节点值为:"+childNodes.item(j).getFirstChild()
                                    .getNodeValue());
                            //方式二:如果<name>节点下有多个子节点,此方法输出所有子节点的text
                            System.out.println(childNodes.item(j).getTextContent());
                        }
    
                    }
    
                    System.out.println("++++++++++++结束遍历第"+(i+1)+"本书++++++++++++");
                }
    
            } catch (SAXException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            } catch (ParserConfigurationException e) {
                e.printStackTrace();
            }
        }
    
    }
    

    输出:
    一共有:2本书
    ++++++++++++开始遍历第1本书+++++++++++
    第1本书共有1个属性
    属性名:id
    属性值:1
    第1本书共有9个子节点
    第2个节点名:name
    节点值为:冰与火之歌
    冰与火之歌
    第4个节点名:author
    节点值为:乔治马丁
    乔治马丁
    第6个节点名:year
    节点值为:2014
    2014
    第8个节点名:price
    节点值为:99
    99
    ++++++++++++结束遍历第1本书++++++++++++
    ++++++++++++开始遍历第2本书+++++++++++
    第2本书共有1个属性
    属性名:id
    属性值:2
    第2本书共有7个子节点
    第2个节点名:name
    节点值为:秦腔
    秦腔
    第4个节点名:author
    节点值为:贾平凹
    贾平凹
    第6个节点名:price
    节点值为:90
    90
    ++++++++++++结束遍历第2本书++++++++++++

    SAX解析XML文件
    通过自己创建的一个Handler类,由外向内顺序逐个解析。

    初步解析:
    步骤:
    1、通过SAXParseFactory的静态newInstance()方法获取SAXParseFactory实例factory
    2、通过SAXParserFactory实例的newSAXParser()方法返回SAXParse实例parser
    3、创建一个类继承DefaultHandler,重写其中的一些方法进行业务处理并创建这个类的实例handler
    重写两个方法:
    startElement()
    endElement()

    SAXParserHandler:

    package test2;
    
    import org.xml.sax.Attributes;
    import org.xml.sax.SAXException;
    import org.xml.sax.helpers.DefaultHandler;
    
    public class SAXParserHandler extends DefaultHandler {
        /***
         * 遍历xml的开始标签
         */
        @Override
        public void startElement(String uri, String localName, String qName, Attributes attributes) throws SAXException {
            // TODO Auto-generated method stub
            super.startElement(uri, localName, qName, attributes);
        }
    
        /***
         * 遍历xml的结束标签
         */
        @Override
        public void endElement(String uri, String localName, String qName) throws SAXException {
            // TODO Auto-generated method stub
            super.endElement(uri, localName, qName);
        }
    
        /***
         * 标识解析开始
         */
        @Override
        public void startDocument() throws SAXException {
            // TODO Auto-generated method stub
            super.startDocument();
            System.out.println("SAX解析开始");
        }
    
        /***
         * 标识解析结束
         */
        @Override
        public void endDocument() throws SAXException {
            // TODO Auto-generated method stub
            super.endDocument();
            System.out.println("SAX解析结束");
        }
    }
    

    SAXTest.java:

    package test;
    
    import java.io.IOException;
    
    import javax.xml.parsers.ParserConfigurationException;
    import javax.xml.parsers.SAXParser;
    import javax.xml.parsers.SAXParserFactory;
    
    import org.xml.sax.SAXException;
    
    import test2.SAXParserHandler;
    
    public class SAXTest {
    
        public static void main(String[] args) {
            // 通过SAXParseFactory的静态newInstance()
            //方法获取SAXParseFactory实例factory
            SAXParserFactory factory=SAXParserFactory.newInstance();
    
            //通过SAXParserFactory实例的newSAXParser()
            //方法返回SAXParse实例parser
            try {
                SAXParser parser= factory.newSAXParser();
                //创建SAXParserHandler对象
                SAXParserHandler handler=new SAXParserHandler();            
                parser.parse("books.xml", handler);
            } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();            
            } catch (ParserConfigurationException | SAXException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    
    }
    

    运行输出:
    SAX解析开始
    SAX解析结束

    解析节点属性:

    package test2;
    
    import org.xml.sax.Attributes;
    import org.xml.sax.SAXException;
    import org.xml.sax.helpers.DefaultHandler;
    
    import test3.Book;
    
    public class SAXParserHandler extends DefaultHandler {
    
        int bookIndex=0;//显示是第几本书的变量
    
        /***
         * 遍历xml的开始标签
         */
        @Override
        public void startElement(String uri, String localName, String qName, 
                Attributes attributes) throws SAXException {
            // TODO Auto-generated method stub
            //调用DefaultHandler类的startElement方法
            super.startElement(uri, localName, qName, attributes);
            //开始解析book元素的属性
            if (qName.equals("book")) {         
                bookIndex++;
                System.out.println("开始遍历第"+bookIndex+"本书");
    //          //方法一:已知book元素下属性的名称,根据属性名称获取属性的值。
    //          String value=attributes.getValue("id");
    //          System.out.println("book的属性值为:"+value);
    
                //方法二:book元素下舒心规定名称个数未知的情况
                int num=attributes.getLength();
                for (int i = 0; i < num; i++) {
                    System.out.println("book元素的第"+(i+1)
                            +"个属性名:"+attributes.getQName(i));
                    System.out.println("book元素的第"+(i+1)
                            +"个属性值:"+attributes.getValue(i));
    
                    if (attributes.getQName(i).equals("id")) {
                        book.setId(attributes.getValue(i));
                    }
                }
            }else if(!qName.equals("book")&&!qName.equals("bookStore")){
                System.out.print("节点名是:"+qName);
            }
    
            //qName.equals("name")时,向book中setName()
        }
    
        /***
         * 遍历xml的结束标签
         */
        @Override
        public void endElement(String uri, String localName, String qName) throws SAXException {
            // TODO Auto-generated method stub
            super.endElement(uri, localName, qName);
            //判断是否针对一本书遍历结束
                    if (qName.equals("book")) { 
    
                        System.out.println("遍历结束");
                        System.out.println("结束遍历第"+bookIndex+"本书");
                        System.out.println();
                    }
        }
    
        /***
         * 标识解析开始
         */
        @Override
        public void startDocument() throws SAXException {
            // TODO Auto-generated method stub
            super.startDocument();
    
            System.out.println("SAX解析开始");
        }
    
        /***
         * 标识解析结束
         */
        @Override
        public void endDocument() throws SAXException {
            // TODO Auto-generated method stub
            super.endDocument();
            System.out.println("SAX解析结束");
        }
    
        /***
         * ch 节点中的所有内容
         * start 开始的节点
         *  
         */
        @Override
        public void characters(char[] ch, int start, int length) throws SAXException {
            // TODO Auto-generated method stub
            super.characters(ch, start, length);
            String value=new String(ch,start,length);
            if (!value.trim().equals("")) {         
                System.out.println("\t节点值是:"+value);
            }
        }
    }
    

    输出:
    SAX解析开始
    开始遍历第1本书
    book元素的第1个属性名:id
    book元素的第1个属性值:1
    节点名是:name 节点值是:冰与火之歌
    节点名是:author 节点值是:乔治马丁
    节点名是:year 节点值是:2014
    节点名是:price 节点值是:99
    遍历结束
    结束遍历第1本书

    开始遍历第2本书
    book元素的第1个属性名:id
    book元素的第1个属性值:2
    节点名是:name 节点值是:秦腔
    节点名是:author 节点值是:贾平凹
    节点名是:price 节点值是:90
    遍历结束
    结束遍历第2本书

    SAX解析结束

    解析并存储XML结构:
    新建Book类

    package test3;
    
    public class Book {
        private String id;
        private String name;
        private String author;
        private String year;
        private 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 autor) {
            this.author = autor;
        }
        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;
        }   
    }

    修改SAXParserHandler:

    package test2;
    
    import java.util.ArrayList;
    
    import org.xml.sax.Attributes;
    import org.xml.sax.SAXException;
    import org.xml.sax.helpers.DefaultHandler;
    
    import test3.Book;
    
    public class SAXParserHandler extends DefaultHandler {
    
        int bookIndex=0;//显示是第几本书的变量
        //将character()中的value定义为全局变量
        String value=null;
        Book book=null;
        private ArrayList<Book> bookList=new ArrayList<Book>();
        public ArrayList<Book> getBookList(){
            return bookList;
        }
        /***
         * 遍历xml的开始标签
         */
        @Override
        public void startElement(String uri, String localName, String qName, 
                Attributes attributes) throws SAXException {
            // TODO Auto-generated method stub
            //调用DefaultHandler类的startElement方法
            super.startElement(uri, localName, qName, attributes);
            //开始解析book元素的属性
            if (qName.equals("book")) {
                book=new Book();
                bookIndex++;
                System.out.println("开始遍历第"+bookIndex+"本书");
    //          //方法一:已知book元素下属性的名称,根据属性名称获取属性的值。
    //          String value=attributes.getValue("id");
    //          System.out.println("book的属性值为:"+value);
    
                //方法二:book元素下舒心规定名称个数未知的情况
                int num=attributes.getLength();
                for (int i = 0; i < num; i++) {
                    System.out.println("book元素的第"+(i+1)
                            +"个属性名:"+attributes.getQName(i));
                    System.out.println("book元素的第"+(i+1)
                            +"个属性值:"+attributes.getValue(i));
    
                    if (attributes.getQName(i).equals("id")) {
                        book.setId(attributes.getValue(i));
                    }
                }
            }else if(!qName.equals("book")&&!qName.equals("bookStore")){
                System.out.print("节点名是:"+qName);
            }
    
            //qName.equals("name")时,向book中setName()
        }
    
        /***
         * 遍历xml的结束标签
         */
        @Override
        public void endElement(String uri, String localName, String qName) throws SAXException {
            // TODO Auto-generated method stub
            super.endElement(uri, localName, qName);
            //判断是否针对一本书遍历结束
                    if (qName.equals("book")) { 
                        bookList.add(book);
                        book=null;
                        System.out.println("遍历结束");
                        System.out.println("结束遍历第"+bookIndex+"本书");
                        System.out.println();
                    }else if(qName.equals("name")){
                        book.setName(value);
                    }else if(qName.equals("author")){
                        book.setAuthor(value);
                    }else if(qName.equals("year")){
                        book.setYear(value);
                    }else if(qName.equals("price")){
                        book.setPrice(value);
                    }
        }
    
        /***
         * 标识解析开始
         */
        @Override
        public void startDocument() throws SAXException {
            // TODO Auto-generated method stub
            super.startDocument();
    
            System.out.println("SAX解析开始");
        }
    
        /***
         * 标识解析结束
         */
        @Override
        public void endDocument() throws SAXException {
            // TODO Auto-generated method stub
            super.endDocument();
            System.out.println("SAX解析结束");
        }
    
        /***
         * ch 节点中的所有内容
         * start 开始的节点
         *  
         */
        @Override
        public void characters(char[] ch, int start, int length) throws SAXException {
            // TODO Auto-generated method stub
            super.characters(ch, start, length);
            value=new String(ch,start,length);
            if (!value.trim().equals("")) {         
                System.out.println("\t节点值是:"+value);
            }
        }
    }
    

    修改SAXTest:

    package test;
    
    import java.io.IOException;
    
    import javax.xml.parsers.ParserConfigurationException;
    import javax.xml.parsers.SAXParser;
    import javax.xml.parsers.SAXParserFactory;
    
    import org.xml.sax.SAXException;
    
    import test2.SAXParserHandler;
    import test3.Book;
    
    public class SAXTest {
    
        public static void main(String[] args) {
            // 通过SAXParseFactory的静态newInstance()
            //方法获取SAXParseFactory实例factory
            SAXParserFactory factory=SAXParserFactory.newInstance();
    
            //通过SAXParserFactory实例的newSAXParser()
            //方法返回SAXParse实例parser
            try {
                SAXParser parser= factory.newSAXParser();
                //创建SAXParserHandler对象
                SAXParserHandler handler=new SAXParserHandler();            
                parser.parse("books.xml", handler);
                System.out.println("书的数量:"+handler.getBookList().size());
                for(Book book: handler.getBookList()){
                    System.out.println(book.getId());
                    System.out.println(book.getName());
                    System.out.println(book.getAuthor());
                    System.out.println(book.getPrice());
                    System.out.println(book.getYear());
                    System.out.println("-------------");
                }
            } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();            
            } catch (ParserConfigurationException | SAXException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }

    输出:
    SAX解析开始
    开始遍历第1本书
    book元素的第1个属性名:id
    book元素的第1个属性值:1
    节点名是:name 节点值是:冰与火之歌
    节点名是:author 节点值是:乔治马丁
    节点名是:year 节点值是:2014
    节点名是:price 节点值是:99
    遍历结束
    结束遍历第1本书

    开始遍历第2本书
    book元素的第1个属性名:id
    book元素的第1个属性值:2
    节点名是:name 节点值是:秦腔
    节点名是:author 节点值是:贾平凹
    节点名是:price 节点值是:90
    遍历结束
    结束遍历第2本书

    SAX解析结束
    书的数量:2
    1
    冰与火之歌
    乔治马丁
    99
    2014

    2
    秦腔
    贾平凹
    90
    null

    JDOM解析
    包文件夹右键,Build Path,Add External Archices 导入JDOM jar包,但只是引用了路径,无法迁移到其他设备。
    解决办法:在项目文件夹下新建一个文件夹,将jar包放进新建的文件夹之后再重新导入。右键jar包, Build Path》》》Add Path

    package test;
    
    import java.util.List;
    import java.io.FileInputStream;
    import java.io.FileNotFoundException;
    import java.io.IOException;
    import java.io.InputStream;
    
    import org.jdom2.Attribute;
    import org.jdom2.Document;
    import org.jdom2.Element;
    import org.jdom2.JDOMException;
    import org.jdom2.input.SAXBuilder;
    
    public class JDOMTest {
    
        public static void main(String[] args) {
            //JDOM解析XML文件
            //创建一个SAXBuilder对象
            SAXBuilder saxbuilder=new SAXBuilder();
    
            InputStream in;
            try {
                //创建一个输入流,将xml文件加载到流中
                in = new FileInputStream("src/res/books.xml");
    
                //通过saxbuilder的build方法将输入流加载到saxbuilder中
                Document document= saxbuilder.build(in);
    
                //通过document对象获取xml文件的根节点
                Element rootElement= document.getRootElement(); 
    
                //获取根节点下的子节点的集合
                List<Element> bookList=rootElement.getChildren();
    
                //使用foreach循环解析
    
                for (Element book : bookList) {
                    System.out.println("开始解析第"+(bookList.indexOf(book)+1)
                            +"本书============");
    
                    //解析book的属性
                    List<Attribute> attrList=book.getAttributes();
    
    //              //知道节点属性名
    //              book.getAttribute("id");
    
    
                    //针对不清楚book节点下属性名和数量的情况
                    //遍历attrList
                    for (Attribute attr : attrList) {
                        //获取属性名和属性值
                        String attrName=attr.getName();
                        String attrValue=attr.getValue();
                        System.out.println("属性名:"+attrName+"\t属性值:"+attrValue);
                    }
    
                    //对book节点的子节点的节点名和节点值进行遍历
                    List<Element> bookChilds= book.getChildren();
                    for (Element child : bookChilds) {
                        System.out.println("节点名:"+child.getName()+"\t节点值:"+child.getValue());
                    }
    
                    System.out.println("结束解析第"+(bookList.indexOf(book)+1)
                            +"本书============");
                }
    
            } catch (FileNotFoundException e1) {
                // TODO Auto-generated catch block
                e1.printStackTrace();
            } catch (JDOMException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
    
        }
    
    }
    

    输出:
    开始解析第1本书============
    属性名:id 属性值:1
    节点名:name 节点值:冰与火之歌
    节点名:author 节点值:乔治马丁
    节点名:year 节点值:2014
    节点名:price 节点值:99
    结束解析第1本书============
    开始解析第2本书============
    属性名:id 属性值:2
    节点名:name 节点值:秦腔
    节点名:author 节点值:贾平凹
    节点名:price 节点值:90
    结束解析第2本书============

    如果解析出来中文出现乱码情况,修改XML文件第一行的encoding属性。如果修改无效,再继续在java代码中进行修改操作。创建InputStreamReader对象并直接制定字符编码:

    InputStreamReader ins=new InputStreamReader(in,"UTF-8");

    加入存储Book对象的操作:

    package test;
    
    import java.util.ArrayList;
    import java.util.List;
    import java.io.FileInputStream;
    import java.io.FileNotFoundException;
    import java.io.IOException;
    import java.io.InputStream;
    import java.io.InputStreamReader;
    
    import org.jdom2.Attribute;
    import org.jdom2.Document;
    import org.jdom2.Element;
    import org.jdom2.JDOMException;
    import org.jdom2.input.SAXBuilder;
    
    import test3.Book;
    
    public class JDOMTest {
        private static ArrayList<Book> booksList=new ArrayList<Book>();
        public static void main(String[] args) {
            //JDOM解析XML文件
            //创建一个SAXBuilder对象
            SAXBuilder saxbuilder=new SAXBuilder();
    
            InputStream in;
            try {
                //创建一个输入流,将xml文件加载到流中
                in = new FileInputStream("src/res/books.xml");
    //          InputStreamReader ins=new InputStreamReader(in,"UTF-8");
                //通过saxbuilder的build方法将输入流加载到saxbuilder中
                Document document= saxbuilder.build(in);
    
                //通过document对象获取xml文件的根节点
                Element rootElement= document.getRootElement(); 
    
                //获取根节点下的子节点的集合
                List<Element> bookList=rootElement.getChildren();
    
                //使用foreach循环解析
    
                for (Element book : bookList) {
                    Book bookEntity=new Book();
                    System.out.println("开始解析第"+(bookList.indexOf(book)+1)
                            +"本书============");
    
                    //解析book的属性
                    List<Attribute> attrList=book.getAttributes();
    
    //              //知道节点属性名
    //              book.getAttribute("id");
    
    
                    //针对不清楚book节点下属性名和数量的情况
                    //遍历attrList
                    for (Attribute attr : attrList) {
                        //获取属性名和属性值
                        String attrName=attr.getName();
                        String attrValue=attr.getValue();
                        System.out.println("属性名:"+attrName+"\t属性值:"+attrValue);
                        //存储book节点
                        if(attrName.equals("id")){
                            bookEntity.setId(attrValue);
                        }
                    }
    
                    //对book节点的子节点的节点名和节点值进行遍历
                    List<Element> bookChilds= book.getChildren();
                    for (Element child : bookChilds) {
                        System.out.println("节点名:"+child.getName()+"\t节点值:"+child.getValue());
    
                        //存储子节点名
                        if(child.getName().equals("name")){
                            bookEntity.setName(child.getValue());
                        }else if(child.getName().equals("author")){
                            bookEntity.setAuthor(child.getValue());
                        }else if(child.getName().equals("year")){
                            bookEntity.setYear(child.getValue());
                        }else if(child.getName().equals("price")){
                            bookEntity.setPrice(child.getValue());
                        }
                    }
    
                    System.out.println("结束解析第"+(bookList.indexOf(book)+1)
                            +"本书============");
                    //添加booksList集合对象
                    booksList.add(bookEntity);
                    bookEntity=null;
                    System.out.println(booksList.size());
                    System.out.println(booksList.get(0).getId());
                    System.out.println(booksList.get(0).getName());
                }
    
            } catch (FileNotFoundException e1) {
                // TODO Auto-generated catch block
                e1.printStackTrace();
            } catch (JDOMException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
    
        }
    
    }
    

    输出:
    开始解析第1本书============
    属性名:id 属性值:1
    节点名:name 节点值:冰与火之歌
    节点名:author 节点值:乔治马丁
    节点名:year 节点值:2014
    节点名:price 节点值:99
    结束解析第1本书============
    1
    1
    冰与火之歌
    开始解析第2本书============
    属性名:id 属性值:2
    节点名:name 节点值:秦腔
    节点名:author 节点值:贾平凹
    节点名:price 节点值:90
    结束解析第2本书============
    2
    1
    冰与火之歌

    DOM4J解析:
    先导入DOM4J jar包

    package Dom4jTest;
    
    import java.io.File;
    import java.util.Iterator;
    import java.util.List;
    
    import org.dom4j.Attribute;
    import org.dom4j.Document;
    import org.dom4j.DocumentException;
    import org.dom4j.Element;
    import org.dom4j.io.SAXReader;
    
    public class DOM4JTest {
    
        public static void main(String[] args) {
            // TODO Auto-generated method stub
            //创建SAXReader对象
            SAXReader reader=new SAXReader();
            //通过reader对象read 方法加载book.xml
            try {
                Document document=reader.read(new File("src/res/books.xml"));
                //通过document对象获取根节点bookstore
                Element bookStore=document.getRootElement();
                //通过element对象的elementIterator方法获取迭代器
                Iterator it=bookStore.elementIterator();
                //遍历迭代器,获取根节点中的信息
                while(it.hasNext()){
                    System.out.println("开始遍历一本书");
                    Element book=(Element) it.next();
                    //获取book的属性名和属性值
                    List<Attribute> bookAttrs=book.attributes();
                    for (Attribute attr : bookAttrs) {
                        System.out.println("属性名:"+attr.getName()
                        +"\t属性值:"+attr.getValue());
                    }
    
                    Iterator itt=book.elementIterator();
                    while(itt.hasNext()){
                        Element bookChild=(Element) itt.next();
                        System.out.println("节点名:"+bookChild.getName()+
                                "\t节点值:"+bookChild.getStringValue());
                    }
    
                    System.out.println("结束遍历一本书"+"\n");
                }
            } catch (DocumentException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    
    }
    

    输出:
    开始遍历一本书
    属性名:id 属性值:1
    节点名:name 节点值:冰与火之歌
    节点名:author 节点值:乔治马丁
    节点名:year 节点值:2014
    节点名:price 节点值:99
    结束遍历一本书

    开始遍历一本书
    属性名:id 属性值:2
    节点名:name 节点值:秦腔
    节点名:author 节点值:贾平凹
    节点名:price 节点值:90
    结束遍历一本书

    四种解析方式对比:
    基础:
    DOM(跨平台)、一次性加载全部XML。
    优点:形成了树结构,直观显示,代码编写简单;解析过程中树结构保留在内存中,便于修改。
    缺点:XML文件较大时,太耗内存,影响解析操作并造成内存溢出。

    SAX(基于事件驱动的解析方式)逐行读取解析
    优点:占内存小,适用于只处理XML中的数据。
    缺点:不易编码,很难同时访问同一个XML中的多出不同数据。

    扩展(仅在JAVA平台使用):JDOM仅使用具体类而不是接口,API大量使用了Cillections类。
    DOM4J、是JDOM的一种只能分支。合并了很多超出基本XML文档表示的功能;使用接口和抽象基本类;具有灵活性好,性能特异,功能强大和极端易用的特点。开源软件。

    展开全文
  • java解析XML文件DOMO

    2014-10-15 15:08:59
    java加载xml文件解析得到数据java加载xml文件解析得到数据
  • JAVA 解析XML文档

    2008-01-30 14:36:00
    首先讲述一下DOM(文档对象模型)方法来实现对xml文档的解析:主要分为四步:第一步,获得一个XML文件的解析器...第二步,解析XML文件生成DOM文档的接口类DocumentBuilder db = null;第三步,创建一个新的Document

    首先讲述一下DOM(文档对象模型)方法来实现对xml文档的解析:

    主要分为四步:

    第一步,获得一个XML文件的解析器

    DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();

    第二步,解析XML文件生成DOM文档的接口类

    DocumentBuilder db = null;

    第三步,创建一个新的DocumentBuilder对象

    db = dbf.newDocumentBuilder();

    第四步,解析XML文档,生成Document对象

    Document doc = db.parse(inFile);

    最后可以利用Document提供的接口来访问DOM树,获取XML文档的元素

    Dom接口表示了一棵树,下面是一些基本的概念:

    Document 接口: 表示DOM文档对象

    Element 接口: 表示元素节点 如<姓名>

    Node 接口: 表示元素叶节点 如 小田 包括在<姓名>中

    NodeList 接口: 便是元素叶节点列表

    展开全文
  • JAVA 解析XML文件

    2017-02-18 22:17:37
    什么是XML文件? XML,可扩展的标识语言(eXtensibleMarkupLanguage) XML是一种类似于HTML的标记语言,XML是用来描述数据的,XML的标记不是在XML中预定义的,你必须定义自己的标记,XML使用文档类型定义(DTD)或者...
  • java 解析xml文件

    2017-08-08 09:45:57
    java使用DOM如何解析xml文件中的单闭合标签,例如<name/>,没有具体的值?
  • 使用java解析XML文件,解析完之后将解析结果导入mysql数据库中
  • Java解析XML文档(简单实例)——dom解析xml 一、前言    用Java解析XML文档,最常用的有两种方法:使用基于事件的XML简单API(Simple API for XML)称为SAX和基于树和节点的文档对象模型(Document Object ...
  • java解析xml文件的四种方式

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 359,085
精华内容 143,634
关键字:

java解析xml文件

java 订阅