Question

如何使用dom进行特定xml的解析

xml如下:
<?xml version="1.0" encoding="GB2312"?>
<!-- -->
<Structure>
<VALUE NUM="1">
<NUMBER>
1
</NUMBER>
<!--记录数,int类型-->
<ACTIVE>
true
</ACTIVE>
<!--活动标识，这类不会删除，回收后改变active状态,boolean类型-->
<CREATEDTIME>
肉容
</CREATEDTIME>
<!--创建时间,long类型-->
<REMINDTIME>
某个时间
</REMINDTIME>
<!--提醒时间,long类型-->
<FINISH>
false
</FINISH>
<!--完成状态,boolean类型-->
<CONTENT>
哈喽
</CONTENT>
<!--提醒的内容,String类型-->
<ADDCONTENT>
再哈喽
</ADDCONTENT>
<!--追加提醒内容,List<String>类型 -->
<REPEAT>
true
</REPEAT>
<!--重复提醒开关,boolean类型-->
<REPEATTYPE>
1
</REPEATTYPE>
<!--重复类型,int类型-->
<RINGMUSIC>
D:\\chiliangjin.mp3
</RINGMUSIC>
<!--提醒音乐的路径,String类型-->
</VALUE>
<VALUE NUM="2">
<NUMBER>
2
</NUMBER>
<!--记录数,int类型-->
<ACTIVE>
true
</ACTIVE>
<!--活动标识，这类不会删除，回收后改变active状态,boolean类型-->
<CREATEDTIME>
肉容2
</CREATEDTIME>
<!--创建时间,long类型-->
<REMINDTIME>
某个时间2
</REMINDTIME>
<!--提醒时间,long类型-->
<FINISH>
false
</FINISH>
<!--完成状态,boolean类型-->
<CONTENT>
哈喽2
</CONTENT>
<!--提醒的内容,String类型-->
<ADDCONTENT>
再哈喽2
</ADDCONTENT>
<!--追加提醒内容,List<String>类型 -->
<REPEAT>
true
</REPEAT>
<!--重复提醒开关,boolean类型-->
<REPEATTYPE>
1
</REPEATTYPE>
<!--重复类型,int类型-->
<RINGMUSIC>
D:\\chiliangjin.mp3
</RINGMUSIC>
<!--提醒音乐的路径,String类型-->
</VALUE>

</Structure>

value 作用根标识，使用map<int,String[]>存储这个结构，其中int 为value 的num值,String[]为value 下的valuename,value的值。
看了一部分的dom 对xml解析，对NodeLIst Node这两个不太理解，请会dom解析的帮忙一下。

Answer 1

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.net.MalformedURLException;
import java.net.URL;

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

import org.w3c.dom.Element;
import org.w3c.dom.NodeList;
import org.xml.sax.SAXException;

public class XMLDownload {
public static final String API = "http://dict-co.iciba.com/api/dictionary.php?w=";

public File getSearchXML(String keyword) {
try {
URL url = new URL(API + keyword);
BufferedInputStream bis = new BufferedInputStream(url.openStream());
File xml = new File("search.xml");
BufferedOutputStream out = new BufferedOutputStream(
new FileOutputStream(xml));
byte[] buf = new byte[2048];
int length = bis.read(buf);
while (length != -1) {
out.write(buf, 0, length);
length = bis.read(buf);
}
bis.close();
out.close();

return xml;
} catch (MalformedURLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return null;
}

public String readXML(File xml) {
String result = "";
DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
DocumentBuilder db;

try {
db = dbf.newDocumentBuilder();
org.w3c.dom.Document doc = db.parse(xml);
Element root = doc.getDocumentElement();
System.out.println("root"+root.getAttribute("num"));
if (root.hasChildNodes()) {
Element key = (Element) root.getElementsByTagName("key")
.item(0);
if(key != null){
System.out.println(key.getTextContent());
result += key.getTextContent() + "*";
NodeList acceptationList = root
.getElementsByTagName("acceptation");
NodeList posList = root.getElementsByTagName("pos");
System.out.println(posList.item(0).getNodeValue());
int size = acceptationList.getLength();
for (int i = 0; i < size; i++) {
Element pos = (Element) posList.item(i);
Element acceptation = (Element) acceptationList.item(i);
if (pos != null) {
result += pos.getTextContent() + "*";
}
if (acceptation.hasChildNodes()
&& (acceptation.getChildNodes().getLength() > 1)) {
NodeList children = acceptation.getChildNodes();
int lenght = children.getLength();
result += "*";
for (int j = 0; j < lenght; j++) {
Element child = (Element) children.item(j);
result += child.getTextContent() + " ";
}
} else {
result += acceptation.getTextContent() + "*";
}
}
}
}

} catch (ParserConfigurationException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (SAXException e) {
// TODO Auto-generated catch block

} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return result;
}

public String search(String condition) {
return this.readXML(this.getSearchXML(condition));
}

}
上面的代码是我写的一个简单的用在线词霸的API做的在线词典。。

解析xml是先拿到root
然后root下面有一个个Element
如你的xml的root应该是Structure
有的element有child node有的没有
你想拿所有的相似的element如你的xml
可以
NodeList values = root.getElementsByTagName("VALUE")
上面这个是一个NodeList 如果按你的XML应该是包含了2个Ndoe VALUE
VALUE1 和VALUE2
Element value1 = values.item(0);
Element value2 = values.item(1);
如果你想继续读取VALUE下面的node如NUMBER
NodeList numbers = value1.getElementsByTagName("NUMBER");
第一个NUMBER node
Element number = numbers.item(0);
读取<> </>中间的值 number.getTextContent();
读取<>里面的属性如VALUE里的NUM
value1.getAttribute("NUM");
其他的不说了查API把

Answer 2

没有按你的map<int,String[]>来存储。
用的是
Map<String, Map<String, String>> struct = new HashMap<String, Map<String, String>>();
代码如下。
-----------------------------------------------------
import java.io.File;
import java.util.HashMap;
import java.util.Map;

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

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

import com.sun.org.apache.xerces.internal.dom.DeferredCommentImpl;
import com.sun.org.apache.xerces.internal.dom.DeferredTextImpl;

public class StructureTest {

public static void main(String[] args) throws Exception {

Map<String, Map<String, String>> struct = new HashMap<String, Map<String, String>>();

DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
DocumentBuilder builder = factory.newDocumentBuilder();
Document document = builder.parse(new File("data.xml"));
Element root = document.getDocumentElement();

NodeList list = root.getElementsByTagName("VALUE");
for (int i = 0; i < list.getLength(); i++) {
Node node = list.item(i);
Map<String, String> data = loopNode(node);

Node attrNode = node.getAttributes().getNamedItem("NUM");
struct.put(attrNode.getNodeValue(), data);
}

System.out.println(struct);
}

public static Map<String, String> loopNode(Node node) {
Map<String, String> data = new HashMap<String, String>();
if (node.hasChildNodes()) {
NodeList child = node.getChildNodes();
for (int i = 0; i < child.getLength(); i++) {
Node tmp = child.item(i);
if (tmp instanceof DeferredTextImpl) {
continue;
}
if (tmp instanceof DeferredCommentImpl) {
continue;
}
String nodeName = tmp.getNodeName();
String nodevalue = tmp.getFirstChild().getNodeValue();
data.put(nodeName, nodevalue);
}
}
return data;
}

}

Answer 3

你是在问啥？ 问关于NodeList 和Node的意义？？

NodeList就是节点集合
Node就是一个节

比如
<node>
<node1></node1>
<node2></node2>
</node>

node, node1,node2都是node

node节的孩子节就是nodelist，集合长度2

Answer 4

解析 成 map 呀，需不需要 帮忙呢，我可以帮你解析哦。肯定 成功。但是，分要给我，可以加Q 说，416000379.可以给我加分。

Answer 5

java的dom4j解析xml是很强大的，map集合里放入int和String int是value的num，也就是value节点的num属性值，String是valuename，value的值？我有点不明白，求解释。

追问

String[][]是valuename，value的值。想了想 还是用List好点，也就是在int 索引后，加下value节点下的所有的值名（如NUMBER）和值(NUMBER的值为1)，以NUM值作为索引。

追答

看我的 ， 不懂就问哦

System.out.println("开始解析");
try {
//解析value的num属性值
SAXReader saxReader = new SAXReader();
Document doc = saxReader.read(new File("test.xml"));
List list = doc.selectNodes("//VALUE/@NUM");
Iterator iter = list.iterator();
while (iter.hasNext()) {
Attribute attr = iter.next();
System.out.println("-------"+attr.getValue());
}
//解析value下的节点名和文本内容
Map m =new HashMap();
Document aa = saxReader.read(new File("test.xml"));
Element root = doc.getRootElement();
System.out.println(root.getName());
//迭代根节点
for ( Iterator it = root.elementIterator(); it.hasNext(); ) {
Element e = (Element) it.next();
//迭代Value子节点
for(Iterator i = e.elementIterator(); i.hasNext(); ){
Element e1 = (Element) i.next();
//得到Name Text 下面的方法你可以放到任意map 或者 list当中
System.out.println("===="+e1.getName()+"===="+e1.getText());
/**
* 下面的方法 你自己来添加 动动手 呵呵
* */
}
System.out.println(e.getName());
}
} catch (DocumentException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println("解析结束");
}