一、DOM4J

?

/*DOM4J提供至少3种遍历节点的方法*/
1. //1)枚举(Iterator)
2. //枚举所有子节点
3. for(Iteratori=root.elementIterator();i.hasNext();){
4. Elementelement=(Element)i.next();
5. //枚举名称为foo的节点
6. for(Iteratori=root.elementIterator(foo);i.hasNext();){
7. Elementfoo=(Element)i.next();
8. //枚举属性
9. for(Iteratori=root.attributeIterator();i.hasNext();){
10. Attributeattribute=(Attribute)i.next();
11. //2)递归
12. //递归也可以采用Iterator作为枚举手段，但文档中提供了另外的做法
13. publicvoidtreeWalk(){
14. treeWalk(getRootElement());
15. publicvoidtreeWalk(Elementelement){
16. for(inti=0,size=element.nodeCount();i<size;i++){
17. Nodenode=element.node(i);
18. if(nodeinstanceofElement){
19. treeWalk((Element)node);
20. }else{//dosomething....
21. //3)Visitor模式
22. //主要原理就是两种类互相保有对方的引用，并且一种作为Visitor去访问许多Visitable。只需要自定一个类实现Visitor接口即可。
23. publicclassMyVisitorextendsVisitorSupport{
24. publicvoidvisit(Elementelement){
25. System.out.println(element.getName());
26. publicvoidvisit(Attributeattr){
27. System.out.println(attr.getName());
28. //调用：root.accept(newMyVisitor())

importjava.io.File;
1. importjava.io.FileWriter;
2. importjava.io.IOException;
3. importjava.util.Iterator;
4. importorg.dom4j.Attribute;
5. importorg.dom4j.Document;
6. importorg.dom4j.DocumentException;
7. importorg.dom4j.DocumentHelper;
8. importorg.dom4j.Element;
9. importorg.dom4j.io.SAXReader;
10. importorg.dom4j.io.XMLWriter;
11. /**
12. *dom4j生成与解析XML文档
13. */
14. publicclassDom4jDemo{
16. /**
17. *利用dom4j进行xml文档的写入操作
18. */
19. publicvoidcreateXml(Filefile){
20. //XML声明<?xmlversion="1.0"encoding="UTF-8"?>自动添加到XML文档中
21. //使用DocumentHelper类创建文档实例(生成XML文档节点的dom4jAPI工厂类)
22. //使用addElement()方法创建根元素employees(用于向XML文档中增加元素)
23. Elementroot=document.addElement("employees");
24. //在根元素中使用addComment()方法添加注释"AnXMLNote"
25. root.addComment("AnXMLNote");
26. //在根元素中使用addProcessingInstruction()方法增加一个处理指令
27. root.addProcessingInstruction("target","text");
28. //在根元素中使用addElement()方法增加employee元素。
29. ElementempElem=root.addElement("employee");
30. //使用addAttribute()方法向employee元素添加id和name属性
31. empElem.addAttribute("id","0001");
32. empElem.addAttribute("name","wanglp");
33. //向employee元素中添加sex元素
34. ElementsexElem=empElem.addElement("sex");
35. //使用setText()方法设置sex元素的文本
36. sexElem.setText("m");
37. //在employee元素中增加age元素并设置该元素的文本。
38. ElementageElem=empElem.addElement("age");
39. ageElem.setText("25");
40. Elementemp2Elem=root.addElement("employee");
41. emp2Elem.addAttribute("id","0002");
42. emp2Elem.addAttribute("name","fox");
43. Elementsex2Elem=emp2Elem.addElement("sex");
44. sex2Elem.setText("f");
45. Elementage2Elem=emp2Elem.addElement("age");
46. age2Elem.setText("24");
47. //可以使用addDocType()方法添加文档类型说明。
48. //document.addDocType("employees",null,"file://E:/Dtds/dom4j.dtd");
49. //这样就向XML文档中增加文档类型说明：
50. //<!DOCTYPEemployeesSYSTEM"file://E:/Dtds/dom4j.dtd">
51. //如果文档要使用文档类型定义（DTD）文档验证则必须有Doctype。
52. try{
53. XMLWriteroutput=newXMLWriter(newFileWriter(file));
54. output.write(document);
55. output.close();
56. }catch(IOExceptione){
57. System.out.println(e.getMessage());
58. *利用dom4j进行xml文档的读取操作
59. publicvoidparserXml(Filefile){
60. Documentdocument=null;
61. //使用SAXReader解析XML文档catalog.xml：
62. SAXReadersaxReader=newSAXReader();
63. try{
64. document=saxReader.read(file);
65. }catch(DocumentExceptione){
66. e.printStackTrace();
67. //将字符串转为XML
68. //document=DocumentHelper.parseText(fileString);
69. //获取根节点
70. //打印节点名称
71. System.out.println("<"+root.getName()+">");
72. //获取根节点下的子节点遍历
73. Iterator<?>iter=root.elementIterator("employee");
74. //遍历employee节点
75. while(iter.hasNext()){
76. //获取当前子节点
77. ElementempEle=(Element)iter.next();
78. System.out.println("<"+empEle.getName()+">");
79. //获取当前子节点的属性遍历
80. Iterator<?>attrList=empEle.attributeIterator();
81. while(attrList.hasNext()){
82. Attributeattr=(Attribute)attrList.next();
83. System.out.println(attr.getName()+"="+attr.getValue());
84. //遍历employee节点下所有子节点
85. Iterator<?>eleIte=empEle.elementIterator();
86. while(eleIte.hasNext()){
87. Elementele=(Element)eleIte.next();
88. System.out.println("<"+ele.getName()+">"+ele.getTextTrim());
89. //获取employee节点下的子节点sex值
90. //Stringsex=empEle.elementTextTrim("sex");
91. //System.out.println("sex:"+sex);
92. System.out.println("</"+root.getName()+">");
93. publicstaticvoidmain(String[]args){
94. Dom4jDemodom4j=newDom4jDemo();
95. Filefile=newFile("e:/dom4j.xml");
96. //dom4j.createXml(file);
97. dom4j.parserXml(file);
98. }

/*修改xml文档*/

[html] view plain copy print ?

1. publicstaticvoidmodifyxml(){
2. //使用SAXReader去解析xml文件
3. SAXReaderreader=newSAXReader();
4. Documentdocument;
5. try{
6. Filefile=newFile("C:workspaceTestmyxml.xml");
7. //获取document对象
8. document=reader.read(file);
9. //通过selectNodes寻找节点或者属性
10. Listlist=document.selectNodes("/student/call/@show");
11. Iteratorit=list.iterator();
12. while(it.hasNext()){
13. //Attribute属性的操作方法
14. Attributeattribute=(Attribute)it.next();
15. if(attribute.getValue().equals("yes"))
16. {
18. attribute.setValue("no");
19. }
20. }
21. list=document.selectNodes("/student/call/name");
22. it=list.iterator();
23. while(it.hasNext()){
24. //标签内容的操作方法
25. ElementnameElment=(Element)it.next();
26. nameElment.setText("studentname");
27. //删除某个节点是要用两层循环，因为删除当前节点必须用父节点去删除。
28. list=document.selectNodes("/student/call");
29. //获取父节点
30. ElementscoreElement=(Element)it.next();
31. System.out.println(scoreElement);
32. @SuppressWarnings("unused")
33. //获取该父节点下面的需要查找的子节点
34. Iteratoritera=scoreElement.elementIterator("English");
35. while(itera.hasNext()){
36. ElementscoreEnglish=(Element)itera.next();
37. if(scoreEnglish.getText().equals("77")){
38. //利用父节点去删除
39. scoreElement.remove(scoreEnglish);
40. @SuppressWarnings("unused")
41. /*Iteratoritera=document.getRootElement().elementIterator("call");
42. Elementele=(Element)itera.next();
43. System.out.println(ele);
44. }*/
46. OutputFormatformat=OutputFormat.createPrettyPrint();
47. format.setEncoding("UTF-8");
48. XMLWriterwriter;
49. try{
50. writer=newXMLWriter(newFileWriter("myxml.xml"),format);
51. writer.write(document);
52. writer.close();
53. }catch(IOExceptione){
54. e.printStackTrace();
55. }catch(DocumentExceptione){
56. }

二、JDOM

//导入jar包：jdom.jarimportjava.io.File;
1. importjava.io.FileNotFoundException;
2. importjava.io.FileOutputStream;
3. importjava.io.IOException;
4. importjava.util.List;
5. importorg.jdom.Attribute;
6. importorg.jdom.Comment;
7. importorg.jdom.Document;
8. importorg.jdom.Element;
9. importorg.jdom.JDOMException;
10. importorg.jdom.input.SAXBuilder;
11. importorg.jdom.output.Format;
12. importorg.jdom.output.XMLOutputter;
13. *jdom生成与解析XML文档
14. publicclassJdomDemo{
15. Documentdocument=newDocument();
16. *利用JDom进行xml文档的写入操作
17. //1.创建元素及设置为根元素
18. Elementemployees=newElement("employees");
19. document.setContent(employees);
20. //2.创建注释及设置到根元素上
21. Commentcommet=newComment("thisismycomment");
22. employees.addContent(commet);
23. //3.创建元素
24. Elementelement1=newElement("employee");
25. //3.1设置元素的属性名及属性值
26. element1.setAttribute(newAttribute("id","0001"));
27. //3.2创建元素的属性名及属性值
28. AttributenameAttr=newAttribute("name",0); background-color:inherit">//3.3设置元素名及文本
29. ElementsexEle=newElement("sex");
30. sexEle.setText("m");
31. //设置到上层元素上
32. element1.addContent(sexEle);
33. //设置元素
34. ElementageEle=newElement("age");
35. ageEle.setText("22");
36. element1.addContent(ageEle);
37. //设置为根元素的子元素
38. employees.addContent(element1);
39. //将元素属性设置到元素上
40. element1.setAttribute(nameAttr);
41. //3.创建元素
42. Elementelement2=newElement("employee");
43. //3.1设置元素的属性名及属性值
44. element2.setAttribute(newAttribute("id","0002"));
45. //3.2创建元素的属性名及属性值
46. Attributename2Attr=newAttribute("name","fox");
47. //3.3设置元素名及文本
48. Elementsex2Ele=newElement("sex");
49. sex2Ele.setText("f");
50. //设置到上层元素上
51. element2.addContent(sex2Ele);
52. //设置元素
53. Elementage2Ele=newElement("age");
54. age2Ele.setText("21");
55. element2.addContent(age2Ele);
56. //设置为根元素的子元素
57. employees.addContent(element2);
58. //将元素属性设置到元素上
59. element2.setAttribute(name2Attr);
60. Elementelement3=newElement("employee");
61. element3.setText("title");
62. element3.addContent(newElement("name").addContent(newElement("hello")));
63. employees.addContent(element3);
64. //设置xml文档输出的格式
65. Formatformat=Format.getPrettyFormat();
66. XMLOutputterout=newXMLOutputter(format);
67. //将得到的xml文档输出到文件流中
68. out.output(document,newFileOutputStream(file));
69. }catch(FileNotFoundExceptione){
70. }catch(IOExceptione){
71. *利用JDom进行xml文档的读取操作
72. publicvoidparserXml(Filefile){
73. //建立解析器
74. SAXBuilderbuilder=newSAXBuilder();
75. //将解析器与文档关联
76. document=builder.build(file);
77. }catch(JDOMExceptione1){
78. e1.printStackTrace();
79. }catch(IOExceptione1){
80. //读取根元素
81. Elementroot=document.getRootElement();
82. //输出根元素的名字
83. System.out.println("<"+root.getName()+">");
84. //读取元素集合
85. List<?>employeeList=root.getChildren("employee");
86. 0;i<employeeList.size();i++){
87. Elementele=(Element)employeeList.get(i);
88. //得到元素的名字
89. System.out.println("<"+ele.getName()+">");
90. //读取元素的属性集合
91. List<?>empAttrList=ele.getAttributes();
92. for(intj=0;j<empAttrList.size();j++){
93. Attributeattrs=(Attribute)empAttrList.get(j);
94. //将属性的名字和值并输出
95. Stringname=attrs.getName();
96. Stringvalue=(String)attrs.getValue();
97. System.out.println(name+"="+value);
98. Elementsex=ele.getChild("sex");
99. System.out.println("<sex>"+sex.getText());
100. Elementage=ele.getChild("age");
101. System.out.println("<age>"+age.getText());
102. }catch(NullPointerExceptione){
103. System.out.println(ele.getTextTrim());
104. Elementname=ele.getChild("name");
105. System.out.println("<name>"+name.getName());
106. System.out.println("</employee>");
107. System.out.println("</employees>");
108. *测试
109. publicstaticvoidmain(String[]args){
110. JdomDemojdom=newJdomDemo();
111. Filefile=newFile("E://jdom.xml");
112. jdom.createXml(file);
113. jdom.parserXml(file);
114. 三、DOM 1、原理：DOM是基于树的结构，解析器读入-整个-文档，然后构建一个驻留内存的树结构，使用 DOM 接 口来操作这个树结构。
     2、优点：a、由于整棵树在内存中，便于操作,可以对xml文档随机访问
     b、可以对xml文档进行删除、修改、重新排列等多种功能；访问效率高
     c、较sax，dom使用也更简单。
     3、缺点：a、整个文档必须一次性解析完（无用的节点也会解析）,浪费时间和空间.
     b、由于整个文档都需要载入内存，对于大文档成本高
     4、 场合：小型xml文档；一旦解析了文档还需多次访问这些数据；
     ?
     importjava.io.PrintWriter;
     1. importjavax.xml.parsers.DocumentBuilder;
     2. importjavax.xml.parsers.DocumentBuilderFactory;
     3. importjavax.xml.parsers.ParserConfigurationException;
     4. importjavax.xml.transform.OutputKeys;
     5. importjavax.xml.transform.Transformer;
     6. importjavax.xml.transform.TransformerConfigurationException;
     7. importjavax.xml.transform.TransformerException;
     8. importjavax.xml.transform.TransformerFactory;
     9. importjavax.xml.transform.dom.DOMSource;
     10. importjavax.xml.transform.stream.StreamResult;
     11. importorg.w3c.dom.Attr;
     12. importorg.w3c.dom.Document;
     13. importorg.w3c.dom.Element;
     14. importorg.w3c.dom.Node;
     15. importorg.w3c.dom.NodeList;
     16. importorg.xml.sax.SAXException;
     17. *DOM生成与解析XML文档
     18. *
     19. *@author莫小哆_ly2012-2-20
     20. publicclassDomDemo{
     21. /*
     22. *解析器读入整个文档，然后构建一个驻留内存的树结构，
     23. *
     24. *然后代码就可以使用DOM接口来操作这个树结构。
     25. *优点：整个文档树在内存中，便于操作；支持删除、修改、重新排列等多种功能；
     26. *缺点：将整个文档调入内存（包括无用的节点），浪费时间和空间；
     27. *使用场合：一旦解析了文档还需多次访问这些数据；硬件资源充足（内存、CPU）
     28. //表示整个HTML或XML文档。从概念上讲，它是文档树的根，并提供对文档数据的基本访问
     29. privateDocumentdocument;
     30. *创建DOM树
     31. *要读入一个XML文档，首先要一个DocumentBuilder对象
     32. publicvoidinit(){
     33. //获取DocumentBuilderFactory的新实例
     34. DocumentBuilderFactoryfactory=DocumentBuilderFactory.newInstance();
     35. //使用当前配置的参数创建一个新的DocumentBuilder实例
     36. DocumentBuilderbuilder=null;
     37. builder=factory.newDocumentBuilder();
     38. }catch(ParserConfigurationExceptione){
     39. e.printStackTrace();
     40. //获取DOMDocument对象的一个新实例来生成一个DOM树
     41. this.document=builder.newDocument();
     42. *xml文档的写入操作
     43. *@paramfile
     44. //创建DOM树
     45. this.init();
     46. //创建XML根节点employees
     47. Elementroot=this.document.createElement("employees");
     48. //AddsthenodenewChildtotheendofthelistofchildrenofthis
     49. //node.
     50. //IfthenewChildisalreadyinthetree,itisfirstremoved.
     51. this.document.appendChild(root);
     52. //1.创建根节点的子节点employee
     53. Elementemployee=this.document.createElement("employee");
     54. //向根节点添加属性节点
     55. Attrid=this.document.createAttribute("id");
     56. id.setNodeValue("0001");
     57. //把属性节点对象，追加到达employee节点；
     58. employee.setAttributeNode(id);
     59. //声明employee的子节点name
     60. Elementname=this.document.createElement("name");
     61. //向XML文件name节点追加数据
     62. name.appendChild(this.document.createTextNode("wanglp"));
     63. //把子节点的属性追加到employee子节点中元素中
     64. employee.appendChild(name);
     65. //声明employee的子节点sex
     66. Elementsex=this.document.createElement("sex");
     67. //向XML文件sex节点追加数据
     68. sex.appendChild(this.document.createTextNode("m"));
     69. //把子节点的属性追加到employee子节点中元素中
     70. employee.appendChild(sex);
     71. //声明employee的子节点age
     72. Elementage=this.document.createElement("age");
     73. //向XML文件age节点追加数据
     74. age.appendChild(this.document.createTextNode("25"));
     75. employee.appendChild(age);
     76. //employee节点定义完成，追加到root
     77. root.appendChild(employee);
     78. //2.创建根节点的子节点employee
     79. employee=this.document.createElement("employee");
     80. //向根节点添加属性节点
     81. id=this.document.createAttribute("id");
     82. id.setNodeValue("0002");
     83. //把属性节点对象，追加到达employee节点；
     84. employee.setAttributeNode(id);
     85. //声明employee的子节点name
     86. name=this.document.createElement("name");
     87. //向XML文件name节点追加数据
     88. name.appendChild(this.document.createTextNode("huli"));
     89. employee.appendChild(name);
     90. //声明employee的子节点sex
     91. sex=this.document.createElement("sex");
     92. //向XML文件sex节点追加数据
     93. sex.appendChild(this.document.createTextNode("f"));
     94. employee.appendChild(sex);
     95. //声明employee的子节点age
     96. age=this.document.createElement("age");
     97. //向XML文件age节点追加数据
     98. age.appendChild(this.document.createTextNode("12"));
     99. employee.appendChild(age);
     100. //employee节点定义完成，追加到root
     101. root.appendChild(employee);
     102. //获取TransformerFactory的新实例。
     103. TransformerFactorytf=TransformerFactory.newInstance();
     104. //创建执行从Source到Result的复制的新Transformer。能够将源树转换为结果树
     105. Transformertransformer=null;
     106. transformer=tf.newTransformer();
     107. }catch(TransformerConfigurationExceptione){
     108. //设置转换中实际的输出属性
     109. //指定首选的字符编码
     110. transformer.setOutputProperty(OutputKeys.ENCODING,"UTF-8");
     111. //indent="yes"|"no".指定了当输出结果树时，Transformer是否可以添加额外的空白
     112. transformer.setOutputProperty(OutputKeys.INDENT,"yes");
     113. //声明文件流
     114. PrintWriterpw=null;
     115. pw=newPrintWriter(newFileOutputStream(file));
     116. System.out.println("文件没有找到!");
     117. //充当转换结果的持有者，可以为XML、纯文本、HTML或某些其他格式的标记
     118. StreamResultresult=newStreamResult(pw);
     119. //DOMSourceimplementsSource
     120. DOMSourcesource=newDOMSource(document);
     121. //将XMLSource转换为Result
     122. transformer.transform(source,result);
     123. }catch(TransformerExceptione){
     124. System.out.println("生成XML文件失败!");
     125. System.out.println("生成XML文件成功!");
     126. *xml文档的读取操作
     127. DocumentBuilderbuilder;
     128. //将给定URI的内容解析为一个XML文档，并且返回一个新的DOMDocument对象
     129. document=builder.parse(file);
     130. }catch(SAXExceptione){
     131. //获得文档根元素对对象;
     132. Elementroot=document.getDocumentElement();
     133. //获得文档根元素下一级子元素所有元素;
     134. NodeListnodeList=root.getChildNodes();
     135. System.out.print("<employees>");
     136. System.out.println(root.getNodeName());
     137. if(null!=root){
     138. for(inti=0;i<nodeList.getLength();i++){
     139. Nodechild=nodeList.item(i);
     140. //输出child的属性;
     141. System.out.print("<test>");
     142. System.out.println(child);
     143. if(child.getNodeType()==Node.ELEMENT_NODE){
     144. System.out.print("<id>");
     145. System.out.println(child.getAttributes().getNamedItem("id").getNodeValue());
     146. for(Nodenode=child.getFirstChild();node!=null;node=node.getNextSibling()){
     147. if(node.getNodeType()==Node.ELEMENT_NODE){
     148. if("name".equals(node.getNodeName())){
     149. System.out.print("<name>");
     150. System.out.println(node.getFirstChild().getNodeValue());
     151. if("sex".equals(node.getNodeName())){
     152. System.out.print("<sex>");
     153. if("age".equals(node.getNodeName())){
     154. System.out.print("<age>");
     155. if("email".equals(node.getNodeName())){
     156. System.out.print("<email>");
     157. System.out.println("解析完毕");
     158. *测试
     159. //为什么有类似于这样东西[#text:]
     160. //原因是XML文件元素之间的空白字符也是一个元素，<employees></employees>包含的空白
     161. DomDemodom=newDomDemo();
     162. Filefile=newFile("E://dom.xml");
     163. dom.createXml(file);
     164. dom.parserXml(file);
     165. 四、SAX 1、原理：SAX类似流媒体，它基于事件驱动，当解析器发现元素开始、元素结束、文本、文档的开始或结束 等时，发送事件，程序员编写响应这些事件的代码，保存数据。无需将整个文档载入内存，使用者 只需要监听自己感兴趣的事件即可。
          2、优点：a、无需将整个xml文档载入内存，因此消耗内存少
          b、SAX解析器代码比DOM解析器代码小，适于Applet，下载。
          c、可以注册多个ContentHandler
          3、缺点：a、不能随机的访问xml中的节点
          b、只支持读，不能修改文档。非持久，事件过后，若没保存数据，那么数据就丢了
          c、无状态性；从事件中只能得到文本，但不知该文本属于哪个元素
          4、场合：大型xml文档；Applet；只需XML文档的少量内容，很少回头访问；
          ?
          importjavax.xml.parsers.SAXParser;
          1. importjavax.xml.parsers.SAXParserFactory;
          2. importorg.xml.sax.Attributes;
          3. importorg.xml.sax.helpers.DefaultHandler;
          4. *startDocument()，endDocument(),startElement(),endElement(),characters()
          5. publicclassSAXParseDemoextendsDefaultHandler{
          6. privateStringtagValue;//标签值
          7. //开始解析XML文件
          8. publicvoidstartDocument()throwsSAXException{
          9. System.out.println("开始解析");
          10. //结束解析XML文件
          11. publicvoidendDocument()throwsSAXException{
          12. System.out.println("结束解析");
          13. //解析元素
          14. *开始解析一个元素
          15. *@paramqName标签名
          16. *@paramattributes属性
          17. @Override
          18. publicvoidstartElement(Stringuri,StringlocalName,StringqName,Attributesattributes)
          19. throwsSAXException{
          20. System.out.println(qName+"开始");
          21. //属性
          22. if(attributes!=null&&attributes.getLength()!=0){
          23. System.out.println("属性：");
          24. 0;i<attributes.getLength();i++){
          25. System.out.print(attributes.getQName(i)+"=");//属性名
          26. System.out.print(attributes.getValue(i)+"");//属性值
          27. System.out.println();
          28. *结束一个元素的解析遇到结束标签时调用此方法通常在此方法对标签取值并处理
          29. publicvoidendElement(Stringuri,StringqName)throwsSAXException{
          30. System.out.println(qName+"标签值："+tagValue);
          31. System.out.println(qName+"结束");
          32. //所有xml文件中的字符都会放到ch[]中
          33. publicvoidcharacters(charch[],intstart,intlength)throwsSAXException{
          34. tagValue=newString(ch,start,length).trim();
          35. Filefile=newFile("src/cn/main/example/demo.xml");
          36. SAXParserFactorysaxParFac=SAXParserFactory.newInstance();
          37. SAXParsersaxParser=saxParFac.newSAXParser();
          38. saxParser.parse(file,newSAXParseDemo());
          39. }catch(Exceptione){
          40. }
          
          

          五、资料(关于Xpath)

          1、选取节点

          XPath 使用路径表达式在 XML 文档中选取节点，节点是沿着路径或者 step 来选取的。

          常见的路径表达式：

          表达式	描述
          nodename	选取当前节点的所有子节点
          /	从根节点选取
          //	从匹配选择的当前节点选择文档中的节点，而不考虑它们的位置
          .	选取当前节点
          ..	选取当前节点的父节点
          @	选取属性

          实例

          路径表达式

          结果
          bookstore	选取 bookstore 元素的所有子节点
          /bookstore	选取根元素 bookstore
          bookstore/book	选取bookstore 下名字为 book的所有子元素。
          //book	选取所有 book 子元素，而不管它们在文档中的位置。
          bookstore//book	选取bookstore 下名字为 book的所有后代元素，而不管它们位于 bookstore 之下的什么位置。
          //@lang	选取所有名为 lang 的属性。

          2、谓语（Predicates）

          谓语用来查找某个特定的节点或者包含某个指定的值的节点。

          谓语被嵌在方括号中。

          实例

          常见的谓语的一些路径表达式：

          /bookstore/book[1]

          选取属于 bookstore 子元素的第一个 book 元素。
          /bookstore/book[last()]	选取属于 bookstore 子元素的最后一个 book 元素。
          /bookstore/book[last()-1]	选取属于 bookstore 子元素的倒数第二个 book 元素。
          /bookstore/book[position()<3]	选取最前面的两个属于 bookstore 元素的子元素的 book 元素。
          //title[@lang]	选取所有拥有名为 lang 的属性的 title 元素。
          //title[@lang='eng']	选取所有 title 元素，要求这些元素拥有值为 eng 的 lang 属性。
          /bookstore/book[price>35.00]	选取所有 bookstore 元素的 book 元素，要求book元素的子元素 price 元素的值须大于 35.00。
          /bookstore/book[price>35.00]/title	选取所有 bookstore 元素中的 book 元素的 title 元素，要求book元素的子元素 price 元素的值须大于 35.00

          3、选取未知节点

          XPath 通配符可用来选取未知的 XML 元素。

          通配符

          *	匹配任何元素节点
          @*	匹配任何属性节点
          node()	匹配任何类型的节点

          /bookstore/*

//*

选取文档中的所有元素

//title[@*]

选取所有带有属性的 title 元素。

ancestor

选取当前节点的所有先辈（父、祖父等）

ancestor-or-self

选取当前节点的所有先辈（父、祖父等）以及当前节点本身

attribute

选取当前节点的所有属性

child

选取当前节点的所有子元素。

descendant

选取当前节点的所有后代元素（子、孙等）。

descendant-or-self

选取当前节点的所有后代元素（子、孙等）以及当前节点本身。

following

选取文档中当前节点的结束标签之后的所有节点。

namespace

选取当前节点的所有命名空间节点

parent

选取当前节点的父节点。

preceding

选取文档中当前节点的开始标签之前的所有节点。

preceding-sibling

选取当前节点之前的所有同级节点。

self

选取当前节点。

运算符

描述

实例

返回值

|

计算两个节点集

//book | //cd

返回所有带有 book 和 ck 元素的节点集

+

加法

6 + 4

10

-

减法

6 - 4

2

*

乘法

6 * 4

24

div

除法

8 div 4

=

等于

price=9.80

如果 price 是 9.80，则返回 true。

如果 price 是 9.90，则返回 fasle。

!=

不等于

price!=9.80

如果 price 是 9.90，则返回 true。

如果 price 是 9.80，则返回 fasle。

<

小于

price<9.80

如果 price 是 9.00，则返回 true。

如果 price 是 9.90，则返回 fasle。

<=

小于或等于

price<=9.80

>

大于

price>9.80

>=

大于或等于

price>=9.80

如果 price 是 9.90，则返回 true。

如果 price 是 9.70，则返回 fasle。

or

或

price=9.80 or price=9.70

如果 price 是 9.80，则返回 true。

如果 price 是 9.50，则返回 fasle。

and

与

price>9.00 and price<9.90

如果 price 是 9.80，则返回 true。

如果 price 是 8.50，则返回 fasle。

mod

计算除法的余数

5 mod 2

1