Java 读取xml文件_java读取xml文件如何处理集合-CSDN博客

使用java读取xml文件

<?xml version="1.0" encoding="UTF-8"?>
<bookstore>
	<book id="1">
		<name>冰与火之歌</name>
		<author>乔治马丁</author>
		<year>2014</year>
		<price>89</price>
	</book>
	<book id="2">
		<name>安徒生童话</name>
		<year>2004</year>
		<price>77</price>
		<language>English</language>
	</book>
</bookstore>

DOM读取

package com.imooc.domtest.test;

import java.io.IOException;

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

import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.NamedNodeMap;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.xml.sax.SAXException;

public class DOMTest {

	public static void main(String[] args) {
		//创建一个DocumentBuilderFactory的对象
		DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
		//创建一个DocumentBuilder的对象
		try {
			//创建DocumentBuilder对象
			DocumentBuilder db = dbf.newDocumentBuilder();
			//通过DocumentBuilder对象的parser方法加载books.xml文件到当前项目下
			Document document = db.parse("books.xml");
			//获取所有book节点的集合
			NodeList bookList = document.getElementsByTagName("book");
			//通过nodelist的getLength()方法可以获取bookList的长度
			System.out.println("一共有" + bookList.getLength() + "本书");
			//遍历每一个book节点
			for (int i = 0; i < bookList.getLength(); i++) {
				System.out.println("=================下面开始遍历第" + (i + 1) + "本书的内容=================");
				//通过 item(i)方法 获取一个book节点，nodelist的索引值从0开始
				Node book = bookList.item(i);
//				获取book节点的所有属性集合
				NamedNodeMap attrs = book.getAttributes();
				System.out.println("第 " + (i + 1) + "本书共有" + attrs.getLength() + "个属性");
//				遍历book的属性
				for (int j = 0; j < attrs.getLength(); j++) {
					//通过item(index)方法获取book节点的某一个属性
					Node attr = attrs.item(j);
					//获取属性名
					System.out.print("属性名：" + attr.getNodeName());
					//获取属性值
					System.out.println("--属性值" + attr.getNodeValue());
				}
//				//前提：已经知道book节点有且只能有1个id属性
//				//将book节点进行强制类型转换，转换成Element类型
//				Element book = (Element) bookList.item(i);
//				//通过getAttribute("id")方法获取属性值
//				String attrValue = book.getAttribute("id");
//				System.out.println("id属性的属性值为" + attrValue);
				//解析book节点的子节点
				NodeList childNodes = book.getChildNodes();
				//遍历childNodes获取每个节点的节点名和节点值
				System.out.println("第" + (i+1) + "本书共有" + 
				childNodes.getLength() + "个子节点");
				for (int k = 0; k < childNodes.getLength(); k++) {
					//区分出text类型的node以及element类型的node
					if (childNodes.item(k).getNodeType() == Node.ELEMENT_NODE) {
						//获取了element类型节点的节点名
						System.out.print("第" + (k + 1) + "个节点的节点名：" 
						+ childNodes.item(k).getNodeName());
//						获取了element类型节点的节点值
						System.out.println("--节点值是：" + childNodes.item(k).getFirstChild().getNodeValue());
//						System.out.println("--节点值是：" + childNodes.item(k).getTextContent());
					}
				}
				System.out.println("======================结束遍历第" + (i + 1) + "本书的内容=================");
			}
		} catch (ParserConfigurationException e) {
			e.printStackTrace();
		}  catch (SAXException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}
		
	}
}

程序运行结果：

一共有2本书
=================下面开始遍历第1本书的内容=================
第 1本书共有1个属性
属性名：id--属性值1
第1本书共有9个子节点
第2个节点的节点名：name--节点值是：冰与火之歌
第4个节点的节点名：author--节点值是：乔治马丁
第6个节点的节点名：year--节点值是：2014
第8个节点的节点名：price--节点值是：89
======================结束遍历第1本书的内容=================
=================下面开始遍历第2本书的内容=================
第 2本书共有1个属性
属性名：id--属性值2
第2本书共有9个子节点
第2个节点的节点名：name--节点值是：安徒生童话
第4个节点的节点名：year--节点值是：2004
第6个节点的节点名：price--节点值是：77
第8个节点的节点名：language--节点值是：English
======================结束遍历第2本书的内容=================

另外，也可以用SAX解析XML

SAX解析XML的步骤：

1、通过SAXParserFactory的静态newInstance()方法获取SAXParserFactory实例factory

2、通过SAXParserFactory实例的newSAXParser()方法返回SAXParser实例parser

3、创建一个类继承DefaultHandler,重写其中的一些方法进行业务处理并创建这个类的实例handler

下面通过一个实例来运行结果

xml文件：

<?xml version="1.0" encoding="UTF-8"?>
<bookstore>
	<book id="1">
		<name>冰与火之歌</name>
		<author>乔治马丁</author>
		<year>2014</year>
		<price>89</price>
	</book>
	<book id="2">
		<name>安徒生童话</name>
		<year>2004</year>
		<price>77</price>
		<language>English</language>
	</book>	
</bookstore>

book对应的实体类：

package com.imooc.entity;

public class Book {
	private String id;
	private String name;
	private String author;
	private String year;
	private String price;
	private String language;
	public String getId() {
		return id;
	}
	public void setId(String id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getAuthor() {
		return author;
	}
	public void setAuthor(String author) {
		this.author = author;
	}
	public String getYear() {
		return year;
	}
	public void setYear(String year) {
		this.year = year;
	}
	public String getPrice() {
		return price;
	}
	public void setPrice(String price) {
		this.price = price;
	}
	public String getLanguage() {
		return language;
	}
	public void setLanguage(String language) {
		this.language = language;
	}
	
	
}

测试类：

package com.imooc.test;

import java.io.IOException;

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

import org.xml.sax.SAXException;
import org.xml.sax.SAXParseException;

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

public class SAXTest {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		
		SAXParserFactory factory = SAXParserFactory.newInstance();
	
		try {
			SAXParser parser = factory.newSAXParser();
		
			SAXParserHandler handler = new SAXParserHandler();
			parser.parse("books.xml", handler);
			System.out.println("~！~！~！共有" + handler.getBookList().size()
					+ "本书");
			for (Book book : handler.getBookList()) {
				System.out.println(book.getId());
				System.out.println(book.getName());
				System.out.println(book.getAuthor());
				System.out.println(book.getYear());
				System.out.println(book.getPrice());
				System.out.println(book.getLanguage());
				System.out.println("----finish----");
			}
		} catch (ParserConfigurationException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (SAXException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}

}

解析器handler

package com.imooc.handler;

import java.util.ArrayList;

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

import com.imooc.entity.Book;


public class SAXParserHandler extends DefaultHandler {
	String value = null;
	Book book = null;
	private ArrayList<Book> bookList = new ArrayList<Book>();
	public ArrayList<Book> getBookList() {
		return bookList;
	}

	int bookIndex = 0;
	/**
	 * 用来标识解析开始
	 */
	@Override
	public void startDocument() throws SAXException {
		// TODO Auto-generated method stub
		super.startDocument();
		System.out.println("SAX解析开始");
	}
	
	/**
	 * 用来标识解析结束
	 */
	@Override
	public void endDocument() throws SAXException {
		// TODO Auto-generated method stub
		super.endDocument();
		System.out.println("SAX解析结束");
	}
	
	/**
	 * 解析xml元素
	 */
	@Override
	public void startElement(String uri, String localName, String qName,
			Attributes attributes) throws SAXException {
		//调用DefaultHandler类的startElement方法
		super.startElement(uri, localName, qName, attributes);
		if (qName.equals("book")) {
			bookIndex++;
			//创建一个book对象
			book = new Book();
			//开始解析book元素的属性
			System.out.println("======================开始遍历某一本书的内容=================");
//			//已知book元素下属性的名称，根据属性名称获取属性值
//			String value = attributes.getValue("id");
//			System.out.println("book的属性值是：" + value);
			//不知道book元素下属性的名称以及个数，如何获取属性名以及属性值
			int num = attributes.getLength();
			for(int i = 0; i < num; i++){
				System.out.print("book元素的第" + (i + 1) +  "个属性名是："
						+ attributes.getQName(i));
				System.out.println("---属性值是：" + attributes.getValue(i));
				if (attributes.getQName(i).equals("id")) {
					book.setId(attributes.getValue(i));
				}
			}
		}
		else if (!qName.equals("name") && !qName.equals("bookstore")) {
			System.out.print("节点名是：" + qName + "---");
		}
	}
	
	@Override
	public void endElement(String uri, String localName, String qName)
			throws SAXException {
		//调用DefaultHandler类的endElement方法
		super.endElement(uri, localName, qName);
		//判断是否针对一本书已经遍历结束
		if (qName.equals("book")) {
			bookList.add(book);
			book = null;
			System.out.println("======================结束遍历某一本书的内容=================");
		}
		else if (qName.equals("name")) {
			book.setName(value);
		}
		else if (qName.equals("author")) {
			book.setAuthor(value);
		}
		else if (qName.equals("year")) {
			book.setYear(value);
		}
		else if (qName.equals("price")) {
			book.setPrice(value);
		}
		else if (qName.equals("language")) {
			book.setLanguage(value);
		}
	}
	
	
	@Override
	public void characters(char[] ch, int start, int length)
			throws SAXException {
		// TODO Auto-generated method stub
		super.characters(ch, start, length);
		value = new String(ch, start, length);
		if (!value.trim().equals("")) {
			System.out.println("节点值是：" + value);
		}
	}
}

运行结果：

SAX解析开始
======================开始遍历某一本书的内容=================
book元素的第1个属性名是：id---属性值是：1
节点值是：冰与火之歌
节点名是：author---节点值是：乔治马丁
节点名是：year---节点值是：2014
节点名是：price---节点值是：89
======================结束遍历某一本书的内容=================
======================开始遍历某一本书的内容=================
book元素的第1个属性名是：id---属性值是：2
节点值是：安徒生童话
节点名是：year---节点值是：2004
节点名是：price---节点值是：77
节点名是：language---节点值是：English
======================结束遍历某一本书的内容=================
SAX解析结束
~！~！~！共有2本书
1
冰与火之歌
乔治马丁
2014
89
null
----finish----
2
安徒生童话
null
2004
77
English
----finish----

使用JDOM解析，需要引入JDOM的jar包

book类:

package com.imooc.entity;

public class Book {
	private String id;
	private String name;
	private String author;
	private String year;
	private String price;
	private String language;
	public String getId() {
		return id;
	}
	public void setId(String id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getAuthor() {
		return author;
	}
	public void setAuthor(String author) {
		this.author = author;
	}
	public String getYear() {
		return year;
	}
	public void setYear(String year) {
		this.year = year;
	}
	public String getPrice() {
		return price;
	}
	public void setPrice(String price) {
		this.price = price;
	}
	public String getLanguage() {
		return language;
	}
	public void setLanguage(String language) {
		this.language = language;
	}
	
	
}

测试：

package com.imooc.jdomtest;

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.List;

import org.jdom2.Attribute;
import org.jdom2.Document;
import org.jdom2.Element;
import org.jdom2.JDOMException;
import org.jdom2.input.SAXBuilder;

import com.imooc.entity.Book;


public class JDOMTest {
	private static ArrayList<Book> booksList = new ArrayList<Book>();
	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// 进行对books.xml文件的JDOM解析
		// 准备工作
		// 1.创建一个SAXBuilder的对象
		SAXBuilder saxBuilder = new SAXBuilder();
		InputStream in;
		try {
			// 2.创建一个输入流，将xml文件加载到输入流中
			in = new FileInputStream("src/res/books.xml");
			InputStreamReader isr = new InputStreamReader(in, "UTF-8");
			// 3.通过saxBuilder的build方法，将输入流加载到saxBuilder中
			Document document = saxBuilder.build(isr);
			// 4.通过document对象获取xml文件的根节点
			Element rootElement = document.getRootElement();
			// 5.获取根节点下的子节点的List集合
			List<Element> bookList = rootElement.getChildren();
			// 继续进行解析
			for (Element book : bookList) {
				Book bookEntity = new Book();
				System.out.println("======开始解析第" + (bookList.indexOf(book) + 1)
						+ "书======");
				// 解析book的属性集合
				List<Attribute> attrList = book.getAttributes();
				// //知道节点下属性名称时，获取节点值
				// book.getAttributeValue("id");
				// 遍历attrList(针对不清楚book节点下属性的名字及数量)
				for (Attribute attr : attrList) {
					// 获取属性名
					String attrName = attr.getName();
					// 获取属性值
					String attrValue = attr.getValue();
					System.out.println("属性名：" + attrName + "----属性值："
							+ attrValue);
					if (attrName.equals("id")) {
						bookEntity.setId(attrValue);
					}
				}
				// 对book节点的子节点的节点名以及节点值的遍历
				List<Element> bookChilds = book.getChildren();
				for (Element child : bookChilds) {
					System.out.println("节点名：" + child.getName() + "----节点值："
							+ child.getValue());
					if (child.getName().equals("name")) {
						bookEntity.setName(child.getValue());
					}
					else if (child.getName().equals("author")) {
						bookEntity.setAuthor(child.getValue());
					}
					else if (child.getName().equals("year")) {
						bookEntity.setYear(child.getValue());
					}
					else if (child.getName().equals("price")) {
						bookEntity.setPrice(child.getValue());
					}
					else if (child.getName().equals("language")) {
						bookEntity.setLanguage(child.getValue());
					}
				}
				System.out.println("======结束解析第" + (bookList.indexOf(book) + 1)
						+ "书======");
				booksList.add(bookEntity);
				bookEntity = null;
				System.out.println(booksList.size());
				System.out.println(booksList.get(0).getId());
				System.out.println(booksList.get(0).getName());
				
			}
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (JDOMException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

}

运行结果：

======开始解析第1书======
属性名：id----属性值：1
节点名：name----节点值：冰与火之歌
节点名：author----节点值：乔治马丁
节点名：year----节点值：2014
节点名：price----节点值：89
======结束解析第1书======
1
1
冰与火之歌
======开始解析第2书======
属性名：id----属性值：2
节点名：name----节点值：安徒生童话
节点名：year----节点值：2004
节点名：price----节点值：77
节点名：language----节点值：English
======结束解析第2书======
2
1
冰与火之歌

使用DOM4J 解析xml文件

book类与book.xml文件与前面相同

package com.imooc.dom4jtest;

import java.io.File;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

import org.dom4j.Attribute;
import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;

import com.imooc.entity.Book;

public class DOM4JTest {
	private static ArrayList<Book> bookList = new ArrayList<Book>();
	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// 解析books.xml文件
		// 创建SAXReader的对象reader
		SAXReader reader = new SAXReader();
		try {
			// 通过reader对象的read方法加载books.xml文件,获取docuemnt对象。
			Document document = reader.read(new File("src/res/books.xml"));
			// 通过document对象获取根节点bookstore
			Element bookStore = document.getRootElement();
			// 通过element对象的elementIterator方法获取迭代器
			Iterator it = bookStore.elementIterator();
			// 遍历迭代器，获取根节点中的信息（书籍）
			while (it.hasNext()) {
				System.out.println("=====开始遍历某一本书=====");
				Element book = (Element) it.next();
				// 获取book的属性名以及 属性值
				List<Attribute> bookAttrs = book.attributes();
				for (Attribute attr : bookAttrs) {
					System.out.println("属性名：" + attr.getName() + "--属性值："
							+ attr.getValue());
				}
				Iterator itt = book.elementIterator();
				while (itt.hasNext()) {
					Element bookChild = (Element) itt.next();
					System.out.println("节点名：" + bookChild.getName() + "--节点值：" + bookChild.getStringValue());
				}
				System.out.println("=====结束遍历某一本书=====");
			}
		} catch (DocumentException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}

	}

}

运行结果：

=====开始遍历某一本书=====
属性名：id--属性值：1
节点名：name--节点值：冰与火之歌
节点名：author--节点值：乔治马丁
节点名：year--节点值：2014
节点名：price--节点值：89
=====结束遍历某一本书=====
=====开始遍历某一本书=====
属性名：id--属性值：2
节点名：name--节点值：安徒生童话
节点名：year--节点值：2004
节点名：price--节点值：77
节点名：language--节点值：English
=====结束遍历某一本书=====

4种xml解析方式的对比：DOM、SAX、JDOM、DOM4J

DOM、SAX与平台无关。SAX基于事件驱动的解析方式。

JDOM、DOM4J 是在基础的方法上扩展出来的，只有java中能够使用的解析方法

DOM

优点：形成了树结构，直观好理解，代码更容易编写

解析过程中树结构保留在内存中，方便修改

缺点：当xml文件较大时，对内存耗费比较大，容易影响解析性能并造成内存溢出。

SAX

优点：采用事件驱动模式，对内存耗费比较小

适用于至需要处理xml数据时

缺点：不容易编码

很难同时访问同一个xml中的多处不同数据