java解析XML几种方式小结

最新推荐文章于 2025-11-18 09:13:51 发布
转载 最新推荐文章于 2025-11-18 09:13:51 发布 · 1.1k 阅读 · 0
本文介绍了 Java 中常用的几种 XML 解析技术，包括 DOM、SAX 和 JDOM 的特点及应用示例。DOM 提供随机访问，适用于较小的文档；SAX 采用事件驱动模式，适合大型文件；JDOM 则结合两者优点，简化 API 并增强易用性。

java解析XML几种方式小结

第一种：DOM。

DOM的全称是Document Object Model，也即文档对象模型。在应用程序中，基于DOM的XML分析器将一个XML文档转换成一个对象模型的集合（通常称DOM树），应用程序正是通过对这个对象模型的操作，来实现对XML文档数据的操作。通过DOM接口，应用程序可以在任何时候访问XML文档中的任何一部分数据，因此，这种利用DOM接口的机制也被称作随机访问机制。

DOM接口提供了一种通过分层对象模型来访问XML文档信息的方式，这些分层对象模型依据XML的文档结构形成了一棵节点树。无论XML文档中所描述的是什么类型的信息，即便是制表数据、项目列表或一个文档，利用DOM所生成的模型都是节点树的形式。也就是说，DOM强制使用树模型来访问XML文档中的信息。由于XML本质上就是一种分层结构，所以这种描述方法是相当有效的。

DOM树所提供的随机访问方式给应用程序的开发带来了很大的灵活性，它可以任意地控制整个XML文档中的内容。然而，由于DOM分析器把整个XML文档转化成DOM树放在了内存中，因此，当文档比较大或者结构比较复杂时，对内存的需求就比较高。而且，对于结构复杂的树的遍历也是一项耗时的操作。所以，DOM分析器对机器性能的要求比较高，实现效率不十分理想。不过，由于DOM分析器所采用的树结构的思想与XML文档的结构相吻合，同时鉴于随机访问所带来的方便，因此，DOM分析器还是有很广泛的使用价值的。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
import java.io.File;
  
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
  
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.NodeList;
  
public class DomTest1
{
   public static void main(String[] args) throws Exception
   {
     // step 1: 获得dom解析器工厂（工作的作用是用于创建具体的解析器）
     DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
      
//   System.out.println("class name: " + dbf.getClass().getName());
      
     // step 2:获得具体的dom解析器
     DocumentBuilder db = dbf.newDocumentBuilder();
      
//   System.out.println("class name: " + db.getClass().getName());
      
     // step3: 解析一个xml文档，获得Document对象（根结点）
     Document document = db.parse( new File( "candidate.xml" ));
      
     NodeList list = document.getElementsByTagName( "PERSON" );
      
     for ( int i = 0 ; i < list.getLength(); i++)
     {
       Element element = (Element)list.item(i);
        
       String content = element.getElementsByTagName( "NAME" ).item( 0 ).getFirstChild().getNodeValue();
        
       System.out.println( "name:" + content);
        
       content = element.getElementsByTagName( "ADDRESS" ).item( 0 ).getFirstChild().getNodeValue();
        
       System.out.println( "address:" + content);
        
       content = element.getElementsByTagName( "TEL" ).item( 0 ).getFirstChild().getNodeValue();
        
       System.out.println( "tel:" + content);
        
       content = element.getElementsByTagName( "FAX" ).item( 0 ).getFirstChild().getNodeValue();
        
       System.out.println( "fax:" + content);
        
       content = element.getElementsByTagName( "EMAIL" ).item( 0 ).getFirstChild().getNodeValue();
        
       System.out.println( "email:" + content);
        
       System.out.println( "--------------------------------------" );
     }
   }
}
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
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.Element;
import org.w3c.dom.NamedNodeMap;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
  
/**
  * 使用递归解析给定的任意一个xml文档并且将其内容输出到命令行上
  * @author zhanglong
  *
  */
public class DomTest3
{
   public static void main(String[] args) throws Exception
   {
     DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
     DocumentBuilder db = dbf.newDocumentBuilder();
      
     Document doc = db.parse( new File( "student.xml" ));
     //获得根元素结点
     Element root = doc.getDocumentElement();
      
     parseElement(root);
   }
    
   private static void parseElement(Element element)
   {
     String tagName = element.getNodeName();
      
     NodeList children = element.getChildNodes();
      
     System.out.print( "<" + tagName);
      
     //element元素的所有属性所构成的NamedNodeMap对象，需要对其进行判断
     NamedNodeMap map = element.getAttributes();
      
     //如果该元素存在属性
     if ( null != map)
     {
       for ( int i = 0 ; i < map.getLength(); i++)
       {
         //获得该元素的每一个属性
         Attr attr = (Attr)map.item(i);
          
         String attrName = attr.getName();
         String attrValue = attr.getValue();
          
         System.out.print( " " + attrName + "=\"" + attrValue + "\"" );
       }
     }
      
     System.out.print( ">" );
      
     for ( int i = 0 ; i < children.getLength(); i++)
     {
       Node node = children.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.print(data);
          
         System.out.print( "-->" );
       }
     }
      
     System.out.print( "</" + tagName + ">" );
   }
}

sax：SAX的全称是Simple APIs for XML，也即XML简单应用程序接口。与DOM不同，SAX提供的访问模式是一种顺序模式，这是一种快速读写XML数据的方式。当使用SAX分析器对XML文档进行分析时，会触发一系列事件，并激活相应的事件处理函数，应用程序通过这些事件处理函数实现对XML文档的访问，因而SAX接口也被称作事件驱动接口。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
import java.io.File;
  
import javax.xml.parsers.SAXParser;
import javax.xml.parsers.SAXParserFactory;
  
import org.xml.sax.Attributes;
import org.xml.sax.SAXException;
import org.xml.sax.helpers.DefaultHandler;
  
public class SaxTest1
{
   public static void main(String[] args) throws Exception
   {
     //step1： 获得SAX解析器工厂实例
     SAXParserFactory factory = SAXParserFactory.newInstance();
      
     //step2: 获得SAX解析器实例
     SAXParser parser = factory.newSAXParser();
      
     //step3: 开始进行解析
     parser.parse( new File( "student.xml" ), new MyHandler());
      
   }
}
  
class MyHandler extends DefaultHandler
{
   @Override
   public void startDocument() throws SAXException
   {
     System.out.println( "parse began" );
   }
    
   @Override
   public void endDocument() throws SAXException
   {
     System.out.println( "parse finished" );
   }
    
   @Override
   public void startElement(String uri, String localName, String qName,
       Attributes attributes) throws SAXException
   {
     System.out.println( "start element" );
   }
    
   @Override
   public void endElement(String uri, String localName, String qName)
       throws SAXException
   {
     System.out.println( "finish element" );
   }
}
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
import java.io.File;
import java.util.Stack;
  
import javax.xml.parsers.SAXParser;
import javax.xml.parsers.SAXParserFactory;
  
import org.xml.sax.Attributes;
import org.xml.sax.SAXException;
import org.xml.sax.helpers.DefaultHandler;
  
public class SaxTest2
{
   public static void main(String[] args) throws Exception
   {
     SAXParserFactory factory = SAXParserFactory.newInstance();
      
     SAXParser parser = factory.newSAXParser();
      
     parser.parse( new File( "student.xml" ), new MyHandler2());
   }
}
  
class MyHandler2 extends DefaultHandler
{
   private Stack<String> stack = new Stack<String>();
    
   private String name;
    
   private String gender;
    
   private String age;
    
   @Override
   public void startElement(String uri, String localName, String qName,
       Attributes attributes) throws SAXException
   {
     stack.push(qName);
      
     for ( int i = 0 ; i < attributes.getLength(); i++)
     {
       String attrName = attributes.getQName(i);
       String attrValue = attributes.getValue(i);
        
       System.out.println(attrName + "=" + attrValue);
     }
   }
    
   @Override
   public void characters( char [] ch, int start, int length)
       throws SAXException
   {
     String tag = stack.peek();
      
     if ( "姓名" .equals(tag))
     {
       name = new String(ch, start,length);
     }
     else if ( "性别" .equals(tag))
     {
       gender = new String(ch, start, length);
     }
     else if ( "年龄" .equals(tag))
     {
       age = new String(ch, start, length);
     }
   }
    
   @Override
   public void endElement(String uri, String localName, String qName)
       throws SAXException
   {
     stack.pop(); //表示该元素已经解析完毕，需要从栈中弹出
      
     if ( "学生" .equals(qName))
     {
       System.out.println( "姓名：" + name);
       System.out.println( "性别：" + gender);
       System.out.println( "年龄：" + age);
        
       System.out.println();
     }
      
   }
}


JDOM:

JDOM是一个开源项目，它基于树型结构，利用纯JAVA的技术对XML文档实现解析、生成、序列化以及多种操作。（http://jdom.org）

•JDOM 直接为JAVA编程服务。它利用更为强有力的JAVA语言的诸多特性（方法重载、集合概念等），把SAX和DOM的功能有效地结合起来。

•JDOM是用Java语言读、写、操作XML的新API函数。在直接、简单和高效的前提下，这些API函数被最大限度的优化。

jdom创建xml

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
import java.io.FileWriter;
  
import org.jdom.Attribute;
import org.jdom.Comment;
import org.jdom.Document;
import org.jdom.Element;
import org.jdom.output.Format;
import org.jdom.output.XMLOutputter;
  
public class JDomTest1
{
   public static void main(String[] args) throws Exception
   {
     Document document = new Document();
  
     Element root = new Element( "root" );
  
     document.addContent(root);
  
     Comment comment = new Comment( "This is my comments" );
  
     root.addContent(comment);
  
     Element e = new Element( "hello" );
  
     e.setAttribute( "sohu" , "www.sohu.com" );
  
     root.addContent(e);
  
     Element e2 = new Element( "world" );
  
     Attribute attr = new Attribute( "test" , "hehe" );
  
     e2.setAttribute(attr);
  
     e.addContent(e2);
  
     e2.addContent( new Element( "aaa" ).setAttribute( "a" , "b" )
         .setAttribute( "x" , "y" ).setAttribute( "gg" , "hh" ).setText( "text content" ));
  
      
     Format format = Format.getPrettyFormat();
      
     format.setIndent( "  " );
//   format.setEncoding("gbk");
      
     XMLOutputter out = new XMLOutputter(format);
  
     out.output(document, new FileWriter( "jdom.xml" ));
      
   }
}

JDOM解析xml

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
import java.io.File;
import java.io.FileOutputStream;
import java.util.List;
  
import org.jdom.Attribute;
import org.jdom.Document;
import org.jdom.Element;
import org.jdom.input.SAXBuilder;
import org.jdom.output.Format;
import org.jdom.output.XMLOutputter;
  
public class JDomTest2
{
   public static void main(String[] args) throws Exception
   {
     SAXBuilder builder = new SAXBuilder();
      
     Document doc = builder.build( new File( "jdom.xml" ));
      
     Element element = doc.getRootElement();
      
     System.out.println(element.getName());
      
     Element hello = element.getChild( "hello" );
      
     System.out.println(hello.getText());
      
     List list = hello.getAttributes();
      
     for ( int i = 0 ;i < list.size(); i++)
     {
       Attribute attr = (Attribute)list.get(i);
        
       String attrName = attr.getName();
       String attrValue = attr.getValue();
        
       System.out.println(attrName + "=" + attrValue);
     }
      
     hello.removeChild( "world" );
      
     XMLOutputter out = new XMLOutputter(Format.getPrettyFormat().setIndent( "  " ));
      
      
     out.output(doc, new FileOutputStream( "jdom2.xml" ));   
      
   }
}

Dom4j

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
import java.io.FileOutputStream;
import java.io.FileWriter;
  
import org.dom4j.Document;
import org.dom4j.DocumentHelper;
import org.dom4j.Element;
import org.dom4j.io.OutputFormat;
import org.dom4j.io.XMLWriter;
  
public class Test1
{
   public static void main(String[] args) throws Exception
   {
     // 创建文档并设置文档的根元素节点 ：第一种方式
     // Document document = DocumentHelper.createDocument();
     //
     // Element root = DocumentHelper.createElement("student");
     //
     // document.setRootElement(root);
  
     // 创建文档并设置文档的根元素节点 ：第二种方式
     Element root = DocumentHelper.createElement( "student" );
     Document document = DocumentHelper.createDocument(root);
  
     root.addAttribute( "name" , "zhangsan" );
  
     Element helloElement = root.addElement( "hello" );
     Element worldElement = root.addElement( "world" );
  
     helloElement.setText( "hello" );
     worldElement.setText( "world" );
  
     helloElement.addAttribute( "age" , "20" );
  
     XMLWriter xmlWriter = new XMLWriter();
     xmlWriter.write(document);
      
     OutputFormat format = new OutputFormat( "  " , true );
      
     XMLWriter xmlWriter2 = new XMLWriter( new FileOutputStream( "student2.xml" ), format);
     xmlWriter2.write(document);
      
     XMLWriter xmlWriter3 = new XMLWriter( new FileWriter( "student3.xml" ), format);
      
     xmlWriter3.write(document);
     xmlWriter3.close();
  
   }
}
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
import java.io.File;
import java.util.Iterator;
import java.util.List;
  
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
  
import org.dom4j.Document;
import org.dom4j.Element;
import org.dom4j.io.DOMReader;
import org.dom4j.io.SAXReader;
  
public class Test2
{
   public static void main(String[] args) throws Exception
   {
     SAXReader saxReader = new SAXReader();
      
     Document doc = saxReader.read( new File( "student2.xml" ));
      
     Element root = doc.getRootElement();
      
     System.out.println( "root element: " + root.getName());
      
     List childList = root.elements();
      
     System.out.println(childList.size());
      
     List childList2 = root.elements( "hello" );
      
     System.out.println(childList2.size());
      
     Element first = root.element( "hello" );
      
     System.out.println(first.attributeValue( "age" ));
      
     for (Iterator iter = root.elementIterator(); iter.hasNext();)
     {
       Element e = (Element)iter.next();
        
       System.out.println(e.attributeValue( "age" ));
     }
      
     System.out.println( "---------------------------" );
      
     DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
     DocumentBuilder db = dbf.newDocumentBuilder();
     org.w3c.dom.Document document = db.parse( new File( "student2.xml" ));
      
     DOMReader domReader = new DOMReader();
      
     //将JAXP的Document转换为dom4j的Document
     Document d = domReader.read(document);
      
     Element rootElement = d.getRootElement();
      
     System.out.println(rootElement.getName());
  
   }
}
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
import java.io.FileWriter;
  
import org.jdom.Attribute;
import org.jdom.Document;
import org.jdom.Element;
import org.jdom.output.Format;
import org.jdom.output.XMLOutputter;
  
public class Test3
{
   public static void main(String[] args) throws Exception
   {
     Document document = new Document();
  
     Element root = new Element( "联系人列表" ).setAttribute( new Attribute( "公司" ,
         "A集团" ));
  
     document.addContent(root);
      
     Element contactPerson = new Element( "联系人" );
      
     root.addContent(contactPerson);
  
     contactPerson
         .addContent( new Element( "姓名" ).setText( "张三" ))
         .addContent( new Element( "公司" ).setText( "A公司" ))
         .addContent( new Element( "电话" ).setText( "021-55556666" ))
         .addContent(
             new Element( "地址" )
                 .addContent( new Element( "街道" ).setText( "5街" ))
                 .addContent( new Element( "城市" ).setText( "上海" ))
                 .addContent( new Element( "省份" ).setText( "上海市" )));
  
     XMLOutputter output = new XMLOutputter(Format.getPrettyFormat()
         .setIndent( "  " ).setEncoding( "gbk" ));
  
     output.output(document, new FileWriter( "contact.xml" ));
  
   }
}
CodingSir
关注
Java解析XML工具类--(java源码)
01-14
package com.hexiang.utils; import javax.xml.parsers.DocumentBuilder; import javax.xml.parsers.DocumentBuilderFactory; import org.w3c.dom.Document; import org.w3c.dom.Element; import org.w3c.dom.NodeList; /** * 本类是专门解析XML文件的，主要用于为系统读取自己的配置文件时提供最方便的解析操作 * @author HX * */ public class XmlManager { /** * 得到某节点下某个属性的值 * @param element 要获取属性的节点 * @param attributeName 要取值的属性名称 * @return 要获取的属性的值 * @author HX_2010-01-12 */ public static String getAttribute( Element element, String attributeName ) { return element.getAttribute( attributeName ); } /** * 获取指定节点下的文本 * @param element 要获取文本的节点 * @return 指定节点下的文本 * @author HX_2010-01-12 */ public static String getText( Element element ) { return element.getFirstChild().getNodeValue(); } /** * 解析某个xml文件，并在内存中创建DOM树 * @param xmlFile 要解析的XML文件 * @return 解析某个配置文件后的Document * @throws Exception xml文件不存在 */ public static Document parse( String xmlFile ) throws Exception { // 绑定XML文件，建造DOM树 DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance(); DocumentBuilder db = dbf.newDocumentBuilder(); Document domTree = db.parse( xmlFile ); return domTree; } /** * 获得某节点下的某个子节点（指定子节点名称，和某个属性的值） * 即获取parentElement下名字叫childName，并且属性attributeName的值为attributeValue的子结点 * @param parentElement 要获取子节点的那个父节点 * @param childName 要获取的子节点名称 * @param attributeName 要指定的属性名称 * @param attributeValue 要指定的属性的值 * @return 符合条件的子节点 * @throws Exception 子结点不存在或有多个符合条件的子节点 * @author HX_2008-12-01 */ public static Element getChildElement( Element parentElement, String childName, String attributeName, String attributeValue ) throws Exception { NodeList list = parentElement.getElementsByTagName( childName ); int count = 0; Element curElement = null; for ( int i = 0 ; i < list.getLength() ; i ++ ) { Element child = ( Element )list.item( i ); String value = child.getAttribute( attributeName ); if ( true == value.equals( attributeValue ) ) { curElement =
java通用解析XML工具类
03-24
java通用解析XML工具类
Java 使用XmlUtil解析Xml
记录工作开发中遇到的技术难点，方便自己查看，也希望可以帮助到他人...
06-27 3571
引言：在日常编码中，我们接触最多的除了JSON外，就是XML格式了，一般而言，我们首先想到的是引入Dom4j包，却不知JDK已经封装有XML解析和构建工具：w3c dom。但是由于这个API操作比较繁琐，因此Hutool中提供了XmlUtil简化XML的创建、读和写的过程。...
Java中操作Xml使用备忘[ Hutool工具类XmlUtil、XStream ]
热门推荐
Zhaof_Notes
05-24 1万+
Java中操作Xml使用备忘
Java 解析xml文件-工具类
zcxbd的博客
06-18 1527
Java解析xml文件，对应的Javabean是根据xml中的节点来创建，如SeexmlZbomord、SeexmlIdoc等等。
java菜鸟|xml小结
qq_36584575的博客
02-09 495
xml和json小结 xml的简介 可扩展标记语言（eXtensible Markup Language）。 特性: xml具有平台无关性, 是一门独立的标记语言. xml具有自我描述性 学习xml的原因 网络数据传输. 数据存储 配置文件 .xml文件 .XML文件是保存XML数据的一种方式 XML数据也可以以其他的方式存在（如在内存中构建XML数据）。 不要将XML语言狭隘的理解成XML文件。 xml的语法格式 1. xml需要开始就写文档声明。 例如： <?xml version="1.
深入浅出：使用DOM4J结合XPath高效解析XML
2301_80237574的博客
10-02 1618
当将数据存储在XML后，我们就希望通过程序获取XML的内容。我们使用Java基础所学的IO知识是可以完成的，不过需要非常繁琐的操作才可以完成，且开发中会遇到不同问题（只读、读写）。人们为不同问题提供不同的解析方式，使用不同的解析器进行解析，方便开发人员操作XML。
【XML解析】使用Jaxp对XML进行DOM解析
王璐
05-05 1450
【前言】    璐小编在之前学习BS的时候接触过XML（请戳：【XML】基础知识初步认识），后来在项目中我们也会遇到XML的配置文件，现在学习Java又遇到对XML的文档内容进行解析。看来对于XML的认知是不断加深的过程~    本篇简介XML解析的方式以及使用Jaxp对XML文档进行dom解析。 【XML解析】     对于XML解析方式，有DOM文档对象模型和SAX两种。前者是
java xml解析工具类 java xml解析工具类
11-29
java xml解析工具类 java xml解析工具类 java xml解析工具类 java xml解析工具类 java xml解析工具类 java xml解析工具类 java xml解析工具类 java xml解析工具类 java xml解析工具类 java xml解析工具类 java xml解析工具类 java xml解析工具类 java xml解析工具类 java xml解析工具类 java xml解析工具类 java xml解析工具类java xml解析工具类 java xml解析工具类
java 解析xml 多级
08-07
企业级应用 java 解析多级xml 多么复杂的都可以， 一个类，一个jar 包，非常实用，希望大家顶起..
对Android中XML解析的小结
java程序
04-14 164
首先说明下为什么用SAX去解析~~现在随便去google一搜索很多的方法去解析XML因为现在XML满大街都是~~新闻可以用~~天气可以用~~论坛博客都可以用~~J2EE 里面经常用~~SSH框架~~同样用的很多就连现在Android的核心配置文件AndroidManifest.xml都是XML格式的以及res下面的文件基本上都是XML格式的~~在应用范围非常的广~~而且从存储和读取方面来说也比较方...
Java使用DOM简单解析XML文件
qq_44717657的博客
11-28 1084
Java解析XML文件流程的简单理解，工具类
XML 处理：在 Java 中解析和生成 XML！
最新发布
喵手的博客
11-18 1034
本文介绍了Java中XML处理的基本方法，包括DOM和SAX两种核心解析技术。文章首先回顾了XML基础语法，随后详细讲解了DOM解析的特点和实现方式，以及SAX解析的事件驱动机制。同时简要介绍了JDOM和DOM4J等第三方库的优势，并提及XML与Java对象的转换需求。通过对比不同解析技术的优缺点，为开发者选择合适的XML处理方案提供了参考依据。全文以代码示例辅助说明，帮助读者快速掌握XML解析的实践方法。
JAVA解析XML文件的四种方法小结
Night In Forest
12-06 209
首先是 DOM   DOM 是用与平台和语言无关的方式表示 XML 文档的官方 W3C 标准。DOM 是以层次结构组织的节点或信息片断的集合。这个层次结构允许开发人员在树中寻找特定信息。分析该结构通常需要加载整个文档和构造层次结构，然后才能做任何工作。由于它是基于信息层次的，因而 DOM 被认为是基于树或基于对象的。DOM 以及广义的基于树的处理具有几个优点。首先，由于树在内存中是持久的，因此可...
XML学习小结
追求大牛之人的博客
02-05 4420
XML是可扩展标记语言（Extensible Markup Language）的缩写，它是是一种数据表示格式，可以描述非常复杂的数据结构，常用于传输和存储数据。 例如，一个描述书籍的XML文档可能如下： <?xml version="1.0" encoding="UTF-8" ?> <!DOCTYPE note SYSTEM "book.dtd"> <book id="1"> <name>Java编程的逻辑</name> <a
XML小结
weixin_44435458的博客
06-01 211
1.XML的基本概念 定义：xml（Extensible Markup Language),可扩展标记语言 XML是一种数据的格式，和JSON差不多，可以用这种数据格式来存储和表示一组数据，又一系列的标签组成。 2.XML基本结构 格式良好的 XML 文档 2.XML文档优势 n XML基于文本格式，具有简单性、可扩展性、交互性和灵活性 xml格式一般在项目中做配置文件 Web项目中都可以用xm...
Java中XML运用总结
weixin_44722237的博客
05-24 2550
XML 简介： 可扩展标记语言（eXtensible Markup Language）。 特性: 1. xml具有平台无关性, 是一门独立的标记语言. 2. xml具有自我描述性 为什么学习XML？ 1. 网络数据传输. 2. 数据存储 3. 配置文件 XML文件 .XML文件是保存XML数据的一种方式 XML数据也可以以其他的方式存在（如在内存中构建XML数据）。 不要将XML语言狭隘的理解成XML文件。 XML语法格式 1. XML文档声明 <?xml versio..
日常小结-SAX解析xml
千念飞羽的专栏
06-26 1477
SAX可用在解析的过程中处理xml而不需要等到整个文件都存入内存在进行解析：SAX解析SAX采用事件处理的方式解析XML文件，利用SAX解析XML文件，涉及两个部分，解析器和事件处理器。 解析器可用使用JAXP的API创建，创建出SAX解析器后，就可以指定解析器去解析某个xml文档。 解析器采用sax方式在解析某个xml文档时，它只要解析到xml文档的一个组成部分，都会调用事件处理器的一个方法，解析
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值