精华内容
下载资源
问答
  • JAVA使用DOM解析XML

    千次阅读 2012-09-15 22:23:57
    JAVA使用DOM解析XML: 首先来了解点Java DOM 的 API: 1.解析器工厂类:DocumentBuilderFactory 创建的方法:DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance(); 2.解析器:DocumentBuilder ...

    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文档:

    <?xml version = "1.0" encoding = "utf-8"?>
    <School>
        <Student>
            <Name>沈浪</Name>
            <Num>1006010022</Num>
            <Classes>信管2</Classes>
            <Address>浙江杭州3</Address>
            <Tel>123456</Tel>
        </Student>
        <Student>
            <Name>沈1</Name>
            <Num>1006010033</Num>
            <Classes>信管1</Classes>
            <Address>浙江杭州4</Address>
            <Tel>234567</Tel>
        </Student>
        <Student>
            <Name>沈2</Name>
            <Num>1006010044</Num>
            <Classes>生工2</Classes>
            <Address>浙江杭州1</Address>
            <Tel>345678</Tel>
        </Student>
        <Student>
            <Name>沈3</Name>
            <Num>1006010055</Num>
            <Classes>电子2</Classes>
            <Address>浙江杭州2</Address>
            <Tel>456789</Tel>
        </Student>
    </School>

    DomDemo.java

    package xidian.sl.dom;
    
    import java.io.FileOutputStream;
    
    import javax.xml.parsers.DocumentBuilder;
    import javax.xml.parsers.DocumentBuilderFactory;
    
    import org.apache.crimson.tree.XmlDocument;
    import org.w3c.dom.Document;
    import org.w3c.dom.Element;
    import org.w3c.dom.NodeList;
    
    
    public class DomDemo {
        /**
         * 遍历xml文档
         * */
        public static void queryXml(){
            try{
                //得到DOM解析器的工厂实例
                DocumentBuilderFactory dbFactory = DocumentBuilderFactory.newInstance();
                //从DOM工厂中获得DOM解析器
                DocumentBuilder dbBuilder = dbFactory.newDocumentBuilder();
                //把要解析的xml文档读入DOM解析器
                Document doc = dbBuilder.parse("src/xidian/sl/dom/school.xml");
                System.out.println("处理该文档的DomImplementation对象  = "+ doc.getImplementation());
                //得到文档名称为Student的元素的节点列表
                NodeList nList = doc.getElementsByTagName("Student");
                //遍历该集合,显示结合中的元素及其子元素的名字
                for(int i = 0; i< nList.getLength() ; i ++){
                    Element node = (Element)nList.item(i);
                    System.out.println("Name: "+ node.getElementsByTagName("Name").item(0).getFirstChild().getNodeValue());
                    System.out.println("Num: "+ node.getElementsByTagName("Num").item(0).getFirstChild().getNodeValue());
                    System.out.println("Classes: "+ node.getElementsByTagName("Classes").item(0).getFirstChild().getNodeValue());
                    System.out.println("Address: "+ node.getElementsByTagName("Address").item(0).getFirstChild().getNodeValue());
                    System.out.println("Tel: "+ node.getElementsByTagName("Tel").item(0).getFirstChild().getNodeValue());
                }
                
            }catch (Exception e) {
                // TODO: handle exception
                e.printStackTrace();
            }
        }
        /**
         * 向已存在的xml文件中插入元素
         * */
        public static void insertXml(){
            Element school = null;
            Element student = null;
            Element name = null;
            Element num = null;
            Element classes = null;
            Element address = null;
            Element tel = null;
            try{
                //得到DOM解析器的工厂实例
                DocumentBuilderFactory dbFactory = DocumentBuilderFactory.newInstance();
                //从DOM工厂中获得DOM解析器
                DocumentBuilder dbBuilder = dbFactory.newDocumentBuilder();
                //把要解析的xml文档读入DOM解析器
                Document doc = dbBuilder.parse("src/xidian/sl/dom/school.xml");
                //得到文档名称为Student的元素的节点列表
                NodeList nList = doc.getElementsByTagName("School");
                school = (Element)nList.item(0);
                //创建名称为Student的元素
                student = doc.createElement("Student");
                //设置元素Student的属性值为231
                student.setAttribute("examId", "23");
                //创建名称为Name的元素
                name = doc.createElement("Name");
                //创建名称为 香香 的文本节点并作为子节点添加到name元素中
                name.appendChild(doc.createTextNode("香香"));
                //将name子元素添加到student中
                student.appendChild(name);
                /**
                 * 下面的元素依次加入即可
                 * */
                num = doc.createElement("Num");
                num.appendChild(doc.createTextNode("1006010066"));
                student.appendChild(num);
                
                classes = doc.createElement("Classes");
                classes.appendChild(doc.createTextNode("眼视光5"));
                student.appendChild(classes);
                
                address = doc.createElement("Address");
                address.appendChild(doc.createTextNode("浙江温州"));
                student.appendChild(address);
                
                tel = doc.createElement("Tel");
                tel.appendChild(doc.createTextNode("123890"));
                student.appendChild(tel);
                
                //将student作为子元素添加到树的根节点school
                school.appendChild(student);
                //将内存中的文档通过文件流生成insertSchool.xml,XmlDocument位于crison.jar下
                ((XmlDocument)doc).write(new FileOutputStream("src/xidian/sl/dom/insertSchool.xml"));
                System.out.println("成功");
            }catch (Exception e) {
                // TODO: handle exception
                e.printStackTrace();
            }    
        }
        public static void main(String[] args){
            //读取
            DomDemo.queryXml();
            //插入
            DomDemo.insertXml();
        }
    }

    运行后结果:

     


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

    打开查看内容:

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

     

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

    package xidian.sl.dom;
    
    import java.io.FileOutputStream;
    
    import javax.xml.parsers.DocumentBuilder;
    import javax.xml.parsers.DocumentBuilderFactory;
    
    import org.apache.crimson.tree.XmlDocument;
    import org.w3c.dom.Document;
    import org.w3c.dom.Element;
    
    
    public class CreateNewDom {
        /**
         * 创建xml文档
         * */
        public static void createDom(){
            Document doc;
            Element school,student;
            Element name = null;
            Element num = null;
            Element classes = null;
            Element address = null;
            Element tel = null;
            try{
                //得到DOM解析器的工厂实例
                DocumentBuilderFactory dbFactory = DocumentBuilderFactory.newInstance();
                //从DOM工厂中获得DOM解析器
                DocumentBuilder dbBuilder = dbFactory.newDocumentBuilder();
                //创建文档树模型对象
                doc = dbBuilder.newDocument();
                if(doc != null){
                    //创建school元素
                    school = doc.createElement("School");
                    //创建student元素
                    student = doc.createElement("Student");
                    //设置元素Student的属性值为231
                    student.setAttribute("examId", "23");
                    //创建名称为Name的元素
                    name = doc.createElement("Name");
                    //创建名称为 香香 的文本节点并作为子节点添加到name元素中
                    name.appendChild(doc.createTextNode("香香"));
                    //将name子元素添加到student中
                    student.appendChild(name);
                    /**
                     * 下面的元素依次加入即可
                     * */
                    num = doc.createElement("Num");
                    num.appendChild(doc.createTextNode("1006010066"));
                    student.appendChild(num);
                    
                    classes = doc.createElement("Classes");
                    classes.appendChild(doc.createTextNode("眼视光5"));
                    student.appendChild(classes);
                    
                    address = doc.createElement("Address");
                    address.appendChild(doc.createTextNode("浙江温州"));
                    student.appendChild(address);
                    
                    tel = doc.createElement("Tel");
                    tel.appendChild(doc.createTextNode("123890"));
                    student.appendChild(tel);
                    
                    //将student作为子元素添加到树的根节点school
                    school.appendChild(student);
                    //添加到文档树中
                    doc.appendChild(school);
                    //将内存中的文档通过文件流生成insertSchool.xml,XmlDocument位于crison.jar下
                    ((XmlDocument)doc).write(new FileOutputStream("src/xidian/sl/dom/createSchool.xml"));
                    System.out.println("创建成功");
                }
            }catch (Exception e) {
                // TODO: handle exception
                e.printStackTrace();
            }
        }
        public static void main(String[] args) {
            CreateNewDom.createDom();
        }
    }

    运行结果:

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


    原文链接:http://www.cnblogs.com/shenliang123/archive/2012/05/11/2495252.html
    展开全文
  • Java:使用DOM解析XML

    千次阅读 2018-10-17 18:42:45
    要理解XML,HTML等格式,先来理解文档对象模型DOM   根据 DOMHTML 文档中的每个成分都是一个节点,这些节点组成了一棵树。 DOM 是这样规定的: 整个文档是一个文档节点 每个 HTML 标签是一个元素节点 包含在 ...

    XML简介

    要理解XML,HTML等格式,先来理解文档对象模型DOM

      

    根据 DOM,HTML 文档中的每个成分都是一个节点,这些节点组成了一棵树。
    DOM 是这样规定的:
    整个文档是一个文档节点
    每个 HTML 标签是一个元素节点
    包含在 HTML 元素中的文本是文本节点
    每一个 HTML 属性是一个属性节点
    注释属于注释节点

    节点彼此都有等级关系。HTML 文档中的所有节点组成了一个文档树(或节点树)。HTML 文档中的每个元素、属性、文本等都代表着树中的一个节点。树起始于文档节点,并由此继续伸出枝条,直到处于这棵树最低级别的所有文本节点为止。

    DOM将整个XML文件加载到内存中,并构建出节点树;应用程序可以通过遍历节点树的方式来解析XML文件中的各个节点、属性等信息;
    这种方式便于对XML节点的添加修改等,而且解析也很方便,然后它比较耗费内存,解析速度也不快

    现在主要流行的是sax,dom4j和jdom
    使用dom4j :https://blog.csdn.net/chengmuzhe2690/article/details/83115697

    这章主要说使用DOM来解析

    而使用DOM解析XML是有步骤的

    1、创建解析器工厂对象 DocumentBuildFactory对象

    2、由解析器工厂对象创建解析器对象,即DocumentBuilder对象

    3、由解析器对象对指定XML文件进行解析,构建相应的DOM树,创建Document对象,生成一个Document对象

    4、以Document对象为起点对DOM树的节点进行查询

    5、使用Document的getElementsByTagName方法获取元素名称,生成一个NodeList集合,

    6、遍历集合

    DocumentBuilderFactory factroy = DocumentBuilderFactory.newInstance();
    		try {
    			DocumentBuilder builder = factroy.newDocumentBuilder();
    			Document document = builder.parse("pets.xml");
    			NodeList lists = document.getElementsByTagName("dog");
    			System.out.println("chengmuzhe养的狗狗初始化信息");
    
    
    			for (int i = 0; i < lists.getLength(); i++) {
    				Node pet = lists.item(i);
    				for (Node node = pet.getFirstChild(); node != null; node = node
    						.getNextSibling()) {
    					if (node.getNodeType() == Node.ELEMENT_NODE) {
    						String name = node.getNodeName();
    						String value = node.getFirstChild().getNodeValue();
    						System.out.println(name + ":" + value + "\t");
    					}
    				}
    			}
    			NodeList lists1 = document.getElementsByTagName("penguin");
    			System.out.println("chengmuzhe养企鹅的初始化信息");
    
    			for (int i = 0; i < lists1.getLength(); i++) {
    				Node pet = lists1.item(i);
    				for (Node node = pet.getFirstChild(); node != null; node = node
    						.getNextSibling()) {
    					if (node.getNodeType() == Node.ELEMENT_NODE) {
    						String name = node.getNodeName();
    						String value = node.getFirstChild().getNodeValue();
    						System.out.println(name + ":" + value + "\t");
    					}
    				}
    			}
    
    		} catch (Exception e) {
    			// TODO: handle exception
    		}
    
    	}

     

    展开全文
  • Java 使用 Dom4j 解析 XML 指南

    千次阅读 2015-01-08 11:05:18
    Java 使用 Dom4j 解析 XML 指南

    Java 使用 Dom4j 解析 XML 指南

    太阳火神的美丽人生 (http://blog.csdn.net/opengl_es)

    本文遵循“署名-非商业用途-保持一致”创作公用协议

    转载请保留此句:太阳火神的美丽人生 -  本博客专注于 敏捷开发及移动和物联设备研究:iOS、Android、Html5、Arduino、pcDuino否则,出自本博客的文章拒绝转载或再转载,谢谢合作。


    解析 XML
    Parsing XML

    首先要做的事情之一就是,可能要解析某种类型的一个 XML 文档。dom4j 中很容易做到这一点。下面的代码演示了如何去做。
    One of the first things you'll probably want to do is to parse an XML document of some kind. This is easy to do in dom4j. The following code demonstrates how to this.

    import java.net.URL;
    
    import org.dom4j.Document;
    import org.dom4j.DocumentException;
    import org.dom4j.io.SAXReader;
    
    public class Foo {
    
        public Document parse(URL url) throws DocumentException {
            SAXReader reader = new SAXReader();
            Document document = reader.read(url);
            return document;
        }
    }
    

    使用迭代器
    Using Iterators

    一个 XML 文档可以使用各种方法返回标准的 Java 迭代器进行导航。例如:
    A document can be navigated using a variety of methods that return standard Java Iterators. For example

        public void bar(Document document) throws DocumentException {
    
            Element root = document.getRootElement();
    
            // iterate through child elements of root
            for ( Iterator i = root.elementIterator(); i.hasNext(); ) {
                Element element = (Element) i.next();
                // do something
            }
    
            // iterate through child elements of root with element name "foo"
            for ( Iterator i = root.elementIterator( "foo" ); i.hasNext(); ) {
                Element foo = (Element) i.next();
                // do something
            }
    
            // iterate through attributes of root 
            for ( Iterator i = root.attributeIterator(); i.hasNext(); ) {
                Attribute attribute = (Attribute) i.next();
                // do something
            }
         }
    

    强大的 XPath 导航
    Powerful Navigation with XPath

    dom4j 中 XPath 表达式可以应用于文档或任何该树中的节点(诸如属性、元素或处理指示符)。这将允许使用一行代码在整个文档中实施复杂的导航。例如:
    In dom4j XPath expressions can be evaluated on the Document or on any Node in the tree (such as Attribute, Element or ProcessingInstruction). This allows complex navigation throughout the document with a single line of code. For example.

        public void bar(Document document) {
            List list = document.selectNodes( "//foo/bar" );
    
            Node node = document.selectSingleNode( "//foo/bar/author" );
    
            String name = node.valueOf( "@name" );
        }
    

    例如,你想要找到在一个 XHTML 文档中找到所有的超文本链接,下面的代码会被用到:
    For example if you wish to find all the hypertext links in an XHTML document the following code would do the trick.

        public void findLinks(Document document) throws DocumentException {
    
            List list = document.selectNodes( "//a/@href" );
    
            for (Iterator iter = list.iterator(); iter.hasNext(); ) {
                Attribute attribute = (Attribute) iter.next();
                String url = attribute.getValue();
            }
        }
    


    如果你需要任何学习 XPath 语言的帮助,我们强烈建议 Zvon tutorial ,它允许你通过示例来学习。
    If you need any help learning the XPath language we highly recommend the Zvon tutorial which allows you to learn by example.

    快速循环
    Fast Looping

    If you ever have to walk a large XML document tree then for performance we recommend you use the fast looping method which avoids the cost of creating an Iterator object for each loop. For example

        public void treeWalk(Document document) {
            treeWalk( document.getRootElement() );
        }
    
        public void treeWalk(Element element) {
            for ( int i = 0, size = element.nodeCount(); i < size; i++ ) {
                Node node = element.node(i);
                if ( node instanceof Element ) {
                    treeWalk( (Element) node );
                }
                else {
                    // do something....
                }
            }
        }
    

    Creating a new XML document

    Often in dom4j you will need to create a new document from scratch. Here's an example of doing that.

    import org.dom4j.Document;
    import org.dom4j.DocumentHelper;
    import org.dom4j.Element;
    
    public class Foo {
    
        public Document createDocument() {
            Document document = DocumentHelper.createDocument();
            Element root = document.addElement( "root" );
    
            Element author1 = root.addElement( "author" )
                .addAttribute( "name", "James" )
                .addAttribute( "location", "UK" )
                .addText( "James Strachan" );
            
            Element author2 = root.addElement( "author" )
                .addAttribute( "name", "Bob" )
                .addAttribute( "location", "US" )
                .addText( "Bob McWhirter" );
    
            return document;
        }
    }
    

    Writing a document to a file

    A quick and easy way to write a Document (or any Node) to a Writer is via the write() method.

      FileWriter out = new FileWriter( "foo.xml" );
      document.write( out );
    

    If you want to be able to change the format of the output, such as pretty printing or a compact format, or you want to be able to work with Writer objects or OutputStream objects as the destination, then you can use the XMLWriter class.

    import org.dom4j.Document;
    import org.dom4j.io.OutputFormat;
    import org.dom4j.io.XMLWriter;
    
    public class Foo {
    
        public void write(Document document) throws IOException {
    
            // lets write to a file
            XMLWriter writer = new XMLWriter(
                new FileWriter( "output.xml" )
            );
            writer.write( document );
            writer.close();
    
    
            // Pretty print the document to System.out
            OutputFormat format = OutputFormat.createPrettyPrint();
            writer = new XMLWriter( System.out, format );
            writer.write( document );
    
            // Compact format to System.out
            format = OutputFormat.createCompactFormat();
            writer = new XMLWriter( System.out, format );
            writer.write( document );
        }
    }
    

    Converting to and from Strings

    If you have a reference to a Document or any other Node such as an Attribute or Element, you can turn it into the default XML text via the asXML() method.

            Document document = ...;
            String text = document.asXML();
    

    If you have some XML as a String you can parse it back into a Document again using the helper method DocumentHelper.parseText()

            String text = "<person> <name>James</name> </person>";
            Document document = DocumentHelper.parseText(text);
    

    Styling a Document with XSLT

    Applying XSLT on a Document is quite straightforward using the JAXP API from Sun. This allows you to work against any XSLT engine such as Xalan or SAXON. Here is an example of using JAXP to create a transformer and then applying it to a Document.

    import javax.xml.transform.Transformer;
    import javax.xml.transform.TransformerFactory;
    
    import org.dom4j.Document;
    import org.dom4j.io.DocumentResult;
    import org.dom4j.io.DocumentSource;
    
    public class Foo {
    
        public Document styleDocument(
            Document document, 
            String stylesheet
        ) throws Exception {
    
            // load the transformer using JAXP
            TransformerFactory factory = TransformerFactory.newInstance();
            Transformer transformer = factory.newTransformer( 
                new StreamSource( stylesheet ) 
            );
    
            // now lets style the given document
            DocumentSource source = new DocumentSource( document );
            DocumentResult result = new DocumentResult();
            transformer.transform( source, result );
    
            // return the transformed document
            Document transformedDoc = result.getDocument();
            return transformedDoc;
        }
    }
    



    展开全文
  • DOM接口和XML的关系模型 W3C制定了一套书写XML分析器的标准接口规范—DOM。下面我们来看看DOM在应用程序开发过程中和XML文档的关系模型示意图。从图中我们可以看出,应用程序不是直接对XML...JavaDOM接口 在DOM
    1. DOM接口和XML的关系模型
      W3C制定了一套书写XML分析器的标准接口规范—DOM。下面我们来看看DOM在应用程序开发过程中和XML文档的关系模型示意图。从图中我们可以看出,应用程序不是直接对XML文档进行操作的,而是首先由XML分析器对XML文档进行分析,然后,应用程序通过对XML分析器所提供的DOM接口对分析结果进行操作,从而间接地实现对XML文档的访问。

      这里写图片描述

    2. Java中DOM接口
      在DOM接口规范中,有四个基本接口:Document,Node,NodeList以及NameNodeMap。在这四个接口中,Document接口是对文档进行操作的入口,它是从Node接口继续过来的。Node接口是其它接口的父类,像Document,Element,Attribute,Text ,comment 等接口都是从Node类接口继承过来的。NodeList 接口是一个节点的集合,它包含了某个节点中的子节点。NameNodeMap 接口也是一个节点的集合。通过该接口,可以建立节点和节点之间的一一映射关系,从而利用节点可以直接访问特定的节点。下面我们来具体了解一下,在Java DOM 解析一个XML文档时常用的类


    • 解析器工厂类:DocumentBuilderFactory 创建一个解析器工厂对象:DocumentBuilderFactory dbf =
      DocumentBuilderFactory.newInstance();

    • 解析器类:DocumentBuilder 通过解析器工厂类来获得 DocumentBuilder db = dbf.newDocumentBuilder();

    • XML 文档对象类:Document 通过xml文档 Document doc = db.parse(new File(“xml15.xml”));

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

    • 节点类Node
      Node对象是DOM中最基本的对象,代表了文档树中的抽象节点。但在实际使用中很少会直接使用Node对象,而是使用Node接口的实现类 Document,Element,Attribute,Text ,comment等。


    Java中Dom解析XML的递归实现

    package com.ywendeng.java.demo;
    
    import java.io.File;
    
    import javax.xml.parsers.DocumentBuilder;
    import javax.xml.parsers.DocumentBuilderFactory;
    
    import org.w3c.dom.Attr;
    import org.w3c.dom.Comment;
    import org.w3c.dom.Document;
    import org.w3c.dom.NamedNodeMap;
    import org.w3c.dom.Node;
    import org.w3c.dom.NodeList;
    import org.w3c.dom.Element;
    
    //用递归的方式解析给定的任意一个XML文档 ,并将其输出到命令行上
    public class Jaxp {
    
        public static void main(String[] args) throws Exception {
            DocumentBuilderFactory  dbf=DocumentBuilderFactory.newInstance();
    
            DocumentBuilder  db=dbf.newDocumentBuilder();
    
            Document doc=db.parse(new File("xml15.xml"));
            //获得根元素节点
            Element  root=doc.getDocumentElement();
            parseElement(root);
    
        }
        private  static void parseElement(Element element){
             //元素的名字
             String tagName=element.getNodeName();
             //获取该元素的所有子元素构成的节点
    
              NodeList childre=element.getChildNodes();
    
            System.out.print("<"+tagName);
            //element 元素的所有属性所构成的NameNodeMap 对象
            NamedNodeMap  nMap=element.getAttributes();
            //如果该元素存在属性
            if(nMap!=null){
                for(int i=0;i<nMap.getLength();i++){
                    //获得该元素的每一个属性
                    Attr  attr=(Attr)nMap.item(i);
                    String  attrName=attr.getName();
                    String  attrValue=attr.getValue();
                    System.out.print(" "+ attrName+"=\""+attrValue+"\"");
                }
    
            }
            System.out.print(">");
            for(int i=0;i<childre.getLength();i++){
                Node  node=childre.item(i);
                //获得节点的类型
                short nodeType=node.getNodeType();
                if(nodeType==node.ELEMENT_NODE){
                    //是元素  继续递归
                    parseElement((Element)node);
    
                }
                else if(nodeType==node.TEXT_NODE){
                    //是递归的出口
                    System.out.print(node.getNodeValue());
                }else if(nodeType==node.COMMENT_NODE){
                    System.out.print("<!--");
                    Comment  comment =(Comment)node;
                    //注释内容
                    String data=comment.getData();
                    System.out.println(data);
                    System.out.print("-->");
                }
            }
            System.out.print("</"+tagName+">");
        }
    }
    
    展开全文
  • java 使用dom4j解析xml

    2014-03-20 19:14:56
    链接地址 http://www.ibm.com/developerworks/cn/xml/x-dom4j.html#ibm-pcon
  • (感谢原作者,本文转载自 ...使用 import 语句导入 dom4j API 类: import org.dom4j.Document; import org.dom4j.DocumentHelper; import org.dom4j.Element;
  • ffdf 转载于:https://www.cnblogs.com/motadou/p/4471088.html
  • org.w3c.dom(java dom)解析XML文档 位于org.w3c.dom操作XML会比较简单,就是将XML看做是一颗树,DOM就是对这颗树的一个数据结构的描述,但对大型XML文件效果可能会不理想 首先来了解点Java DOM 的 API: 1.解析...
  • DOM的特点是随机读写查询,但是一次性要把xml读到内存里,对于大的xml文件而言,不是个好方法。 加之我个人觉得W3C的Document这套体系的坑比较多,如果要用的话,需要非常系统的学习才能避开这些坑,挺麻烦的。 所以...
  • 使用DOM解析XML文件

    千次阅读 2016-01-21 20:55:33
    XML是一种可扩展的标记语言,首先它是一种标记语言,类似于HTML,有标签,...首先,DOM是一种文档对象模型(Document Object Model),使用DOM解析时会将XML文档表示为树状,具有层次性。 如下是一个xml文件的例子:
  • Java进阶(二十七)使用Dom4j解析XML文件

    万次阅读 2016-04-23 21:24:11
    使用Dom4j解析XML文件写在前面的话 由于论文实验要求,需要实现操作XML文档,为此想到了dom4j这个工具,使用之后深感受益。在此分享给大家,以此共勉。 注:本文转载自...
  • 使用Simple-Html-Dom解析HTML文件

    千次阅读 2015-05-18 19:19:00
    Java中,有大牛封装好的库,我使用的是Jsoup。将Jsuop的Jar包引入项目中,指定好唯一标示,再使用选择器,就可以将数据解析出来,最近接触到了PHP,就像使用PHP解析个新闻来玩玩!Jsoup解析滁州学院官网获取信息...
  • Java DOM解析Xml中文乱码问题

    千次阅读 2015-08-24 00:32:55
    如果没有字符流,但却有字节流,则解析器将使用该字节流,从而使用在   InputSource   中指定的编码,或者另外(如果未指定编码)通过使用某种诸如 XML 规范 中的算法算法自动探测字符编码。如果既没有字符流,又...
  • 一、Java解析XML概述 ... DOM解析:1.要生成节点树,就必须加载整个文档。2.容易造成内存溢出。 SAX:Simple API for XML。这种方式不是官方标准,属于开源社区XML-DEV,几乎所有的XML解析器都支持...
  • 在文章《JAVA 使用Dom4j 解析XML》中,介绍了使用Dom44j解析XML,比如节点的解析遍历、节点的增加、删除、写入文件等操作,本文我们继续使用dom4j实现xml字符串与xml文件之间的转换。 1、xml文档或节点转换为字符串...
  • Dom4j(Document For Java)-第三方开源,是从jdom分裂出来的解析技术。目前jdom已经完全被dom4j替代。 【注意】: ①jDom – Dom4j的前身。 ②Dom4j在性能和速度上都比sun公司的要快,而且支持Xpath快速...
  • Java使用DOM读写XML

    千次阅读 2013-01-18 23:35:46
    通俗的说,就是通过解析XML文档,为XML文档在逻辑上建立一个树模型,树的节点是一个个对象。我们通过存取这些对象就能够存取XML文档的内容。 下面我们来看一个简单的例子,看看在DOM中,我们是如何来操作一个...
  • java dom4j 解析XML文件 简易教程

    千次阅读 2015-08-08 09:25:35
    java dom4j 解析XML文件 简易教程
  • DOM解析

    2018-11-22 15:04:43
    如果我们使用java 基础所学习 IO 知识是可以完成的, 不过你需要非常繁琐的操作才可以完成, 且开发中会遇到不同问题, 为不同问题提供不同的解析方式, 并提交对应的解析器, 方便开发人员操作XML. 关于解析方式和解析...
  • 一、利用Dom4j进行生成和解析XML文件,简要过程如下: //////////使用Dom4j创建XML文档 //【1】定义一个XML文档对象 Document document=DocumentHelper.createDocument(); //【2】定义一个XML元素,添加根结点 ...
  • 使用Dom4j 解析XML

    万次阅读 2017-04-16 20:30:01
    使用Dom4j 解析XML,dom4j操作节点属性,dom4j新增节点,把Document对象写入新的文件
  • Jquery、Java解析html字符串成dom对象,遍历dom对象获取图片元素(或者其子元素) 使用 Jquery解析html: .parseHTML方法:将html字符串解析成dom对象,他返回的是一个array数组(包含其所有子元素).parseHTML方法...
  • JAVA操作DOM工具类

    千次阅读 2019-04-10 19:27:53
    JAVA操作DOM工具类; org.w3c.dom操作html、xml等DOM文本。
  • java dom4j解析XML读取数据源配置的代码实例 源代码下载地址:http://www.zuidaima.com/share/1796449490865152.htm
  • 使用Dom4j解析XML

    万次阅读 多人点赞 2013-10-23 12:06:26
    dom4j是一个非常非常优秀的Java XML API,具有性能优异、功能强大和极端易用使用的特点,同时它也是一个开放源代码的软件,可以在SourceForge上找到它.  对主流的Java XML API进行的性能、功能和易用性的评测,dom4...
  • 5、使用DOM解析XML文档

    千次阅读 2013-02-27 10:41:54
    DOM:Document Object Model (文档对象模型) 1、DOM与SAX W3C制定了一套书写XML分析器的标准接口规范--DOM。除此之外,XML_DEV邮件列表中的成员根据应用的需求也自发地定义了一套对XML文档进行操作的接口规范--...
  • Java XML解析工具 dom4j介绍及使用实例

    千次阅读 2018-04-21 09:48:13
    大名鼎鼎的 DOM绿色环保的 SAX默默无闻的 Digester三种解析方式比较DOM优缺点:实现 W3C 标准,有多种编程语言支持这种解析方式,并且这种方法本身操作上简单快捷,十分易于初学者掌握。其处理方式是将 XML 整个作为...
  • DOM解析XML

    2014-04-12 20:37:22
    我们知道,用Java解析XML文档,最常用的有两种方法: (1)使用基于事件的XML简单API(Simple API for XML)称为SAX。 (2)基于树和节点的文档对象模型(Document Object Module)称为DOM。 ...
  • jsoup 是一个用于处理真实世界的HTML的Java库。它提供了一个非常方便的API来...从URL,文件或字符串中刮取和解析HTML使用DOM遍历或CSS选择器查找和提取数据操纵HTML元素,属性和文本清除用户提交的内容与安全的白名单

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 60,620
精华内容 24,248
关键字:

java使用dom解析html

java 订阅