# java对xml文件的基本操做
下面是简单的总结三种经常使用的java对xml文件的操做
1. dom方式对xml进行操做，这种操做原理是将整个xml文档读入内存总，在内存中进行操做，当xml文档很是庞大的时候就会出现内存溢出的异常，这种方式能够进行增删改查的操做。 2. sax方式进行xml的操做，这种方式则不是将整个xml文档读入到内存中进行操做，sax的操做方式是实时将文档中的数据进行处理，这种方式是一个标签一个标签的进行读取，而后由程序员去实现一个自定义的操做，那么这里须要去实现ContentHandler这个接口中的方法，可是这种方式只能读取xml中的数据，效率快，不占用太大内存。 3. dom4j这是有第三方提供的一种解析方式，咱们须要去下载dom4j.jar才能进行使用，这种方式结合了前两种的一些优点，也是比较经常使用的一种解析方式。
1、dom对xml的基本操做
<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<书架>
<书>
<书名>科学怪人</书名>
<做者>张三</做者>
<售价>20.0元</售价>
</书>
<书>
<书名>java</书名>
<做者>扎笑道</做者>
</书>
</书架>
下面这个例子就是简单操做xml的例子：
要求：对上面这个xml文件进行操做java
package com.cn.ljh.jaxpxml;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.transform.Transformer;
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.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
public class JaxpXml {
public static void main(String [] args) throws Exception{
//一、建立一个工厂类
DocumentBuilderFactory doucumentfactory = DocumentBuilderFactory.newInstance();
//二、建立一个解析器
DocumentBuilder builder = doucumentfactory.newDocumentBuilder();
Document document = builder.parse("src/Books.xml");
test7(document);
}
//一、在第一个元素上在增长一个子元素
public static boolean test1(Document document) throws Exception{
//先建立一个新的元素
Element element = document.createElement("内部价");
element.setTextContent("1元");
//得到父节点
Node node = document.getElementsByTagName("书").item(0);
//将新建立的节点添加上去
node.appendChild(element);
//将内存中的数据写入到硬盘
TransformerFactory factory = TransformerFactory.newInstance();
Transformer transformer = factory.newTransformer();
transformer.transform(new DOMSource(document), new StreamResult("src/Books.xml"));
return true;
}
//二、在第一个元素的第一个子元素前面增长一个兄弟元素
public static boolean test2(Document document) throws TransformerException {
//建立一个新的元素
Element element = document.createElement("笔名");
element.setTextContent("大侠");
//获取插入位置的元素
Node node = document.getElementsByTagName("书名").item(0);
System.err.println(node.getTextContent());
node.insertBefore(element, node);
//node.appendChild(element);
//将内存中的数据写入到硬盘上
TransformerFactory factory = TransformerFactory.newInstance();
factory.newTransformer().transform(new DOMSource(document), new StreamResult("src/Books.xml"));
return true;
}
//三、删除第一个元素的第一个子元素
public static boolean test3(Document document) throws Exception{
//获得第一个节点
Node node = document.getElementsByTagName("内部价").item(0);
//得到父节点
node.getParentNode().removeChild(node);
//将内存中的数据写入硬盘中
TransformerFactory factory = TransformerFactory.newInstance();
factory.newTransformer().transform(new DOMSource(document), new StreamResult("src/Books.xml"));
return true;
}
//四、删除第一个元素
public static boolean test4(Document document){
Node node = document.getElementsByTagName("书").item(0);
node.getParentNode().removeChild(node);
TransformerFactory factory = TransformerFactory.newInstance();
try {
factory.newTransformer().transform(new DOMSource(document), new StreamResult("src/Books.xml"));
} catch (TransformerException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return true;
}
//五、在第二个元素上增长属性
public static void test5(Document document) throws Exception{
Node node = document.getElementsByTagName("书").item(0);
Element element = (Element) node;
element.setAttribute("出版社","四川出版社");
//将文件写入硬盘
TransformerFactory factory = TransformerFactory.newInstance();
factory.newTransformer().transform(new DOMSource(document), new StreamResult("src/Books.xml"));
}
//六、删除第一个元素的属性
public static void test6(Document document) throws Exception{
//得到第一个节点
Node node = document.getElementsByTagName("书").item(0);
Element element = (Element) node;
element.removeAttribute("出版社");
TransformerFactory factory = TransformerFactory.newInstance();
factory.newTransformer().transform(new DOMSource(document), new StreamResult("src/Books.xml"));
}
//七、增长一个新的完整的元素，这个元素有三个子元素，而且添加一个属性
public static void test7(Document document) throws Exception{
//建立一个新的元素
Element oneE = document.createElement("书");
Element towE = document.createElement("书名");
towE.setTextContent("java");
Element towW = document.createElement("做者");
towW.setTextContent("扎笑道");
//获取父节点(书架)
Node node = document.getFirstChild();
node.appendChild(oneE);
oneE.appendChild(towE);
oneE.appendChild(towW);
TransformerFactory factory = TransformerFactory.newInstance();
factory.newTransformer().transform(new DOMSource(document), new StreamResult("src/Books.xml"));
}
//八、获取第一个元素的第一个子元素的内容
public static boolean test8(Document document){
NodeList nodelist = document.getElementsByTagName("书名");
Node node = nodelist.item(0);
String name = node.getTextContent();
System.out.println(name);
return false;
}
//九、获取属性内容
public static void test9(Document document){
NodeList nodelist = document.getElementsByTagName("书");
Node node = nodelist.item(0);
Element element = (Element) node;
String attName = element.getAttribute("id");
System.out.println(attName);
}
//十、循环遍历打印标签内容
public static void test10(Node node){
//判断是否是Node类型
short type = node.getNodeType();
if(type == Node.ELEMENT_NODE){
System.out.println(node.getNodeName());
}
NodeList nodelist = node.getChildNodes();
long len = nodelist.getLength();
for(int i=0;i<len;i++){
Node n = nodelist.item(i);
test10(n);
}
}
//十一、修改第一本书的书名的内容
public static boolean test11(Document document) throws Exception{
//获得第一本书
NodeList nodelist = document.getElementsByTagName("书名");
//获得第一本书的书名元素
Node node = nodelist.item(0);
node.setTextContent("商人");
//将内存中的数据写到硬盘上
TransformerFactory factory = TransformerFactory.newInstance();
factory.newTransformer().transform(new DOMSource(document), new StreamResult("src/Books.xml"));
return true;
}
}
2、sax对xml的基本操做
<?xml version="1.0" encoding="UTF-8"?>
<movies>
<movie>
<name>捉妖记</name>
<time>2015</time>
<director>许诚毅</director>
</movie>
<movie>
<name>老炮儿</name>
<director>冯小刚</director>
<time>2016</time>
</movie>
</movies>
下面这个例子就是sax对xml的基本操做：
要求：对上面的xml文件进行内容读取，而后进行数据的封装node
数据封装类程序员
package com.cn.ljh.sax;
public class Movie {
private String name;
private String time;
private String director;
public Movie(){
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getTime() {
return time;
}
public void setTime(String time) {
this.time = time;
}
public String getDirector() {
return director;
}
public void setDirector(String director) {
this.director = director;
}
}
sax操做类设计模式
package com.cn.ljh.sax;
import java.util.ArrayList;
import java.util.List;
import javax.xml.parsers.SAXParser;
import javax.xml.parsers.SAXParserFactory;
import org.xml.sax.Attributes;
import org.xml.sax.SAXException;
import org.xml.sax.XMLReader;
import org.xml.sax.helpers.DefaultHandler;
public class SaxTeat {
//如今要求将xml文档中的全部内容读取到movie中进行封装
public static void main(String[] args) throws Exception {
//下面就是sax解析xml的方式
//建立sax解析工厂
SAXParserFactory factory = SAXParserFactory.newInstance();
//建立sax的解析器
SAXParser parser = factory.newSAXParser();
//建立xml读取器
XMLReader reader = parser.getXMLReader();
List<Movie> movies = new ArrayList<Movie>();//存储电影数据
//挂载解析器（并实现解析其中的方法）
reader.setContentHandler(new DefaultHandler(){
Movie movie = null;
String tag = null;
//读取到元素开始，执行该方法
public void startElement(String uri, String localName, String qName, Attributes attributes)
throws SAXException {
super.startElement(uri, localName, qName, attributes);
if("movie".equals(qName)){
movie = new Movie();
}
tag = qName;
}
//读取到元素结束，执行该方法
public void endElement(String uri, String localName, String qName) throws SAXException {
super.endElement(uri, localName, qName);
if("movie".equals(qName)){
movies.add(movie);
}
}
//读取到内容，执行该方法
public void characters(char[] ch, int start, int length) throws SAXException {
super.characters(ch, start, length);
if("name".equals(tag)){
movie.setName(new String(ch,start,length));
}
if("time".equals(tag)){
movie.setTime(new String(ch, start, length));
}
if("director".equals(tag)){
movie.setDirector(new String(ch,start,length));
}
tag = null;
}
});
reader.parse("src/movie.xml");
for(Movie m : movies){
System.out.println(m.getName());
System.out.println(m.getDirector());
System.out.println(m.getTime());
}
}
}
能够看到上面，我没有去实现ContentHandler这个接口，我是去继承了DefaultHandler类，这里用到了适配器的设计模式（这样咱们能够更加方便的去实现里面的方法）。同时咱们也能够看出来，这个类中的方法就像是事件同样的方法，当解析器读到每个标签或者内容都会触发这些方法，因此，这些方法须要本身去实现。同时，这样操做咱们还须要将数据进行封装，这样方便咱们之后的操做。app
3、dom4j对xml的基本操做
<?xml version="1.0" encoding="UTF-8"?>
<cars>
<car time="2015">
<name>科鲁兹</name>
<color>白色</color>
<price>1500000</price>
<oil>10.L</oil>
</car>
<car where="中国">
<name>新蒙迪欧</name>
<price>1700000</price>
</car>
<car where="japan">
<name>丰田</name>
<color>黑色</color>
<price>1000000</price>
</car>
</cars>
下面这个例子就是dom4j对xml的基本操做
要求：对上面的xml文件进行一些简单的操做dom
package com.cn.ljh.Dom4j;
import java.io.FileWriter;
import java.util.List;
import org.dom4j.Attribute;
import org.dom4j.Document;
import org.dom4j.Element;
import org.dom4j.Node;
import org.dom4j.io.SAXReader;
import org.dom4j.io.XMLWriter;
import org.junit.Test;
public class Dom4jTest {
// 对cas这个xml文件进行操做，利用dom4j的方式
// 1.获得第一辆车的名字
@Test
public void test1() throws Exception {
SAXReader read = new SAXReader();
// 获得文档树
Document document = read.read("src/cars.xml");
// 获得根元素
Element root = document.getRootElement();
List<Element> elements = root.elements("car");
// 获得第一个car元素
Element e = elements.get(0);
// 获得name元素
Element name_E = e.element("name");
String name = name_E.getText();
System.out.println("name= " + name);
}
// 2.获得第二辆车的属性
@Test
public void test2() throws Exception {
// 获得读取器
SAXReader read = new SAXReader();
Document document = read.read("src/cars.xml");
// 获得根元素
Element root = document.getRootElement();
// 获得全部车的元素
List<Element> es = root.elements("car");
// 获得第二个车的元素
Element car2 = es.get(1);
Attribute att = car2.attribute("where");
String where = att.getText();
System.out.println("where=" + where);
}
// 3.获得第二辆车的价格
@Test
public void test3() throws Exception {
SAXReader read = new SAXReader();
Document document = read.read("src/cars.xml");
Element root = document.getRootElement();
List<Element> cars = root.elements("car");
Element car = cars.get(1);
// 获得价格
Element price = car.element("price");
String text = price.getText();
System.out.println(text);
}
// 4.添加第一辆车一个属性
@Test
public void test4() throws Exception {
SAXReader read = new SAXReader();
Document document = read.read("src/cars.xml");
Element root = document.getRootElement();
List<Element> cars = root.elements("car");
Element car = cars.get(0);
// 添加属性
car.addAttribute("time", "2015");
// 将内存中的数据写到硬盘上
XMLWriter writer = new XMLWriter(new FileWriter("src/cars.xml"));
writer.write(document);
writer.close();
String text = car.attribute("time").getText();
System.out.println(text);
}
// 5.删除第一辆车的属性
@Test
public void test5() throws Exception {
SAXReader read = new SAXReader();
Document document = read.read("src/cars.xml");
Element root = document.getRootElement();
List<Element> cars = root.elements("car");
Element car = cars.get(0);
// 获得第一辆车的属性
Attribute att = car.attribute("where");
// 删除属性
car.remove(att);
// 将内存中的数据写入到硬盘上
XMLWriter writer = new XMLWriter(new FileWriter("src/cars.xml"));
writer.write(document);
writer.close();
}
// 6.给第一辆车添加油耗元素
@Test
public void test6() throws Exception {
SAXReader reader = new SAXReader();
Document document = reader.read("src/cars.xml");
Element root = document.getRootElement();
List<Element> cars = root.elements("car");
Element car = cars.get(0);
// 添加一个元素
car.addElement("oil").addText("10.L");
// 将数据写入到内存中
XMLWriter writer = new XMLWriter(new FileWriter("src/cars.xml"));
writer.write(document);
writer.close();
}
// 7.删除第二辆车的颜色的元素
@Test
public void test7() throws Exception {
SAXReader reader = new SAXReader();
Document document = reader.read("src/cars.xml");
Element root = document.getRootElement();
List<Element> cars = root.elements("car");
Element car = cars.get(1);
Element color = car.element("color");
car.remove(color);
// 将数据写入到硬盘上
XMLWriter writer = new XMLWriter(new FileWriter("src/cars.xml"));
writer.write(document);
writer.close();
}
// 8.打印全部的标签内容和名字
@Test
public void test8() throws Exception{
SAXReader reader = new SAXReader();
Document document = reader.read("src/cars.xml");
Element root = document.getRootElement();
//遍历全部元素
print(root);
}
//遍历全部元素的方法
private void print(Element element){
String text_name = element.getName();
String text = element.getText();
System.out.println("name = "+text_name+"text = "+text);
for(int i=0,size = element.nodeCount(); i < size;i++){
Node node = element.node(i);
if(node instanceof Element){
print((Element) node);
}
}
}
// 9.建立一个完整的car，包含属性
@Test
public void test9() throws Exception{
SAXReader reader = new SAXReader();
Document document = reader.read("src/cars.xml");
Element root = document.getRootElement();
Element car = root.addElement("car")
.addAttribute("where", "japan");
car.addElement("name").addText("丰田");
car.addElement("color").addText("黑色");
car.addElement("price").addText("1000000");
//将内存中的数据写入到硬盘中
XMLWriter writer = new XMLWriter(new FileWriter("src/cars.xml"));
writer.write(document);
writer.close();
}
}
那么上面这些例子只是简单的以dom4j的方式进行简单的操做，dom4j的功能还有很是多，当咱们须要使用这种方式去操做一个xml的时候能够去研究官方文档。dom4j的操做方式要比上面的两种简单高效。学习
记录学习的每一步，记录每一次的成长！！！！ui
相关文章
- 1. java对文件的基本操做
- 2. java对xml文件的操做
- 3. Java 对xml文件的读写操做
- 4. java 本身作的对XML文件的读写操做
- 5. Java操做XML文件
- 6. java操做XML文件
- 7. C#中对XML文件的一些基本操做
- 8. Adobe AIR对本地文件(XML文件)的操做
- 9. pig的基本操做（对hadoop文件）
- 10. c#对XML文件的读写操做
- 更多相关文章...
- • Git 基本操作 - Git 教程
- • C# 文本文件的读写 - C#教程
- • ☆基于Java Instrument的Agent实现
- • Kotlin学习（二）基本类型
相关标签/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
欢迎关注本站公众号,获取更多信息
相关文章
- 1. java对文件的基本操做
- 2. java对xml文件的操做
- 3. Java 对xml文件的读写操做
- 4. java 本身作的对XML文件的读写操做
- 5. Java操做XML文件
- 6. java操做XML文件
- 7. C#中对XML文件的一些基本操做
- 8. Adobe AIR对本地文件(XML文件)的操做
- 9. pig的基本操做（对hadoop文件）
- 10. c#对XML文件的读写操做