Dom Sax Pull解析xml

最新推荐文章于 2024-05-28 21:12:14 发布
最新推荐文章于 2024-05-28 21:12:14 发布
阅读量537 收藏
点赞数
分类专栏： Android 文章标签： xml exception string properties blog output 

import java.io.ByteArrayOutputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.StringWriter;
import java.util.Properties;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.transform.OutputKeys;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerConfigurationException;
import javax.xml.transform.TransformerException;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;

import org.w3c.dom.DOMException;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;

import android.R.string;
import android.content.Context;

public class XmlDom {

	private final String filename = "DomXml.xml";
	private Context mContext = null;

	public XmlDom(Context context) {
		this.mContext = context;
	}

	public String XmlCreate() {
		
		String xmlWriter = null;
		Person[] persons = new Person[3];
		persons[0] = new Person(1, "facebook", "www.facebook.com");
		persons[1] = new Person(2, "baidu", "www.baidu.com");
		persons[2] = new Person(3, "google", "www.google.com");

		try {
			DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
			DocumentBuilder builder = factory.newDocumentBuilder();
			Document doc = builder.newDocument();
			
			Element eRoot = doc.createElement("root");
			eRoot.setAttribute("author", "homer");  //设置根元素属性
			eRoot.setAttribute("data", "2012-8-12");
			doc.appendChild(eRoot);  //将根元素附加到Document对象

			for (int i = 0; i < persons.length; i++) {
				Element ePerson = doc.createElement("person");//创建“person”元素
				eRoot.appendChild(ePerson);

				Element eId = doc.createElement("id");//创建“id”节点
				Node nodeId = doc.createTextNode(persons[i].getId() + "");
				eId.appendChild(nodeId);
				ePerson.appendChild(eId);//向“person”中添加“id”元素

				Element eName = doc.createElement("name");
				Node nodeName = doc.createTextNode(persons[i].getName());
				eName.appendChild(nodeName);
				ePerson.appendChild(eName);

				Element eBlog = doc.createElement("blog");
				Node nodeBlog = doc.createTextNode(persons[i].getBlog());
				eBlog.appendChild(nodeBlog);
				ePerson.appendChild(eBlog);

			}

			Properties properties = new Properties();
			properties.setProperty(OutputKeys.INDENT, "yes");//缩进
			properties.setProperty(OutputKeys.VERSION, "1.0");//xml版本
			properties.setProperty(OutputKeys.ENCODING, "utf-8");//文档的编码方式
			properties.setProperty(OutputKeys.METHOD, "xml");//输出格式
			properties.setProperty(OutputKeys.OMIT_XML_DECLARATION, "yes");//xml声明
			
			//创建一个转换器对象
			TransformerFactory transformerFactory = TransformerFactory.newInstance();
			Transformer transformer = transformerFactory.newTransformer();
			transformer.setOutputProperties(properties);

			DOMSource domSource = new DOMSource(doc.getDocumentElement());
			OutputStream output = new ByteArrayOutputStream();
			StreamResult result = new StreamResult(output);
			transformer.transform(domSource, result);

			xmlWriter = output.toString();

		}
		catch (ParserConfigurationException e) {
			e.printStackTrace();
		}
		catch (DOMException e) {
			e.printStackTrace();
		}
		catch (TransformerConfigurationException e) {
			e.printStackTrace();
		}
		catch (TransformerException e) {
			e.printStackTrace();
		}
		catch (Exception e) {
			e.printStackTrace();
		}
		saveXml(filename, xmlWriter.toString());
		return xmlWriter.toString();
	}

//	解析xml
	public String xmlParse() {
		
		StringWriter xmlWriter = new StringWriter();
		InputStream is = readXml(filename);
		try {
			DocumentBuilderFactory documentBuilderFactory = DocumentBuilderFactory.newInstance();
			DocumentBuilder documentBuilder = documentBuilderFactory.newDocumentBuilder();
			Document document = documentBuilder.parse(is);
			
			document.getDocumentElement().normalize();
			NodeList nodeRoot = document.getElementsByTagName("root");
			Element elementRoot = (Element)nodeRoot.item(0);
			String attributeAuthor = elementRoot.getAttribute("Author");
			String attributeDate = elementRoot.getAttribute("Date");
			xmlWriter.append("root").append("\t");
			xmlWriter.append(attributeAuthor).append("\t");
			xmlWriter.append(attributeDate).append("\n");
			
			NodeList nodePersion = elementRoot.getElementsByTagName("person");
			Person[] persons = new Person[nodePersion.getLength()];
			for (int i = 0; i < persons.length; i++) {
				Element personElement = (Element)nodePersion.item(i);
				Person person = new Person();
				
				NodeList nlId = personElement.getElementsByTagName("id");
				Element idElement = (Element)nlId.item(0);
				String id = idElement.getChildNodes().item(0).getNodeValue();
				person.setId(Integer.parseInt(id));
				
				NodeList nlName = personElement.getElementsByTagName("name");
				Element nameElement = (Element)nlName.item(0);
				String name = nameElement.getChildNodes().item(0).getNodeValue();
				person.setName(name);
				
				NodeList nlBlog = personElement.getElementsByTagName("blog");
				Element blogElement = (Element)nlBlog.item(0);
				String blog = blogElement.getChildNodes().item(0).getNodeValue();
				person.setBlog(blog);
				
				xmlWriter.append(person.toString()).append("\n");
				persons[i] = person;
			}
		}
		catch (ParserConfigurationException e) {
			// TODO: handle exception
		}catch (IOException e) {
			// TODO: handle exception
		}catch (Exception e) {
			// TODO: handle exception
		}
		return xmlWriter.toString();
	}
	private void saveXml(String filename, String xml) {
		FileOutputStream fout =null;
		try {
			fout = mContext.openFileOutput(filename, mContext.MODE_PRIVATE);
			byte []buffer = xml.getBytes();
			fout.write(buffer);
			fout.close();
		}
		catch (FileNotFoundException e) {
			// TODO: handle exception
		}catch (IOException e) {
			// TODO: handle exception
		}catch (Exception e) {
			// TODO: handle exception
		}
	}
	
	private InputStream readXml(String filename) {
		FileInputStream fin = null;
		try {
			fin = mContext.openFileInput(filename);
			
		}
		catch (FileNotFoundException e) {
			// TODO: handle exception
		}catch (Exception e) {
			// TODO: handle exception
		}
		return fin;
	}
	
}


Sax解析

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.StringWriter;
import java.util.ArrayList;
import java.util.List;

import javax.xml.parsers.FactoryConfigurationError;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.parsers.SAXParser;
import javax.xml.parsers.SAXParserFactory;
import javax.xml.transform.OutputKeys;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerConfigurationException;
import javax.xml.transform.TransformerFactoryConfigurationError;
import javax.xml.transform.sax.SAXTransformerFactory;
import javax.xml.transform.sax.TransformerHandler;
import javax.xml.transform.stream.StreamResult;

import org.xml.sax.Attributes;
import org.xml.sax.SAXException;
import org.xml.sax.helpers.AttributesImpl;
import org.xml.sax.helpers.DefaultHandler;

import android.content.Context;


public class SaxXml {


	private final String fileName = "SaxXml.xml";
	private Context mContext = null;

	public SaxXml(Context context) {
		this.mContext = context;
	}
	/** Sax方式，创建 XML  */
	public String saxCreateXML(){
		StringWriter xmlWriter = new StringWriter();

		Person []persons = new Person[3];		// 创建节点Person对象
		persons[0] = new Person(1, "facebook", "www.facebook.com");
		persons[1] = new Person(2, "baidu", "www.baidu.com");
		persons[2] = new Person(3, "google", "www.google.com");
		
		try {
			SAXTransformerFactory factory = (SAXTransformerFactory)SAXTransformerFactory.newInstance();
			TransformerHandler handler = factory.newTransformerHandler();//获取能够将 SAX ContentHandler 事件处理为 Result 的 TransformerHandler 对象
			
			Transformer transformer = handler.getTransformer();		// 用于设置参数和输出属性
			transformer.setOutputProperty(OutputKeys.INDENT, "yes");//设置转换中实际的输出属性
			transformer.setOutputProperty(OutputKeys.ENCODING, "utf-8");
			transformer.setOutputProperty(OutputKeys.VERSION, "1.0");
			
			StreamResult result = new StreamResult(xmlWriter);		// 保存创建的xml
			handler.setResult(result);
			
			handler.startDocument();
			AttributesImpl attr = new AttributesImpl();
			
			attr.clear();
			attr.addAttribute("", "", "author", "", "homer"); //将属性添加到列表的末尾
			attr.addAttribute("", "", "date", "", "2012-04-27");
			handler.startElement("", "", "root", attr);
			
			int personsLen = persons.length;
			for(int i=0; i<personsLen; i++){
				attr.clear();
				handler.startElement("", "", "person", attr);
				
				attr.clear();
				handler.startElement("", "", "id", attr);
				String id = persons[i].getId() + "";
				handler.characters(id.toCharArray(), 0, id.length());
				handler.endElement("", "", "id");

				attr.clear();
				handler.startElement("", "", "name", attr);
				String name = persons[i].getName();
				handler.characters(name.toCharArray(), 0, name.length());
				handler.endElement("", "", "name");

				attr.clear();
				handler.startElement("", "", "blog", attr);
				String blog = persons[i].getBlog();
				handler.characters(blog.toCharArray(), 0, blog.length());
				handler.endElement("", "", "blog");
				
				handler.endElement("", "", "person");
			}
			
			handler.endElement("", "", "root");
			handler.endDocument();
			
		} catch (TransformerFactoryConfigurationError e) {		// SAXTransformerFactory.newInstance
			e.printStackTrace();
		} catch (TransformerConfigurationException e) {			// factory.newTransformerHandler
			e.printStackTrace();
		} catch (IllegalArgumentException e) {		// transformer.setOutputProperty
			e.printStackTrace();
		} catch (SAXException e) {		// handler.startDocument
			e.printStackTrace();
		} catch (Exception e) {
			e.printStackTrace();
		}
		
		saveXml(fileName, xmlWriter.toString());
		return xmlWriter.toString();
	}
	
	/** Sax方式，解析 XML  */
	public String saxResolveXML(){
		StringWriter xmlWriter = new StringWriter();//一个字符流，可以用其回收在字符串缓冲区中的输出来构造字符串

		InputStream is = readXml(fileName);
		try {
			SAXParserFactory factory = SAXParserFactory.newInstance();
			SAXParser saxParser = factory.newSAXParser();
			
			PersonHandler handler = new PersonHandler();	// person处理Handler
			saxParser.parse(is, handler);					// handler解析xml
			
			// 获取解析的xml
			String xmlHeader = handler.getXMLHeader();
			xmlWriter.append(xmlHeader);
			
			List<Person> personsList = handler.getPersons();
			int personsLen = personsList.size();
			for(int i=0; i<personsLen; i++){
				xmlWriter.append(personsList.get(i).toString()).append("\n");
			}
			
		} catch (FactoryConfigurationError e) {			// SAXParserFactory.newInstance
			e.printStackTrace();
		} catch (ParserConfigurationException e) {		// factory.newSAXParser
			e.printStackTrace();
		} catch (SAXException e) {			// factory.newSAXParser
			e.printStackTrace();
		} catch (IllegalArgumentException e) {		// saxParser.parse
			e.printStackTrace();
		} catch (IOException e) {			// saxParser.parse
			e.printStackTrace();
		} catch (Exception e) {
			e.printStackTrace();
		}
		
		return xmlWriter.toString();
	}
	
	/** Handler处理类 */
	private final class PersonHandler extends DefaultHandler{
		private List<Person> personsList = null;	// 保存person
		private Person person = null;
		private StringBuffer xmlHeader;				// 保存xml头部信息
		private String tag = null;			// xml Element
		
		/** 返回解析的xml头部信息 */
		public String getXMLHeader(){
			return xmlHeader.toString();
		}
		
		/** 返回解析的Person实例数组 */
		public List<Person> getPersons(){
			return personsList;
		}
		
		@Override
		public void startDocument() throws SAXException{
			super.startDocument();
			personsList = new ArrayList<Person>();
			xmlHeader = new StringBuffer();
		}
		
		@Override
		public void startElement(String uri, String localName, String qName, Attributes attributes) throws SAXException{
			super.startElement(uri, localName, qName, attributes);
			if("root".equals(localName)) {
				String attrAuthor = attributes.getValue(0);
				String attrDate = attributes.getValue(1);
				xmlHeader.append("root").append("\t\t");
				xmlHeader.append(attrAuthor).append("\t");
				xmlHeader.append(attrDate).append("\n");
			} else if("person".equals(localName)) {
				person = new Person();
			} 
			tag = localName;
		}
		
		@Override
		public void characters(char[] ch, int start, int length) throws SAXException {
			super.characters(ch, start, length);
			if (null != tag) {
				String value = new String(ch, start, length);
				System.out.println("value = " + value);
				if ("id".equals(tag)) {
					person.setId(new Integer(value));
				} else if ("name".equals(tag)) {
					person.setName(value);
				} else if ("blog".equals(tag)) {
					person.setBlog(value);
				}
			}
		}
		
		@Override
		public void endElement(String uri, String localName, String qName) throws SAXException {
			if("person".equals(qName)) {
				personsList.add(person);
				person = null;
			}
			tag = null;
			super.endElement(uri, localName, qName);
		}
		
		@Override
		public void endDocument() throws SAXException{
//			personsList = null;
			super.endDocument();
		}
	}
	private void saveXml(String fileName, String xml) {
		FileOutputStream fout =null;
		try {
			fout = mContext.openFileOutput(fileName, mContext.MODE_PRIVATE);
			byte []buffer = xml.getBytes();
			fout.write(buffer);
			fout.close();
		}
		catch (FileNotFoundException e) {
			// TODO: handle exception
		}catch (IOException e) {
			// TODO: handle exception
		}catch (Exception e) {
			// TODO: handle exception
		}
	}
	
	private InputStream readXml(String fileName) {
		FileInputStream fin = null;
		try {
			fin = mContext.openFileInput(fileName);
			
		}
		catch (FileNotFoundException e) {
			// TODO: handle exception
		}catch (Exception e) {
			// TODO: handle exception
		}
		return fin;
	}
	
}

Pull解析

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.StringWriter;
import java.util.ArrayList;
import java.util.List;

import org.xmlpull.v1.XmlPullParser;
import org.xmlpull.v1.XmlPullParserException;
import org.xmlpull.v1.XmlPullParserFactory;
import org.xmlpull.v1.XmlSerializer;

import wsi.decodeXml.Person;

import android.content.Context;

public class PullXml {

	private final String fileName = "SaxXml.xml";
	private Context mContext = null;

	public PullXml(Context context) {
		this.mContext = context;
	}
	/** Pull方式，创建 XML  */
	public String pullXMLCreate(){
		StringWriter xmlWriter = new StringWriter();

		Person []persons = new Person[3];		// 创建节点Person对象
		persons[0] = new Person(1, "facebook", "www.facebook.com");
		persons[1] = new Person(2, "baidu", "www.baidu.com");
		persons[2] = new Person(3, "google", "www.google.com");

		
		try {
//			// 方式一：使用Android提供的实用工具类android.util.Xml
//			XmlSerializer xmlSerializer = Xml.newSerializer();		
			
			// 方式二：使用工厂类XmlPullParserFactory的方式
			XmlPullParserFactory factory = XmlPullParserFactory.newInstance();
			XmlSerializer xmlSerializer = factory.newSerializer();
			
			xmlSerializer.setOutput(xmlWriter);				// 保存创建的xml
			
			xmlSerializer.setFeature("http://xmlpull.org/v1/doc/features.html#indent-output", true);
//			xmlSerializer.setProperty("http://xmlpull.org/v1/doc/properties.html#serializer-indentation", " ");			// 设置属性
//			xmlSerializer.setProperty("http://xmlpull.org/v1/doc/properties.html#serializer-line-separator", "\n");
			xmlSerializer.startDocument("utf-8", null);		// <?xml version='1.0' encoding='UTF-8' standalone='yes' ?> 
			
			xmlSerializer.startTag("", "root");
			xmlSerializer.attribute("", "author", "homer");
			xmlSerializer.attribute("", "date", "2012-04-28");
			
			int personsLen = persons.length;
			for(int i=0; i<personsLen; i++) {
				xmlSerializer.startTag("", "person");		// 创建person节点
				
				xmlSerializer.startTag("", "id");
				xmlSerializer.text(persons[i].getId()+"");
				xmlSerializer.endTag("", "id");

				xmlSerializer.startTag("", "name");
				xmlSerializer.text(persons[i].getName());
				xmlSerializer.endTag("", "name");

				xmlSerializer.startTag("", "blog");
				xmlSerializer.text(persons[i].getBlog());
				xmlSerializer.endTag("", "blog");
				
				xmlSerializer.endTag("", "person");
			}
			
			xmlSerializer.endTag("", "root");
			xmlSerializer.endDocument();
			
		} catch (XmlPullParserException e) {		// XmlPullParserFactory.newInstance
			e.printStackTrace();
		} catch (IllegalArgumentException e) {		// xmlSerializer.setOutput
			e.printStackTrace();
		} catch (IllegalStateException e) {			// xmlSerializer.setOutput
			e.printStackTrace();
		} catch (IOException e) {		// xmlSerializer.setOutput
			e.printStackTrace();
		} catch (Exception e) {
			e.printStackTrace();
		}
		
		saveXml(fileName, xmlWriter.toString());
		return xmlWriter.toString();
	}
	
	/** Pull方式，解析 XML  */
	public String pullXMLResolve(){
		StringWriter xmlWriter = new StringWriter();
		
		InputStream is = readXml(fileName);
		try {
//			// 方式一：使用Android提供的实用工具类android.util.Xml
//			XmlPullParser xpp = Xml.newPullParser();
			
			// 方式二：使用工厂类XmlPullParserFactory的方式
			XmlPullParserFactory factory = XmlPullParserFactory.newInstance();
			XmlPullParser xpp = factory.newPullParser();
			
			xpp.setInput(is, "utf-8");
			
			List<Person> personsList = null;		// 保存xml的person节点
			Person person = null;
			StringBuffer xmlHeader = null;			// 保存xml头部
			String ele = null;		// Element flag
			
			int eventType = xpp.getEventType();
			while(XmlPullParser.END_DOCUMENT != eventType) {
				switch (eventType) {
				case XmlPullParser.START_DOCUMENT:
					personsList = new ArrayList<Person>();		// 初始化persons
					xmlHeader = new StringBuffer();				// 初始化xmlHeader
					break;
					
				case XmlPullParser.START_TAG:
					if("root".equals(xpp.getName())) {
						String attrAuthor = xpp.getAttributeValue(0);
						String attrDate = xpp.getAttributeValue(1);
						xmlHeader.append("root").append("\t\t");
						xmlHeader.append(attrAuthor).append("\t");
						xmlHeader.append(attrDate).append("\n");
					} else if("person".equals(xpp.getName())) {
						person = new Person();			// 创建person实例
					} else if("id".equals(xpp.getName())) {
						ele = "id";
					} else if("name".equals(xpp.getName())) {
						ele = "name";
					} else if("blog".equals(xpp.getName())) {
						ele = "blog";
					} else {
						ele = null;
					}
					break;
					
				case XmlPullParser.TEXT:
					if(null != ele) {
						if("id".equals(ele)) {
							person.setId(Integer.parseInt(xpp.getText()));
						} else if("name".equals(ele)) {
							person.setName(xpp.getText());
						} else if("blog".equals(ele)) {
							person.setBlog(xpp.getText());
						}
					}
					break;
					
				case XmlPullParser.END_TAG:
					if("person".equals(xpp.getName())){
						personsList.add(person);
						person = null;
					}
					ele = null;
					break;
				}
				
				eventType = xpp.next();		// 下一个事件类型
			}
			
			xmlWriter.append(xmlHeader);
			int personsLen = personsList.size();
			for(int i=0; i<personsLen; i++) {
				xmlWriter.append(personsList.get(i).toString());
			}
			
		} catch (XmlPullParserException e) {		// XmlPullParserFactory.newInstance
			e.printStackTrace();
		} catch (Exception e) {
			e.printStackTrace();
		}
		
		return xmlWriter.toString();		
	}
	private void saveXml(String fileName, String xml) {
		FileOutputStream fout =null;
		try {
			fout = mContext.openFileOutput(fileName, mContext.MODE_PRIVATE);
			byte []buffer = xml.getBytes();
			fout.write(buffer);
			fout.close();
		}
		catch (FileNotFoundException e) {
			// TODO: handle exception
		}catch (IOException e) {
			// TODO: handle exception
		}catch (Exception e) {
			// TODO: handle exception
		}
	}
	
	private InputStream readXml(String fileName) {
		FileInputStream fin = null;
		try {
			fin = mContext.openFileInput(fileName);
			
		}
		catch (FileNotFoundException e) {
			// TODO: handle exception
		}catch (Exception e) {
			// TODO: handle exception
		}
		return fin;
	}
	
}

参考：http://blog.csdn.net/sunboy_2050/article/details/7516058

http://www.ibm.com/developerworks/cn/xml/x-androidxml/

http://blog.csdn.net/hosterZhu/article/details/6123274

http://blog.csdn.net/sunboy_2050/article/details/7521598

http://blog.csdn.net/sunboy_2050/article/details/7521601

http://www.ibm.com/developerworks/cn/xml/x-android/

http://blog.csdn.net/ichliebephone/article/details/5981913

weiyier
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Dom sax pull解析xml的差异
05-08 800
----------------------------------------Dom解析xml------------------------------------------ 》DOM简介         dom全称Document Object Model ,为xml文档的已解析版本定义了一组接口。解析器读入整个文档，然后构建一个主流内存的树结构，          然后
java pull解析与_Java sax、dom、pull解析xml
weixin_30735701的博客
02-21 115
-------------------------------------SAX解析xml----------------------------------》Sax定义SAX是一个解析速度快并且占用内存少的xml解析器，非常适合用于android等移动设备SAX全称是Simple API for Xml，既是指一种接口，也是一个软件包作为接口，sax是事件驱动型xml解析的一个标准接口》Sax特...
利用Dom,Sax,Pull三种方式解析xml文件
知其然，必将知其所以然
02-27 686
最近找工作,看到许多公司的要求里都写了要会xml解析,所以就把之前的xml解析知识又重新回顾了一下,写个小例子.解析xml文件常用的几种方式也就dom,sax,pull了,并且面试官经常问到的也是这三种解析方式之间的优缺点以及使用情况,先说一下这三种方式的优缺点和使用情况吧:其实dom,sax,pull之间的优缺点网上有很多,讲的搞不好比我的还要深入和贴切,不过还是要说一下,毕竟自己以后还是要回顾...
Android基础篇-XML文件解析汇总SAX/DOM/PULL
王涛的博客
09-14 692
阅读时如有疑问和错误欢迎评论提出或者加我企鹅1262135886 ,谢谢支持SAX 、DOM4J 、PULL解析的区别 Sax特点（ SAX是Simple API for XML的简称） 1. 解析效率高，占用内存少 2.可以随时停止解析 3.不能载入整个文档到内存 4.不能写入xml 5.SAX解析xml
dom4j解析xml
m0_60181622的博客
04-20 3950
xml xml解析技术介绍 xml可扩展的标记性语言 不管是html文件还是xml文件，它们都是标记性文档，都可以使用w3c组织制定的 dom 技术进行解析 早期JDK为我们提供了两种xml解析技术Dom和Sax： 1) dom解析技术是w3c组织制定的，而所有的编程语言都对这个解析技术使用了自己的特点进行实现 2) sun公司在JDK5版本对dom解析技术进行升级：Sax（Simple API for xml） 第三方解析： 1) jdom在dom基础上进行了封装 2) dom4j又对jdom进行
DOM、SAX、Pull解析XML
闫新宇的博客
07-28 192
您可以通过点击 右下角 的按钮 来对文章内容作出评价, 也可以通过左下方的 关注按钮 来关注我的博客的最新动态。 如果文章内容对您有帮助, 不要忘记点击右下角的 推荐按钮 来支持一下哦 如果您对文章内容有任何疑问, 可以通过评论或发邮件的方式联系我: 501395377@qq.com / lzp501395377@gmail.com 如果需要转载，请注明出处，谢谢！！
Android之SAX、DOM和Pull解析XML
姚镜堂
04-12 2199
Android之SAX、DOM和Pull解析XML文章链接知识点 XML的3种解析方式：SAX、DOM和Pull； PULL解析XML文档示例； Dom解析XML文档示例； SAX解析XML文档示例； 调用运行结果示例； 新名词记录{SAX、DOM和Pull解析XML文档} 概述XML的解析有3中解析方式：SAX、DOM、Pull。SAX(Simple API for XML) 使用流式处理的方式，
XML三种解析方式 SAX、Dom、Pull
云淡风轻的博客
04-24 999
SAX解析： 1.解析效率高，占用内存少 2.可以随时停止解析 3.不能整个文档载入内存 4.不能写入xm 5.SAX解析采用事件驱动型 SAX并不需要解析整个文档，在按顺序解析文档的过程中，SAX会判断当前读到的字符是否合法xml中的部分，如果符合就触发 SAX工作原理：对文档进行顺序扫描，扫描到文档的开始和结尾，扫到元素的开始与结束等地方调用时间处理，处理函数做相应的动作，然后接
Android解析xml（DOM SAX PULL）
snail_Long的博客
03-05 444
也不知在黑暗中究竟沉睡了多久，也不知要有多难才能睁开双眼，我从远方赶来 恰巧你们也在，痴迷流连人间 我为她而狂野，我是这耀眼的瞬间，是划过天边的刹那火焰，我为你来看我不顾一切，我将熄灭永不能再回来，我在这里啊，就在这里啊，惊鸿一般短暂，像夏花一样绚烂，这是一个多美丽又遗憾的世界 ——《生如夏花》
Android SAX、DOM、Pull解析xml文件案例讲解
11-20
读取和解析xml文件
使用sax,pull,dom4j解析XML
09-05
使用环境eclipse4.8,jdk1.8 使用sax,pull,dom4j解析XML,对xml的简单解析,sax,pull,dom4j的简单使用
SAX,PULL,DOM解析XML
08-04
pull,sax,dom,解析XML的例子：各一个
Android编程解析XML方法详解(SAX,DOM与PULL)
09-02
主要介绍了Android编程解析XML方法,结合实例形式详细分析了Android解析XML文件的常用方法与相关实现技巧,需要的朋友可以参考下
Android解析XML的三种方式SAX、Pull、Dom
09-02
主要为大家详细介绍了Android解析XML的三种方式：SAX、Pull、Dom，感兴趣的小伙伴们可以参考一下
java配置文件解析yml/xml/properties文件
编写博客，学习交流
05-28 209
以mybatis.xml:获取所有Environment中的数据库并连接session为例。
【前端】XML和HTML的区别详解
double222222的博客
05-28 757
XML（eXtensible Markup Language）是一种标记语言，主要用于存储和传输数据。XML的设计目标是强调数据的自描述性和可扩展性。XML标签没有预定义，用户可以根据需要创建自己的标签。HTML（HyperText Markup Language）是一种标记语言，用于创建和展示网页内容。HTML的设计目标是强调内容的显示和链接能力。HTML标签是预定义的，每个标签都有特定的意义和用途。XML：标签是用户自定义的，可以根据需要创建任何标签，标签名必须遵循规则。HTML。
XML和JSON的区别
祈澈菇凉
05-28 256
JSON更加简洁紧凑,解析更加高效,因此在现代Web开发中更加流行。但XML可以表达更丰富的数据结构,在一些特定领域(如配置文件、文档格式等)仍有广泛应用。具体使用哪种格式,需要根据实际项目需求进行权衡和选择。
Mybatis的Xml映射文件
最新发布
weixin_55639995的博客
05-28 303
如果是查询操作,那么要resultmap的类型与Emp保持一致。resultType 是单条数据返回的数据类型。那么我们就先根据这三点规范,去定义。从mybatis的官网复制。
SAX 方式解析 XML 的操作流程。
05-19
SAX 是一种基于事件驱动的 XML 解析器，它的操作流程大致如下： 1. 创建 SAXParser 对象； 2. 实现自己的 Handler，以响应 ...与 DOM 不同，SAX 不需要将整个文档加载到内存中，因此适用于对大型 XML 文件进行处理。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值