Java 四种创建 解析XML方法 XML学习

最新推荐文章于 2024-08-17 02:04:49 发布
最新推荐文章于 2024-08-17 02:04:49 发布
阅读量306 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： XML 文章标签： xml java xml解析 xml创建 java创建解析xml
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/lingyiwin/article/details/113525922

Java 创建 解析XML

创建解析XMl

为什么要使用XML：

  • 不同应用程序之间的通信
  • 不同平台间通信
  • 不同平台之间的数据共享

四中解析方式的归纳和总结

基础解析方式

不需要导入jar包 DOM：平台无关的官方解析。
解析时：一次性将xml文件加载至内存，生成DOM树，比较 耗内存
优点：形成了树型结构，直观好理解，代码更容易编写。
解析过程中结构保存在内存中，方便修改。
缺点：当xml文件较大时，对内存消耗比较大，容易影响解析性能并造成内存溢出。

SAX ：基于事件驱动的解析方式。

优点：采用事件驱动模式，对内存消耗较少 适用于只需要处理xml中数据时
缺点：不易编码 很难同时访问同一个xml中的多处不同数据

扩展解析方式 ：需要导入相应的的jar包，只有在Java中才能使用

JDOM ：仅使用具体类而不使用接口
API大量使用Collections类

DOM4J：JDOM的一种智能分支，它合并了许多超出基本XML文档表示的功能。如： dtd、Scheme等

  • 使用接口和抽象基本类方法，是一个优秀的Java xml api
  • 具有性能优异、灵活性好、功能强大和极端易用的特点 是一个开放源代码的软件

总结：由于DOM4J的出众，项目中使用DOM4J的较多。

创建XML

package com.create.test;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.transform.OutputKeys;
import javax.xml.transform.Result;
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.sax.SAXTransformerFactory;
import javax.xml.transform.sax.TransformerHandler;
import javax.xml.transform.stream.StreamResult;

import org.dom4j.DocumentHelper;
import org.dom4j.io.OutputFormat;
import org.dom4j.io.XMLWriter;
import org.jdom2.output.Format;
import org.jdom2.output.XMLOutputter;
import org.junit.Test;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.xml.sax.SAXException;
import org.xml.sax.helpers.AttributesImpl;


public class CreateTest {

	/**
	 * DOM方式生成xml文档
	 */
	private void DOMCreateXML() {
		DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
		DocumentBuilder db = null;
		try {
			db = dbf.newDocumentBuilder();
		} catch (ParserConfigurationException e) {
			e.printStackTrace();
		}
		Document document = db.newDocument();
		document.setXmlStandalone(true);
		Element bookstore = document.createElement("bookStore");
		Element book = document.createElement("book");
		Element name = document.createElement("name");
		name.setTextContent("小王子");
		book.appendChild(name);
		book.setAttribute("id", "1");
		bookstore.appendChild(book);
		document.appendChild(bookstore);
		TransformerFactory tff = TransformerFactory.newInstance();
		try {
			Transformer tf = tff.newTransformer();
			tf.setOutputProperty(OutputKeys.INDENT, "yes");
			tf.transform(new DOMSource(document), new StreamResult(new File(
					"books1.xml")));
		} catch (TransformerConfigurationException e) {
			e.printStackTrace();
		} catch (TransformerException e) {
			e.printStackTrace();
		}
	}
	
	/**
	 * SAX方式生成xml文档
	 */
	public void SAXCreateXML() {
		SAXTransformerFactory tff = (SAXTransformerFactory) SAXTransformerFactory
				.newInstance();
		try {
			TransformerHandler handler = tff.newTransformerHandler();
			Transformer tr = handler.getTransformer();
			tr.setOutputProperty(OutputKeys.ENCODING, "UTF-8");
			tr.setOutputProperty(OutputKeys.INDENT, "yes");
			File f = new File("books2.xml");
			if (!f.exists()) {
				f.createNewFile();
			}
			Result result = new StreamResult(new FileOutputStream(f));
			handler.setResult(result);
			handler.startDocument();
			AttributesImpl attr = new AttributesImpl();
			handler.startElement("", "", "bookstore", attr);
			attr.clear();
			attr.addAttribute("", "", "id", "", "1");
			handler.startElement("", "", "book", attr);
			attr.clear();
			handler.startElement("", "", "name", attr);
			handler.characters("小王子".toCharArray(), 0, "小王子".length());
			handler.endElement("", "", "name");
		
			handler.endElement("", "", "book");
			handler.endElement("", "", "bookstore");
			handler.endDocument();

		} catch (TransformerConfigurationException e) {
			e.printStackTrace();
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} catch (SAXException e) {
			e.printStackTrace();
		}
	}
	
	/**
	 * JDOM方式生成xml文档
	 */
	private void JDOMCreateXML() {
		org.jdom2.Element bookstore = new org.jdom2.Element("bookstore");
		org.jdom2.Document document = new org.jdom2.Document(bookstore);
		
		org.jdom2.Element book = new org.jdom2.Element("book");
		book.setAttribute("id", "1");
		org.jdom2.Element name = new org.jdom2.Element("name");
		name.setText("小王子");
		book.addContent(name);
		bookstore.addContent(book);
		Format format = Format.getCompactFormat();
		format.setIndent("");
		format.setEncoding("UTF-8");
		XMLOutputter outputer = new XMLOutputter(format);
		try {
			outputer.output(document, new FileOutputStream(new File("books3.xml")));
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
	
	/**
	 * DOM4J方式生成xml文档
	 */
	private void DOM4JCreateXML(){
		org.dom4j.Document document = DocumentHelper.createDocument();
		org.dom4j.Element bookstore = document.addElement("bookstore");
		org.dom4j.Element book = bookstore.addElement("book");
		book.addAttribute("id", "1");
		org.dom4j.Element name = book.addElement("name");
		name.setText("小王子");
		OutputFormat format = OutputFormat.createPrettyPrint();
		format.setEncoding("UTF-8");
		File file = new File("books4.xml");
		XMLWriter writer;
		try {
			writer = new XMLWriter(new FileOutputStream(file), format);
			writer.setEscapeText(false);
			writer.write(document);
			writer.close();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

	@Test
	public void testPerformance() throws Exception{
		System.out.println("性能测试:");
		//测试DOM的性能:
		long start = System.currentTimeMillis();
		DOMCreateXML();
		System.out.println("DOM:"+ (System.currentTimeMillis() - start));
		//测试SAX的性能:
		start = System.currentTimeMillis();
		SAXCreateXML();
		System.out.println("SAX:"+ (System.currentTimeMillis() - start) );
		//测试JDOM的性能:
		start = System.currentTimeMillis();
		JDOMCreateXML();
		System.out.println("JDOM:"+ (System.currentTimeMillis() - start) );
		//测试DOM4J的性能:
		start = System.currentTimeMillis();
		DOM4JCreateXML();
		System.out.println("DOM4J:"+ (System.currentTimeMillis() - start) );
	}
}

解析XML

package com.parser.test;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.parsers.SAXParser;
import javax.xml.parsers.SAXParserFactory;

import org.dom4j.DocumentException;
import org.dom4j.io.SAXReader;
import org.jdom2.Attribute;
import org.jdom2.JDOMException;
import org.jdom2.input.SAXBuilder;
import org.junit.Test;
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;

import com.imooc.entity.Book;
import com.imooc.handler.SAXParserHandler;

public class ParseTest {


	public void domXmlParser() {
		ArrayList<Book> bookLists = new ArrayList<Book>();
		DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
		try {
			DocumentBuilder db = dbf.newDocumentBuilder();
			Document document = db.parse("books.xml");
			NodeList bookList = document.getElementsByTagName("book");
			for (int i = 0; i < bookList.getLength(); i++) {
				Node book = bookList.item(i);
				Book bookEntity = new Book();
				NamedNodeMap attrs = book.getAttributes();
				for (int j = 0; j < attrs.getLength(); j++) {
					Node attr = attrs.item(j);
					if (attr.getNodeName().equals("id")) {
						bookEntity.setId(attr.getNodeValue());
					}
				}
				NodeList childNodes = book.getChildNodes();
				for (int k = 0; k < childNodes.getLength(); k++) {
					if (childNodes.item(k).getNodeType() == Node.ELEMENT_NODE) {
						String name = childNodes.item(k).getNodeName();
						String value = childNodes.item(k).getFirstChild().getNodeValue();
						if (name.equals("name")) {
							bookEntity.setName(value);
						}
						else if (name.equals("author")) {
							bookEntity.setAuthor(value);
						}
						else if (name.equals("year")) {
							bookEntity.setYear(value);
						}
						else if (name.equals("price")) {
							bookEntity.setPrice(value);
						}
						else if (name.equals("language")) {
							bookEntity.setLanguage(value);
						}
					}
				}
				bookLists.add(bookEntity);
				bookEntity = null;
			}
		} catch (ParserConfigurationException e) {
			e.printStackTrace();
		} catch (SAXException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
	
	public void saxXmlParser(){
		SAXParserFactory factory = SAXParserFactory.newInstance();
		try {
			SAXParser parser = factory.newSAXParser();
			SAXParserHandler handler = new SAXParserHandler();
			parser.parse("books.xml", handler);
		} catch (ParserConfigurationException e) {
			e.printStackTrace();
		} catch (SAXException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
	
	public void jdomXmlParser() {
		ArrayList<Book> booksList = new ArrayList<Book>();
		SAXBuilder saxBuilder = new SAXBuilder();
		InputStream in;
		try {
			in = new FileInputStream("books.xml");
			InputStreamReader isr = new InputStreamReader(in, "UTF-8");
			org.jdom2.Document document = saxBuilder.build(isr);
			org.jdom2.Element rootElement = document.getRootElement();
			List<org.jdom2.Element> bookList = rootElement.getChildren();
			for (org.jdom2.Element book : bookList) {
				Book bookEntity = new Book();
				List<Attribute> attrList = book.getAttributes();
				for (Attribute attr : attrList) {
					String attrName = attr.getName();
					String attrValue = attr.getValue();
					if (attrName.equals("id")) {
						bookEntity.setId(attrValue);
					}
				}
				List<org.jdom2.Element> bookChilds = book.getChildren();
				for (org.jdom2.Element child : bookChilds) {
					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());
					}
					else if (child.getName().equals("language")) {
						bookEntity.setLanguage(child.getValue());
					}
				}
				booksList.add(bookEntity);
				bookEntity = null;
			}
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (JDOMException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}

	}
	
	public void dom4jXmlParser(){
		ArrayList<Book> booksList = new ArrayList<Book>();
		SAXReader reader = new SAXReader();
		try {
			org.dom4j.Document document = reader.read(new File("books.xml"));
			org.dom4j.Element bookStore = document.getRootElement();
			List<org.dom4j.Element> bookEles = bookStore.elements();
			for (org.dom4j.Element book : bookEles) {
				Book bookEntity = new Book();
				List<org.dom4j.Attribute> bookAttrs = book.attributes();
				for (org.dom4j.Attribute attr : bookAttrs) {
					if (attr.getName().equals("id")) {
						bookEntity.setId(attr.getValue());
					}
				}
				List<org.dom4j.Element> bookss = book.elements();
				for (org.dom4j.Element bookChild : bookss) {
					String name = bookChild.getName();
					String value = bookChild.getStringValue();
					if (name.equals("name")) {
						bookEntity.setName(value);
					}
					else if (name.equals("author")) {
						bookEntity.setAuthor(value);
					}
					else if (name.equals("year")) {
						bookEntity.setYear(value);
					}
					else if (name.equals("price")) {
						bookEntity.setPrice(value);
					}
					else if (name.equals("language")) {
						bookEntity.setLanguage(value);
					}
				}
				booksList.add(bookEntity);
				bookEntity = null;
			}
		} catch (DocumentException e) {
			e.printStackTrace();
		}
	}

	@Test
	public void testPerformance() throws Exception{
		System.out.println("性能测试:");
		//测试DOM的性能:
		long start = System.currentTimeMillis();
		domXmlParser();
		System.out.println("DOM:"+ (System.currentTimeMillis() - start) );
		//测试SAX的性能:
		start = System.currentTimeMillis();
		saxXmlParser();
		System.out.println("SAX:"+ (System.currentTimeMillis() - start) );
		//测试JDOM的性能:
		start = System.currentTimeMillis();
		jdomXmlParser();
		System.out.println("JDOM:"+ (System.currentTimeMillis() - start) );
		//测试DOM4J的性能:
		start = System.currentTimeMillis();
		dom4jXmlParser();
		System.out.println("DOM4J:"+ (System.currentTimeMillis() - start) );
	
	}
}

XML 简介

XML 被设计用来传输和存储数据。
HTML 被设计用来显示数据。

XML 是什么？

  • XML 指可扩展标记语言（EXtensible Markup Language）
  • XML 是一种标记语言，类似HTML
  • XML 的设计宗旨是传输数据
  • XML标签 需要自己定义
  • XML 被设计为具有自我描述性

XML 与 HTML 的主要差异

  • XML 不是 HTML 的替代。
  • XML 和 HTML 为不同的目的而设计
  • XML 被设计为传输和存储数据，其焦点是数据的内容。
  • HTML 被设计用来显示数据，其焦点是数据的外观。
  • HTML 旨在显示信息，而 XML 旨在传输信息。

XML 的用途

XML 应用于 web 开发的许多方面，常用于简化数据的存储和共享。

XML 把数据从 HTML 分离

HTML 文档中显示动态数据，每当数据改变时将花费大量的时间来编辑 HTML。

通过 XML，数据能够存储在独立的 XML 文件中。这样你就可以专注于使用 HTML 进行布局和显示，并确保修改底层数据不再需要对 HTML 进行任何的改变。

通过使用几行 JavaScript，就可以读取一个外部 XML 文件，然后更新 HTML 中的数据内容。

XML 简化数据共享

XML 数据以纯文本格式进行存储，提供了一种独立于软件和硬件的数据存储方法。创建不同应用程序可以共享的数据变得更加容易。

XML 简化数据传输

通过 XML，可以在不兼容的系统之间轻松地交换数据。以 XML 交换数据降低了这种复杂性。

XML 用于创建新的 Internet 语言

很多新的 Internet 语言是通过 XML 创建的：其中的例子包括：

  • XHTML - 最新的 HTML 版本
  • WSDL - 用于描述可用的 web service
  • WAP 和 WML - 用于手持设备的标记语言
  • RSS - 用于 RSS feed 的语言
  • RDF 和 OWL - 用于描述资源和本体
  • SMIL - 用于描述针针对 web 的多媒体

XML 树结构

XML 文档形成了一种树结构，它从“根部”开始，然后扩展到“枝叶”。

一个 XML 文档实例

XML 使用简单的具有自我描述性的语法：

<?xml version="1.0" encoding="UTF-8"?>
<bookstore>
<book category="COOKING">
  <title lang="en">Everyday Italian</title> 
  <author>Giada De Laurentiis</author> 
  <year>2005</year> 
  <price>30.00</price> 
</book>
<book category="CHILDREN">
  <title lang="en">Harry Potter</title> 
  <author>J K. Rowling</author> 
  <year>2005</year> 
  <price>29.99</price> 
</book>
<book category="WEB">
  <title lang="en">Learning XML</title> 
  <author>Erik T. Ray</author> 
  <year>2003</year> 
  <price>39.95</price> 
</book>
</bookstore>

第一行是 XML 声明。它定义 XML 的版本 (1.0) 和所使用的编码

<bookstore></bookstore>

元素

book是bookstore的子元素
title、author、year、price是book的子元素

<book category="COOKING">
  <title lang="en">Everyday Italian</title> 
  <author>Giada De Laurentiis</author> 
  <year>2005</year> 
  <price>30.00</price> 
</book>

元素属性

category、lang 元素的属性

XML 语法规则

XML 的语法规则很简单，且很有逻辑。

  • 元素都有关闭标签
  • 大小写敏感
  • 正确嵌套
  • 必备根元素
  • 属性加引号
  • 特殊符号 大于、小于、单引号、双引号
  • 保留空格

XML 中的注释

<!-- This is a comment -->

CDATA 可以不适用特殊字符转义

CDATA 部分由 “<![CDATA[*" 开始，由 "*]]>” 结束：

XML命名规范

  • 名称可以含字母、数字以及其他的字符
  • 名称不能以数字或者标点符号开始
  • 名称不能以字符 “xml”（或者 XML、Xml）开始
  • 名称不能包含空格
  • 名称具有描述性。使用下划线的名称也很不错。
  • 名称应当比较简短，比如：<book_title>
  • 避免 “-” 字符。如果您按照这样的方式进行命名：“first-name”，一些软件会认为你需要提取第一个单词。
  • 避免 “.” 字符。如果您按照这样的方式进行命名：“first.name”，一些软件会认为 “name” 是对象 “first” 的属性。
  • 避免 “:” 字符。冒号会被转换为命名空间来使用。

XML 属性

XML 元素可以在开始标签中包含属性，类似 HTML。

属性 (Attribute) 提供关于元素的额外（附加）信息。

  • 属性必须加引号
  • 属性无法包含多重的值（元素可以）
  • 属性无法描述树结构（元素可以）
  • 属性不易扩展（为未来的变化）
  • 属性难以阅读和维护
java解析XML
qq_45796208的博客
10-28 419
可扩展的标记语言(Extensible Markup language) XML的主要用途 --数据存储和数据描述 --是一个优良的配置文件 --相当于一个小型数据库 --XML不依赖于任何一种编程语言，是独立的W3C提供的规范，所以可以完成多种语言之间的数据交换（重点） XML的语法严格，并且完全区分大小写 XML（eXtensible Markup Language）-描述事物本身 .xml XSL （eXtensible Stylesheet L...
Java解析XML的四种方法详解
09-05
在Java中，解析XML文件主要有四种方法：DOM、SAX、StAX和JAXB。每种方法都有其特定的优缺点，适用于不同的场景。以下是对这四种方法的详细解释： 1. DOM（Document Object Model）解析： DOM是一种基于树形结构的...
Java解析XML字符串
Snapeee_的博客
09-26 3078
Java解析XML字符串 后端需要接收一段xml字符串并解析，xml标签有重复，涉及到解析过后不能用map存入，网上找了好多解析方式并不是我想要的（大部分都是用map存储），于是看着网上解析的思路，写了一套可以保存重复标签以及其他标签的方法。 /** * 解析xml文件 * @param xml * @param map * @param list * @return */ public static List parseXml2Ma
java xml解析
qq_34968945的博客
07-14 275
DOM解析 DOM解析方式，将所有的xml文件内容加载到内存中 优点：获取数据简单 缺点：文件大时占用大量内存 常用类和方法 javax.xml.parsers.DocumentBuilderFactory static DocumentBuilderFactory newInstance() 新建一个DocumentBuilderFactory实例 DocumentBuilder newDocumentBuilder() 创建一个DocumentBuilder实例 javax.xml.parsers.Do
Java XML解析
SmilingBoy000的博客
01-30 336
Java引用XStream解析xml文件
Java 解析 XML
weixin_30530523的博客
01-31 202
Java 解析 XML 标签： Java基础 XML解析技术有两种 DOM SAX DOM方式 根据XML的层级结构在内存中分配一个树形结构,把XML的标签,属性和文本等元素都封装成树的节点对象 优点: 便于实现增 删 改 查 缺点: XML文件过大可能造成内存溢出 SAX方式 采用事件驱动模型边读边解析:从上到下一行行解析,解析到某一元素, 调用相应解析方...
JAVA DOM解析XML文件过程详解
08-25
JAVA DOM 解析 XML 文件过程详解 JAVA DOM 解析 XML 文件过程详解是指使用 ...此外，我们也可以使用其他解析 XML 文件的方法，如 SAX 解析和 StAX 解析等等，每种方法都有其优缺点，需要根据实际情况选择合适的方法。
Java解析xml的四种方法汇总
09-02
它可以在解析XML文档时立即开始，不需要等待所有数据处理完毕。SAX通过触发一系列的事件来识别和处理特定的标签。这种方法的主要优点在于内存要求低，且解析速度快，适合处理大型文档。但是SAX解析器的编码工作比较...
JavaXml.zip_java xml_javaXML_java解析xml_文档解析
09-21
在Java中，有多种方式可以解析XML文档，包括DOM（Document Object Model）、SAX（Simple API for XML）和StAX（Streaming API for XML）。下面我们将详细探讨这些解析方法以及相关的API。 1. DOM解析器：DOM解析器...
java的XML四种解析方法汇总
03-09
JAVA xml 的四种解析方式，(1)Dom生成和解析XML文档 (2)SAX生成和解析XML文档(3)DOM4J生成和解析XML文档 (4)JDOM生成和解析XML
java解析xml字符串
12-03
java解析xml字符串，添加属性，更新属性等
java中的xml解析
最新发布
weixin_41463095的博客
08-17 132
我整理的一些关于【XML】的项目学习资料（附讲解～～）和大家一起分享、学习一下：https://d.51cto.com/Hpqqk2Java中的XML解析指南 在现代开发中，XML（可扩展标记语言）是一种广泛使用的数据交换格式。掌握如何在Java中解析XML是每位开发者的重要技能。本文将引导您完成XML解析的整体流程，并...
java 解析xml
cwx_csdn的博客
07-05 160
import com.alibaba.fastjson.JSONObject; import com.google.common.collect.Maps; import com.meida.common.utils.StringUtils; import org.w3c.dom.Document; import org.w3c.dom.Node; import org.w3c.dom.NodeList; import javax.xml.parsers.DocumentBuilder; import .
java解析xml
dalter的博客
08-07 249
File f = new File("E:\\IO\\wc.xml");// 源数据 DocumentBuilderFactory factory = DocumentBuilderFactory .newInstance(); DocumentBuilder builder = factory.newDocumentBuilder(); Document doc = builder.parse(...
Java-XML解析
ppfppf123的博客
09-14 95
XML解析方法 1、树结构 -DOM：Document Object Model文档对象模型，擅长（小规模）读写 2、流结构 -SAX：simple API for XML流机制解释器（推模式）擅长读 -Stax：the Streaming API for XML流机制解释器（拉模式）擅长读 DOM是W3C处理XML的标准API -直观易用 -处理方式是将XML整个作为类似树结构的方式读入内存中以便操作及解析，方便修改 -解析大数据量的XML文件，会遇到内存泄漏及程序崩溃的风险 ...
Java解析xml
qq_39019331的博客
05-18 9837
记录工作中遇到的一些问题和解决方式，自己摘抄整理了一下用来巩固，如有不足或有更好的方式 欢迎交流。 java解析xml的话有四种方式，分别为DOM,SAX,DOM4J,JDOM 转载：Java解析XML(4种方法)_蓝星花的博客-优快云博客_java解析xml 这里的话我用的是dom4j Date date = new Date();//用于查看耗时 //InputStream是字节输入流，用来将文件中的数据读取到java程序中 //new FileInputStr...
Java中的XML解析
apple_52109766的博客
07-04 3154
这几天在手写Spring IOC的时候遇上了xml文件的解析，通过解析Spring.xml配制文件的方式来创建对象。因为之前从来都没遇见过相关的需求，所以对此做一份记录 XML (eXtensible Markup Language) 意为可扩展标记语言，被多数技术人员用以选择作为数据传输的载体，成为一种通用的数据交换格式,xml的平台无关性,语言无关性,系统无关性,给数据集成与交互带来了极大的便利。在不同的语言中，解析mxl的方式都是一样的,只不过实现的语法不同而已。 XML解析主要有两种方式，一种称为D
Java读取XML文件的四种方法解析
在提供的代码示例中，首先通过`DocumentBuilderFactory`创建`DocumentBuilder`实例，然后使用`parse()`方法解析XML文件。`getElementsByTagName()`用于获取指定标签的所有节点，通过索引访问并打印出"NO"和"ADDR...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

EngineerForSoul

你的鼓励是我孜孜不倦的动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值