程序博客网 > 怎么修复u盘里的数据

JAVA DOM解析XML

来源：互联网 发布：怎么修复u盘里的数据 编辑：程序博客网 时间：2024/06/05 11:11

xml文件如下：

  1. <smil xmlns="http://www.w3.org/2000/SMIL20/CR/Language">
  2. <head>
  3. <layout>
  4. <root-layout height="100%" width="100%" />
  5. <region id="Image" top="0" left="0" height="80%" width="100%"/>
  6. <region id="Text" top="80%" left="0" height="20%" width="100%"/>
  7. </layout>
  8. </head>
  9. <body>
  10. <par dur = "5000ms">
  11. <img region="Image" src="/contentlib/32/35/92/52.jpg"/>
  12. <audio src="/contentlib/32/36/58.wav"/>
  13. <text region="Text" src="/contentlib/1/3/29/12.txt"/>
  14. </par>
  15. </body>
  16. </smil>

要解析出xml文件节点属性，比如 要得出 节点<img region="Image" src="/contentlib/32/35/92/52.jpg"/> 属性src的值（/contentlib/32/35/92/52.jpg）。

下面是源码，可以直接解析xml文件 ，和文件流。

可以得到节点值，节点属性值，（如果存在多个<img  下面代码还存在问题）

 

  1. import java.io.InputStream;
  2. import java.io.IOException;
  3. import java.util.ArrayList;
  4. import javax.xml.parsers.DocumentBuilderFactory;
  5. import javax.xml.parsers.DocumentBuilder;
  6. import javax.xml.parsers.ParserConfigurationException;
  7. import javax.xml.parsers.FactoryConfigurationError;
  9. import org.w3c.dom.Document;
  10. import org.w3c.dom.Element;
  11. import org.w3c.dom.NamedNodeMap;
  12. import org.w3c.dom.NodeList;
  13. import org.w3c.dom.Node;
  14. import org.xml.sax.SAXException;
  17. /**
  18.  * <p>Description:  xml解析类</p>
  19.  *
  20.  */
  21. public class XmlParser
  22. {
  23.     
  24.     private static DocumentBuilderFactory factory;
  25.     private static DocumentBuilder builder;
  26.     private Document doc;
  27.     private Element root;
  28.     private String fileName;
  29.     private InputStream inputstream;
  31.     /**
  32.      * 解析文件xml
  33.      * @param file String
  34.      */
  35.     public XmlParser(String file)
  36.     {
  37.         if (file == null)
  38.         {
  39.             return;
  40.         }
  41.         this.fileName = file;
  42.         try
  43.         {
  44.             load();
  45.         }
  46.         catch (IOException ex)
  47.         {
  48.             ex.printStackTrace();
  49.             return;
  50.         }
  51.     }
  53.     /**
  54.      * 解析输入流xml
  55.      * @param input InputStream
  56.      */
  57.     public XmlParser(InputStream input)
  58.     {
  59.         if (input == null)
  60.         {
  61.             return;
  62.         }
  63.         inputstream = input;
  64.         try
  65.         {
  66.             loadStream();
  67.         }
  68.         catch (IOException ex)
  69.         {
  70.             ex.printStackTrace();
  71.             return;
  72.         }
  73.     }
  75.     /**
  76.      * 获取XML文件中指定标签所对应的节点集合
  77.      * @param key String 标签名字
  78.      * @return ArrayList 指定标签对应的节点集
  79.      */
  80.     public ArrayList findNodes(String key)
  81.     {
  82.         NodeList nodes = root.getElementsByTagName(key);
  83.         ArrayList nodeList = new ArrayList();
  84.         for (int i = 0; i < nodes.getLength(); i++)
  85.         {
  86.             nodeList.add(i, (Node) nodes.item(i));
  87.         }
  89.         return nodeList;
  90.     }
  92.     /**
  93.      * 初始化XML
  94.      * @throws IOException
  95.      */
  96.     public void loadStream()
  97.             throws IOException
  98.     {
  99.         try
  100.         {
  101.             loadXMLParser();
  102.             doc = builder.parse(inputstream);
  103.             root = doc.getDocumentElement();
  104.         }
  105.         catch (IOException ex)
  106.         {
  107.             ex.printStackTrace();
  108.         }
  109.         catch (SAXException ex)
  110.         {
  111.             ex.printStackTrace();
  112.         }
  113.         finally
  114.         {
  115.             inputstream.close();
  116.         }
  117.     }
  119.     /**
  120.      * 初始化XML
  121.      * @throws IOException
  122.      */
  123.     public void load()
  124.             throws IOException
  125.     {
  126.         try
  127.         {
  128.             loadXMLParser();
  129.             doc = builder.parse(fileName);
  130.             root = doc.getDocumentElement();
  131.         }
  132.         catch (SAXException SaxEx)
  133.         {
  134.             SaxEx.printStackTrace();
  135.             throw new IOException(SaxEx.getMessage() + "XML file parse error:"
  136.                                   + SaxEx.getException());
  137.         }
  138.         catch (IOException IoEx)
  139.         {
  140.             IoEx.printStackTrace();
  141.             throw new IOException(IoEx.getMessage() + "XML file parse error:");
  142.         }
  143.         catch (Exception ex)
  144.         {
  145.             ex.printStackTrace();
  146.             throw new IOException(ex.getMessage() + "XML file parse error:");
  147.         }
  148.     }
  150.     /**
  151.      * 初始化XML
  152.      * @throws IOException
  153.      */
  154.     private void loadXMLParser()
  155.             throws IOException
  156.     {
  157.         if (builder == null)
  158.         {
  159.             try
  160.             {
  161.                 factory = DocumentBuilderFactory.newInstance();
  162.                 builder = factory.newDocumentBuilder();
  163.             }
  164.             catch (ParserConfigurationException ex)
  165.             {
  166.                 throw new IOException("XML Parser load error:"
  167.                                       + ex.getLocalizedMessage());
  168.             }
  169.             catch (FactoryConfigurationError ConfErrEx)
  170.             {
  171.                 throw new IOException("XML Parser load error:"
  172.                                       + ConfErrEx.getLocalizedMessage());
  173.             }
  174.             catch (Exception Ex)
  175.             {
  176.                 throw new IOException("XML Parser load error:"
  177.                                       + Ex.getLocalizedMessage());
  178.             }
  179.         }
  180.     }
  182.     /**
  183.      * 获取XML文件中某级节点下一级元素的值
  184.      * @param node 节点对象
  185.      * @param subTagName subTagName元素的标签名
  186.      * @return String 该标记元素的的内容
  187.      */
  188.     public static String getSubTagValue(Node node, String subTagName)
  189.     {
  190.         String returnString = "";
  191.         if ((node != null) && (subTagName != null))
  192.         {
  193.             NodeList children = node.getChildNodes();
  195.             for (int innerLoop = 0; innerLoop < children.getLength(); innerLoop++)
  196.             {
  197.                 Node child = children.item(innerLoop);
  199.                 if ((child != null) && (child.getNodeName() != null)
  200.                     && (child.getNodeName().equals(subTagName)))
  201.                 {
  202.                     Node grandChild = child.getFirstChild();
  203.                     if (grandChild != null)
  204.                     {
  205.                         return grandChild.getNodeValue();
  206.                     }
  207.                 }
  208.             }
  209.         }
  210.         return returnString;
  211.     }
  213.     /**
  214.      * 获取XML文件中某单一值
  215.      * @param node 节点对象
  216.      * @param subTagName subTagName元素的标签名
  217.      * @return String 该标记元素的的内容
  218.      */
  220.     public String getresult(String name)
  221.     {
  222.         String result = "";
  223.         ArrayList resultlist = findNodes(name);
  224.         if ((resultlist != null) && (resultlist.size() > 0))
  225.         {
  226.             for (int i = 0; i < resultlist.size(); i++)
  227.             {
  228.                 Node node = (Node) resultlist.get(i);
  229.                 if (node instanceof Element)
  230.                 {
  231.                     if ((node != null) && (node.getNodeName() != null)
  232.                         && (node.getNodeName().equals(name)))
  234.                     {
  235.                         Node grandChild = node.getFirstChild();
  236.                         if (grandChild != null)
  237.                         {
  238.                             result = grandChild.getNodeValue();
  239.                         }
  240.                     }
  241.                 }
  242.             }
  243.         }
  244.         return result;
  245.     }
  246.     
  247.     //
  248.     public String getAttr(String name,String attrName)
  249.     {
  250.         String result = "";
  251.         ArrayList resultlist = findNodes(name);
  252.         if ((resultlist != null) && (resultlist.size() > 0))
  253.         {
  254.             for (int i = 0; i < resultlist.size(); i++)
  255.             {
  256.                 Node node = (Node) resultlist.get(i);
  257.                 if (node instanceof Element)
  258.                 {
  259.                     if ((node != null) && (node.getNodeName() != null)
  260.                         && (node.getNodeName().equals(name)))
  262.                     {
  263.                         //遍历整个xml某节点指定的属性
  264.                         NamedNodeMap attrs=node.getAttributes();
  265.                         if(attrs.getLength()>0 && attrs!=null)
  266.                         {
  267.                             Node attr=attrs.getNamedItem(attrName);
  268.                             result=attr.getNodeValue();
  269.                 
  270.                         }
  271.                         
  272.                     }
  273.                 }
  274.             }
  275.         }
  276.         return result;
  277.     }
  278.     
  279.     public static void main(String[] args)
  280.     {
  281.         String file="D://common//Tomcat60//smil.smil";
  282.   
  283.         XmlParser xml =new XmlParser(file);
  284.         System.out.println(xml.getAttr("text","src"));
  285.   
  286.     }
  287. }

 

解决多个节点问题，，比如下面的xml文件

  1. <smil xmlns="http://www.w3.org/2000/SMIL20/CR/Language">
  2. <head>
  3. <layout>
  4. <root-layout height="100%" width="100%" />
  5. <region id="Image" top="0" left="0" height="80%" width="100%"/>
  6. <region id="Text" top="80%" left="0" height="20%" width="100%"/>
  7. </layout>
  8. </head>
  9. <body>
  10. <par dur = "5000ms">
  11. <img region="Image" src="/contentlib/5/6/95/0.jpg"/>
  12. <audio src="/contentlib/5/6/95/0.wav"/>
  13. <text region="Text" src="/contentlib/5/6/95/0.txt"/>
  14. </par>
  15. <par dur = "5000ms">
  16. <img region="Image" src="/contentlib/5/6/95/1.gif"/>
  17. <audio src="/contentlib/5/6/95/1.wav"/>
  18. <text region="Text" src="/contentlib/5/6/95/1.txt"/>
  19. </par>
  20. <par dur = "5000ms">
  21. <img region="Image" src="/contentlib/5/6/95/2.gif"/>
  22. <audio src="/contentlib/5/6/95/2.wav"/>
  23. <text region="Text" src="/contentlib/5/6/95/2.txt"/>
  24. </par>
  25. </body>
  26. </smil>

要得出所有的src值，下面代码可以实现

 

  2. import java.io.InputStream;
  3. import java.io.IOException;
  4. import java.util.ArrayList;
  5. import java.util.LinkedList;
  6. import java.util.List;
  8. import javax.xml.parsers.DocumentBuilderFactory;
  9. import javax.xml.parsers.DocumentBuilder;
  10. import javax.xml.parsers.ParserConfigurationException;
  11. import javax.xml.parsers.FactoryConfigurationError;
  13. import org.w3c.dom.Document;
  14. import org.w3c.dom.Element;
  15. import org.w3c.dom.NamedNodeMap;
  16. import org.w3c.dom.NodeList;
  17. import org.w3c.dom.Node;
  18. import org.xml.sax.SAXException;
  20. /**
  21.  * Description:  xml解析类
  22.  * @author wayfoon
  23.  * @version 
  24.  */
  25. public class XmlParser
  26. {
  28.     private static DocumentBuilderFactory factory;
  29.     private static DocumentBuilder builder;
  30.     private Document doc;
  31.     private Element root;
  32.     private String fileName;
  33.     private InputStream inputstream;
  35.     /**
  36.      * 解析文件xml
  37.      * @param file
  38.      *            String
  39.      */
  40.     public XmlParser(String file)
  41.     {
  42.         if (file == null)
  43.         {
  44.             return;
  45.         }
  46.         this.fileName = file;
  47.         try
  48.         {
  49.             load();
  50.         }
  51.         catch (IOException ex)
  52.         {
  53.             ex.printStackTrace();
  54.             return;
  55.         }
  56.     }
  58.     /**
  59.      * 解析输入流xml
  60.      * 
  61.      * @param input
  62.      *            InputStream
  63.      */
  64.     public XmlParser(InputStream input)
  65.     {
  66.         if (input == null)
  67.         {
  68.             return;
  69.         }
  70.         inputstream = input;
  71.         try
  72.         {
  73.             loadStream();
  74.         }
  75.         catch (IOException ex)
  76.         {
  77.             ex.printStackTrace();
  78.             return;
  79.         }
  80.     }
  82.     /**
  83.      * 获取XML文件中指定标签所对应的节点集合
  84.      * 
  85.      * @param key
  86.      *            String 标签名字
  87.      * @return ArrayList 指定标签对应的节点集
  88.      */
  89.     public ArrayList findNodes(String key)
  90.     {
  91.         NodeList nodes = root.getElementsByTagName(key);
  92.         ArrayList nodeList = new ArrayList();
  93.         for (int i = 0; i < nodes.getLength(); i++)
  94.         {
  95.             nodeList.add(i, (Node) nodes.item(i));
  96.         }
  98.         return nodeList;
  99.     }
  101.     /**
  102.      * 初始化XML
  103.      * 
  104.      * @throws IOException
  105.      */
  106.     public void loadStream() throws IOException
  107.     {
  108.         try
  109.         {
  110.             loadXMLParser();
  111.             doc = builder.parse(inputstream);
  112.             root = doc.getDocumentElement();
  113.         }
  114.         catch (IOException ex)
  115.         {
  116.             ex.printStackTrace();
  117.         }
  118.         catch (SAXException ex)
  119.         {
  120.             ex.printStackTrace();
  121.         }
  122.         finally
  123.         {
  124.             inputstream.close();
  125.         }
  126.     }
  128.     /**
  129.      * 初始化XML
  130.      * 
  131.      * @throws IOException
  132.      */
  133.     public void load() throws IOException
  134.     {
  135.         try
  136.         {
  137.             loadXMLParser();
  138.             doc = builder.parse(fileName);
  139.             root = doc.getDocumentElement();
  140.         }
  141.         catch (SAXException SaxEx)
  142.         {
  143.             SaxEx.printStackTrace();
  144.             throw new IOException(SaxEx.getMessage() + "XML file parse error:"
  145.                     + SaxEx.getException());
  146.         }
  147.         catch (IOException IoEx)
  148.         {
  149.             IoEx.printStackTrace();
  150.             throw new IOException(IoEx.getMessage() + "XML file parse error:");
  151.         }
  152.         catch (Exception ex)
  153.         {
  154.             ex.printStackTrace();
  155.             throw new IOException(ex.getMessage() + "XML file parse error:");
  156.         }
  157.     }
  159.     /**
  160.      * 初始化XML
  161.      * 
  162.      * @throws IOException
  163.      */
  164.     private void loadXMLParser() throws IOException
  165.     {
  166.         if (builder == null)
  167.         {
  168.             try
  169.             {
  170.                 factory = DocumentBuilderFactory.newInstance();
  171.                 builder = factory.newDocumentBuilder();
  172.             }
  173.             catch (ParserConfigurationException ex)
  174.             {
  175.                 throw new IOException("XML Parser load error:"
  176.                         + ex.getLocalizedMessage());
  177.             }
  178.             catch (FactoryConfigurationError ConfErrEx)
  179.             {
  180.                 throw new IOException("XML Parser load error:"
  181.                         + ConfErrEx.getLocalizedMessage());
  182.             }
  183.             catch (Exception Ex)
  184.             {
  185.                 throw new IOException("XML Parser load error:"
  186.                         + Ex.getLocalizedMessage());
  187.             }
  188.         }
  189.     }
  191.     /**
  192.      * 获取XML文件中某级节点下一级元素的值
  193.      * 
  194.      * @param node
  195.      *            节点对象
  196.      * @param subTagName
  197.      *            subTagName元素的标签名
  198.      * @return String 该标记元素的的内容
  199.      */
  200.     public static String getSubTagValue(Node node, String subTagName)
  201.     {
  202.         String returnString = "";
  203.         if ((node != null) && (subTagName != null))
  204.         {
  205.             NodeList children = node.getChildNodes();
  207.             for (int innerLoop = 0; innerLoop < children.getLength(); innerLoop++)
  208.             {
  209.                 Node child = children.item(innerLoop);
  211.                 if ((child != null) && (child.getNodeName() != null)
  212.                         && (child.getNodeName().equals(subTagName)))
  213.                 {
  214.                     Node grandChild = child.getFirstChild();
  215.                     if (grandChild != null)
  216.                     {
  217.                         return grandChild.getNodeValue();
  218.                     }
  219.                 }
  220.             }
  221.         }
  222.         return returnString;
  223.     }
  225.     /**
  226.      * 获取XML文件中某单一值
  227.      * 
  228.      * @param node
  229.      *            节点对象
  230.      * @param subTagName
  231.      *            subTagName元素的标签名
  232.      * @return String 该标记元素的的内容
  233.      */
  235.     public String getresult(String name)
  236.     {
  237.         String result = "";
  238.         ArrayList resultlist = findNodes(name);
  239.         if ((resultlist != null) && (resultlist.size() > 0))
  240.         {
  241.             for (int i = 0; i < resultlist.size(); i++)
  242.             {
  243.                 Node node = (Node) resultlist.get(i);
  244.                 if (node instanceof Element)
  245.                 {
  246.                     if ((node != null) && (node.getNodeName() != null)
  247.                             && (node.getNodeName().equals(name)))
  249.                     {
  250.                         Node grandChild = node.getFirstChild();
  251.                         if (grandChild != null)
  252.                         {
  253.                             result = grandChild.getNodeValue();
  254.                         }
  255.                     }
  256.                 }
  257.             }
  258.         }
  259.         return result;
  260.     }
  262.     /**
  263.      * 得到某一节点指定属性的值
  264.      * @param node
  265.      * @param name
  266.      * @param attrName
  267.      * @return
  268.      */
  269.     public String getAttrByNode(Node node, String name, String attrName)
  270.     {
  271.         NodeList list = node.getChildNodes();
  272.         // System.out.println("---"+list.getLength());
  273.         String result = "";
  274.         Node child = null;
  275.         for (int innerLoop = 0; innerLoop < list.getLength(); innerLoop++)
  276.         {
  277.             child = list.item(innerLoop);
  279.             if (child instanceof Element)
  280.             {
  281.                 if ((child != null) && (child.getNodeName() != null)
  282.                         && (child.getNodeName().equals(name)))
  283.                 {
  284.                     // 遍历整个xml某节点指定的属性
  285.                     NamedNodeMap attrs = child.getAttributes();
  286.                     if (attrs.getLength() > 0 && attrs != null)
  287.                     {
  288.                         Node attr = attrs.getNamedItem(attrName);
  289.                         result = attr.getNodeValue();
  291.                     }
  292.                 }
  293.             }
  294.         }
  296.         return result;
  297.     }
  299.     /**
  300.      * 得到节点属性值，节点可能存在多个，返回的是个数组
  301.      * 
  302.      * @param name
  303.      * @param attrName
  304.      * @return
  305.      */
  306.     public String[] getAttr(String name, String attrName)
  307.     {
  308.         int len = 0;
  309.         String result[] = new String[] {};
  310.         ArrayList resultlist = findNodes(name);
  311.         if ((resultlist != null) && (resultlist.size() > 0))
  312.         {
  313.             result = new String[resultlist.size() * 3];
  314.             for (int i = 0; i < resultlist.size(); i++)
  315.             {
  316.                 Node node = (Node) resultlist.get(i);
  317.                 if (node instanceof Element)
  318.                 {
  319.                     if ((node != null) && (node.getNodeName() != null)
  320.                             && (node.getNodeName().equals(name)))
  322.                     {
  323.                         String img = getAttrByNode(node, "img", "src");
  324.                         String audio = getAttrByNode(node, "audio", "src");
  325.                         String text = getAttrByNode(node, "text", "src");
  326.                         if (!"".equals(img) && img != null)
  327.                         {
  328.                             result[len++] = img;
  329.                         }
  330.                         else
  331.                         {
  332.                             result[len++] = "";
  333.                         }
  334.                         if (!"".equals(audio) && audio != null)
  335.                         {
  336.                             result[len++] = audio;
  337.                         }
  338.                         else
  339.                         {
  340.                             result[len++] = "";
  341.                         }
  342.                         if (!"".equals(text) && text != null)
  343.                         {
  344.                             result[len++] = text;
  345.                         }
  346.                         else
  347.                         {
  348.                             result[len++] = "";
  349.                         }
  350.                         // System.out.println(result[len]);
  351.                     }
  352.                 }
  353.             }
  354.         }
  355.         //System.out.println(result.length);
  356.         return result;
  357.     }
  359.     public static void main(String[] args)
  360.     {
  361.         String file = "D://**//smil.smil";
  363.         XmlParser xml = new XmlParser(file);
  364.         // XmlParser xml1 =new XmlParser(file1);
  365.         String[] strings = xml.getAttr("par", "dur");
  366.         for (int i = 0; i < strings.length; i++)
  367.         {
  368.             System.out.println(strings[i]);
  369.         }
  372.     }
  373. }

输入结果：就是我们想得到的

0 0
怎么修复u盘里的数据 怎么修复u盘里的数据
原创粉丝点击
热门IT博客
知乎lols7淘汰赛知乎lols7淘汰赛
北师大网络教育怎么样北师大网络教育怎么样
java项目案例分析源码
sqlpro for mac
淘宝无法举证
哪个软件新闻好
yum安装ipk
侠客风云传mac移植
mac mp3转m4r
知乎 胸下夹笔福利
sw软件多大
sem优化方案 给领导看
编制软件
linux cat 倒序 行数
淘宝怎么看信誉度
淘宝装修布局管理
js中数组和对象的区别
淘宝店铺品牌定位
微信cms系统源码
mac 上怎么找到安装包
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 德国帅哥 德国钟 德国suv 游德国 德国dax 德国瓦 德国笃宾犬 德国介绍 美国战机德国坠毁 德国车采用中国电池 德国恶心家庭 德国柏林光之节举行 德国中国时差 德国时间现在几点 德国性宫画图 德国汽车品牌 德国汽车品牌大全 德国车有哪些品牌 德国购物清单 德国和中国时差 德国骨科什么梗 德国必买17种购物清单 德国大学排名 德国英文怎么读 德国风景图片 德国法兰克福 德国国土面积 德国用什么货币 德国科技有多强大 德国特产可以带回国的 德国英语怎么说 德国著名景点 德国人口有多少 德国用英语怎么说 德国特产购物攻略 德国的英文单词 德国三大著名特产 德国英语怎么读 德国足球明星 德国代购什么好 青岛德国建筑群

程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里