java的xml读写

xml读取的基本上都是获取一个xml文件的输入流作为参数,通过一些类方法返回一个document对象(sax读取除外),接下下来的是事情就简单了;xml的写入是利用设置好输出格式的transformer转换器将document对象和xml文件的输出流作为参数生成一个xml文档。采用的测试xml是一个包含全球所有一级城市的xml文档,按照读取所有国家、有州就不读城市(中国除外)的逻辑那么整个文档有3512条可用数据。源码下载

一、采用Dom方式读写

Dom方式读写都是利用的DocumentBuilder对象来读取xml文件或创建document对象的,将创DocumentBuilder对象的代码放入一个方法中。

[java] view plain copy
  1. /** 
  2.  * @Decription TODO 获取DocumentBuilder对象 
  3.  * @date 2016年10月12日 下午8:29:46 
  4.  * @return 
  5.  */  
  6. public  DocumentBuilder getDocumentBuilder(){  
  7.     // 获得DocumentBuilderFactory对象  
  8.     DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();  
  9.     DocumentBuilder db =null;  
  10.     try {  
  11.          db= factory.newDocumentBuilder();  
  12.     } catch (ParserConfigurationException e) {  
  13.         e.printStackTrace();  
  14.     }  
  15.     return db;  
  16. }  

1、Dom读

一次加载所有节点(xml文件过大可能就比较慢的),能保存xml的结构(更方便修改,整棵树都在内存中)。利用DocumentBuilder对象的parse()方法加载xml文档。
[java] view plain copy
  1. /** 
  2.  * @Decription TODO 
  3.  *  有些小国家是没其他城市的,所以没有子节点. 
  4.  *  如果有就获取所有一级城市节点:国外有些国家是没有州的state,那么这些国家的一级城市就是city节点的属性值. 
  5.  *  中华人民共和国全部的省份城市都要保存 
  6.  * @date 2016年10月11日 下午2:46:25 
  7.  */  
  8.  public  void  domParseTest() {  
  9.       
  10.     try {  
  11.         // 获得DocumentBuilder对象  
  12.         DocumentBuilder builder = this.getDocumentBuilder();  
  13.         // 通过xml文件输入流获取xml的document对象,parse有输入流的重载方法。这里我用的是源文件路经作为参数(懒^_^)  
  14.         Document document = builder.parse("LocList.xml");  
  15.         // 获取所有国家节点  
  16.         NodeList countrys = document.getElementsByTagName("CountryRegion");  
  17.         //要保存到数据库的数据题条目的计数器  
  18.         int count = 0;  
  19.         //遍历所有CountryRegion节点  
  20.         for (int j = 0; j < countrys.getLength(); j++) {  
  21.             String countryName = "";  
  22.             String countryCode = "";  
  23.             //获取当前CountryRegion节点  
  24.             Element country = (Element) countrys.item(j);  
  25.             //判断是否拥有属性  
  26.             if(country.hasAttributes()){  
  27.                 //这是一种获取属性值得方式,当属性较多时可用遍历去获取,下面有遍历获取的的方法  
  28.                 countryName = country.getAttribute("Name");  
  29.                 countryCode = country.getAttribute("Code");  
  30.                 System.out.println("国家:" + countryName + "  代码:" + countryCode);  
  31.                 count++;  
  32.             }  
  33.             //判断当前CountryRegion节点是否拥有子节点  
  34.             if (country.hasChildNodes()) {  
  35.                 //获取CountryRegion节点的子节点  
  36.                 NodeList states = country.getChildNodes();  
  37.                 //遍历所有CountryRegion节点下的所有State节点  
  38.                 for (int k = 0; k < states.getLength(); k++) {  
  39.                     //缓存city或state节点的name属性值  
  40.                     String cityName = "";  
  41.                     //缓存city或state节点的code属性值  
  42.                     String cityCode = "";  
  43.                     //中国下面的子节点逻辑(if) 其他(else if 和else) 当elseif和前面的if或elseif同时成立时,执行前面的那一个if或elseif后面的elseif不执行。  
  44.                     if ("State".equals(states.item(k).getNodeName()) && states.item(k).hasAttributes() && "中华人民共和国".equals(countryName)) {  
  45.                         if (states.item(k).getNodeType() == Node.ELEMENT_NODE){  
  46.                             NamedNodeMap stateAttr = states.item(k).getAttributes();  
  47.                             for (int i = 0; i < stateAttr.getLength(); i++) {  
  48.                                 Attr attr = (Attr) stateAttr.item(i);  
  49.                                 if ("Name".equals(attr.getNodeName())) {  
  50.                                     cityName = attr.getNodeValue();  
  51.                                 } else {  
  52.                                     cityCode = attr.getNodeValue();  
  53.                                 }  
  54.                             }  
  55.                             System.out.println(countryName + "的省份: " + cityName + "  代码:" + cityCode);  
  56.                             count++;  
  57.                             if (states.item(k).hasChildNodes()){  
  58.                                 NodeList cityList = states.item(k).getChildNodes();  
  59.                                 //将省份保留下来  
  60.                                 String curState = cityName;  
  61.                                 for (int city = 0; city < cityList.getLength(); city++) {  
  62.                                     if (cityList.item(city).hasAttributes()){  
  63.                                         NamedNodeMap cityAttr = cityList.item(city).getAttributes();  
  64.                                         for (int i = 0; i < cityAttr.getLength(); i++) {  
  65.                                             Attr attr = (Attr) cityAttr.item(i);  
  66.                                             if ("Name".equals(attr.getNodeName())) {  
  67.                                                 cityName = attr.getNodeValue();  
  68.                                             } else {  
  69.                                                 cityCode = attr.getNodeValue();  
  70.                                             }  
  71.                                         }  
  72.                                         System.out.println(countryName + curState + "的城市或地区: " + cityName + "  代码:" + cityCode);  
  73.                                         count++;  
  74.                                     }  
  75.                                 }  
  76.                             }  
  77.                         }  
  78.                           
  79.                     }else if("State".equals(states.item(k).getNodeName()) && states.item(k).hasAttributes() ){  
  80.                         NamedNodeMap cityAttr = states.item(k).getAttributes();  
  81.                         for (int i = 0; i < cityAttr.getLength(); i++) {  
  82.                             Attr attr = (Attr) cityAttr.item(i);  
  83.                             if ("Name".equals(attr.getNodeName())) {  
  84.                                 cityName = attr.getNodeValue();  
  85.                             } else {  
  86.                                 cityCode = attr.getNodeValue();  
  87.                             }  
  88.                         }  
  89.                         System.out.println(countryName + "的一级城市: " + cityName + "  代码:" + cityCode);  
  90.                         count++;  
  91.                     }else {  
  92.                         /** 
  93.                          * 前面是没有属性的state节点时System.out.println(states.item(k).getNodeName());输出下列内容: 
  94.                          * #text  TEXT_NODE 
  95.                          * State  ELEMENT_NODE 
  96.                          * #text 
  97.                          * 所以要加一个判断 
  98.                          **/  
  99.                         if (states.item(k).getNodeType() == Node.ELEMENT_NODE){  
  100.                             if(states.item(k).hasChildNodes()){  
  101.                                 NodeList cityList = states.item(k).getChildNodes();  
  102.                                 for (int city = 0; city < cityList.getLength(); city++) {  
  103.                                     if (cityList.item(city).hasAttributes()){  
  104.                                         NamedNodeMap cityAttr = cityList.item(city).getAttributes();  
  105.                                         for (int i = 0; i < cityAttr.getLength(); i++) {  
  106.                                             Attr attr = (Attr) cityAttr.item(i);  
  107.                                             if ("Name".equals(attr.getNodeName())) {  
  108.                                                 cityName = attr.getNodeValue();  
  109.                                             } else {  
  110.                                                 cityCode = attr.getNodeValue();  
  111.                                             }  
  112.                                         }  
  113.                                         System.out.println(countryName + "的一级城市: " + cityName + "  代码:" + cityCode);  
  114.                                         count++;  
  115.                                     }  
  116.                                 }  
  117.                             }else{  
  118.                                 NamedNodeMap cityAttr = states.item(k).getAttributes();  
  119.                                 for (int i = 0; i < cityAttr.getLength(); i++) {  
  120.                                     Attr attr = (Attr) cityAttr.item(i);  
  121.                                     if ("Name".equals(attr.getNodeName())) {  
  122.                                         cityName = attr.getNodeValue();  
  123.                                     } else {  
  124.                                         cityCode = attr.getNodeValue();  
  125.                                     }  
  126.                                 }  
  127.                                 System.out.println(countryName + "的一级城市: " + cityName + "  代码:" + cityCode);  
  128.                                 count++;  
  129.                             }  
  130.                               
  131.                         }  
  132.                     }  
  133.                 }  
  134.             } else {  
  135.                 System.out.println(countryName + "是个小国家,没有一级城市!");  
  136.             }  
  137.         }  
  138.         System.out.println("一共有:" + count + "的数据!");  
  139.     } catch (SAXException e) {  
  140.         e.printStackTrace();  
  141.     } catch (IOException e) {  
  142.         e.printStackTrace();  
  143.     }  
  144.   
  145. }  

2、Dom写

利用DocumentBuilder对象创建document对象,Transformer对象生成xml文档。

[java] view plain copy
  1. /** 
  2.       * dom生成xml文件 
  3.       */  
  4.     public void domCreateXml(){  
  5.         //创建DocumentBuilder对象  
  6.         DocumentBuilder db = this.getDocumentBuilder();  
  7.         //生成一个Dom树  
  8.         Document document = db.newDocument();  
  9.         //去掉standalone="no"声明,说明只是一个简单的xml,没有特殊DTD(document type definition文档类型定义)规范  
  10.         document.setXmlStandalone(true);  
  11.         //创建Location根节点  
  12.         Element rootElement = document.createElement("Location");  
  13.         //创建CountryRegion节点  
  14.         Element country = document.createElement("CountryRegion");  
  15.         country.setAttribute("Name""中国");  
  16.         country.setAttribute("Code""1");  
  17.         //创建State节点  
  18.         Element state = document.createElement("State");  
  19.         state.setAttribute("Name""四川");  
  20.         state.setAttribute("Code""22");  
  21.         //创建city节点  
  22.         Element city = document.createElement("City");  
  23.         city.setAttribute("Name""成都");  
  24.         city.setAttribute("Code""cd");  
  25.         //将city是state下的子节点,将city加入到state中  
  26.         state.appendChild(city);  
  27.         //将state是country下的子节点,将state加入到country中  
  28.         country.appendChild(state);  
  29.         //将country是Location下的子节点,将state加入到country中  
  30.         rootElement.appendChild(country);  
  31.           
  32.         //将包含了子节点的rootElement添加到document中  
  33.         document.appendChild(rootElement);  
  34.         //实例化工厂类,工厂类不能使用new关键字实例化创建对象  
  35.         TransformerFactory transFactory = TransformerFactory.newInstance();  
  36.         try {  
  37.             //创建transformer对象  
  38.             Transformer transformer = transFactory.newTransformer();  
  39.             //设置换行  
  40.             transformer.setOutputProperty(OutputKeys.INDENT, "Yes");  
  41.             //构造转换,参数都是抽象类,要用的却是更具体的一些类,这些的类的命名有一些规律的。  
  42.             transformer.transform(new DOMSource(document), new StreamResult("LocListDom.xml"));  
  43.         } catch (TransformerConfigurationException e) {  
  44.             e.printStackTrace();  
  45.         } catch (TransformerException e) {  
  46.             e.printStackTrace();  
  47.         }  
  48.     }  

二、采用SAX方式读写

1、SAX读

事件驱动,逐行读取,通过重写DefaultHandler来获取解析的场景。

[java] view plain copy
  1. /** 
  2.      * @Decription TODO 
  3.      * @date 2016年10月12日 下午7:33:26 
  4.      */  
  5.     public  void saxParseTest(){  
  6.         //SAXParserFactory工厂类对象  
  7.         SAXParserFactory factory  = SAXParserFactory.newInstance();  
  8.         InputStream in = null;  
  9.         try {  
  10.             //利用工厂类创建SAXParser对象  
  11.             SAXParser parser = factory.newSAXParser();  
  12.             //创建文件输入流  
  13.             in = new FileInputStream("LocList.xml");  
  14.             //解析  
  15.             parser.parse(in, new SaxHandler());  
  16.         } catch (ParserConfigurationException e) {  
  17.             e.printStackTrace();  
  18.         } catch (SAXException e) {  
  19.             e.printStackTrace();  
  20.         } catch (FileNotFoundException e) {  
  21.             e.printStackTrace();  
  22.         } catch (IOException e) {  
  23.             e.printStackTrace();  
  24.         } finally{  
  25.             try {  
  26.                 if(in != null)  
  27.                 in.close();  
  28.             } catch (IOException e) {  
  29.                 e.printStackTrace();  
  30.             }  
  31.         }  
  32.     }  

通过继承DefaultHandler重写4个方法获取解析状态

[java] view plain copy
  1. package my.sax.practice;  
  2.   
  3. import org.xml.sax.Attributes;  
  4. import org.xml.sax.SAXException;  
  5. import org.xml.sax.helpers.DefaultHandler;  
  6.   
  7. public class SaxHandler extends DefaultHandler{  
  8.         //缓存CountryRegion的name属性值  
  9.         String countryName = "";  
  10.         //缓存CountryRegion的code属性值  
  11.         String countryCode = "";  
  12.         //缓存city或state节点的name属性值  
  13.         String stateName = "";  
  14.         //缓存city或state节点的code属性值  
  15.         String stateCode = "";  
  16.         /** 
  17.          * xml解析开始 
  18.          */  
  19.         @Override  
  20.         public void startDocument() throws SAXException {  
  21.             super.startDocument();  
  22.             System.out.println("sax的xml解析开始");  
  23.         }  
  24.         /** 
  25.          * 解析节点开始 
  26.          */  
  27.         @Override  
  28.         public void startElement(String uri, String localName, String qName, Attributes attributes) throws SAXException {  
  29.             super.startElement(uri, localName, qName, attributes);  
  30.             //attributes!=null判断不行  
  31.             if(attributes.getLength() > 0){  
  32.                 switch (qName) {  
  33.                 case "CountryRegion":  
  34.                     countryName =  attributes.getValue("Name");  
  35.                     countryCode =  attributes.getValue("Code");  
  36.                     System.out.println("国家:" + countryName + "  代码:" + countryCode);  
  37.                     break;  
  38.                 case "State":  
  39.                     stateName =  attributes.getValue("Name");  
  40.                     stateCode = attributes.getValue("Code");  
  41.                     System.out.println(countryName + "的一级城市: " + stateName + "  代码:" + stateCode);  
  42.                     break;    
  43.                 case "City":  
  44.                     String cityName = attributes.getValue("Name");  
  45.                     String cityCode = attributes.getValue("Code");  
  46.                     if("".equals(stateName) && "".equals(stateCode)){  
  47.                         System.out.println(countryName + "的一级城市: " + cityName + "  代码:" + cityCode);  
  48.                     }else{  
  49.                         System.out.println(countryName + stateName + "的城市或地区: " + cityName + "  代码:" + cityCode);  
  50.                     }  
  51.                     break;    
  52.                 default:  
  53.                     break;  
  54.                 }  
  55.             }else{  
  56.                 if(qName.equals("State")){  
  57.                     stateName = "";  
  58.                     stateCode = "";  
  59.                 }  
  60.             }  
  61.         }  
  62.         /** 
  63.          * 解析节点结束 
  64.          */  
  65.         @Override  
  66.         public void endElement(String uri, String localName, String qName) throws SAXException {  
  67.             super.endElement(uri, localName, qName);  
  68.         }  
  69.         /** 
  70.          * xml解析结束 
  71.          */  
  72.         @Override  
  73.         public void endDocument() throws SAXException {  
  74.             super.endDocument();  
  75.             System.out.println("sax的xml解析结束");  
  76.         }  
  77. }  

2、SAX写

[java] view plain copy
  1. /** 
  2.      * @Decription TODO sax方法创建一个xml文档 
  3.      * @date 2016年10月12日 下午8:37:26 
  4.      */  
  5.     public void saxCreateXml(){  
  6.         //1、创建一个SAXTransformerFactory一个对象  
  7.         SAXTransformerFactory sf = (SAXTransformerFactory) SAXTransformerFactory.newInstance();  
  8.         OutputStream in =null;  
  9.         try {  
  10.             //2、通过SAXTransformerFactory创建一个TransformerHandler对象  
  11.             TransformerHandler handler = sf.newTransformerHandler();  
  12.             //3、通过TransformerHandler对象获取Transformer对象(用于设置xml输出的样式和头)  
  13.             Transformer transformer = handler.getTransformer();  
  14.             //设置没有其他的DTD(Document Type Defination 文档类型定义)规范  
  15.             transformer.setOutputProperty(OutputKeys.STANDALONE, "yes");  
  16.             //设置编码格式,显式的显示在<?xml version="1.0" ?>中  
  17.             transformer.setOutputProperty(OutputKeys.ENCODING, "utf-8");  
  18.             //设置换行  
  19.             transformer.setOutputProperty(OutputKeys.INDENT, "yes");  
  20.             //文件输出  
  21.             File file =new File("LocListSax.xml");  
  22.             //确保file是存在的  
  23.             if(!file.exists()){  
  24.                 if(!file.createNewFile()){  
  25.                     throw new FileNotFoundException("文件创建失败!");  
  26.                 }  
  27.             }  
  28.             //4、创建输出流OutputStream对象  
  29.             in = new FileOutputStream(file);  
  30.             //5、创建流Result对象  
  31.             Result result = new StreamResult(in);  
  32.             //6、关联result,此时有了生成元素的方法(handler提供的方法)和装元素的容器(result对象)  
  33.             handler.setResult(result);  
  34.             //打开文档  
  35.             handler.startDocument();  
  36.             //属性设置  
  37.             AttributesImpl attr = new AttributesImpl();  
  38.             //开始创建元素  
  39.             handler.startElement("""""Location", attr);  
  40.             attr.addAttribute("""""Name""""阿尔巴尼亚");  
  41.             attr.addAttribute("""""Code""""DZA");  
  42.             handler.startElement("""""CountryRegion", attr);  
  43.             attr.clear();  
  44.             attr.addAttribute("""""Name""""阿德拉尔");  
  45.             attr.addAttribute("""""Code""""ADR");  
  46.             handler.startElement("""""State", attr);  
  47.             handler.endElement("""""State");  
  48.             handler.endElement("""""CountryRegion");  
  49.             //结束元素创建  
  50.             handler.endElement("""""Location");  
  51.             //关闭文档  
  52.             handler.endDocument();  
  53.         } catch (TransformerConfigurationException e) {  
  54.             e.printStackTrace();  
  55.         } catch (SAXException e) {  
  56.             e.printStackTrace();  
  57.         } catch (IOException e) {  
  58.             e.printStackTrace();  
  59.         }   finally{  
  60.                 try {  
  61.                     //关闭流, 习惯不好,老是不喜欢关闭流  
  62.                     in.close();  
  63.                 } catch (IOException e) {  
  64.                     e.printStackTrace();  
  65.                 }  
  66.         }  
  67.                   
  68.     }  

三、采用JDom方式读写

1、JDom读

[java] view plain copy
  1. public static void jdomParseTest(){  
  2.         //创建SAXBuilder对象  
  3.         SAXBuilder builder = new SAXBuilder();  
  4.         //创建InputStream对象并初始化变量null  
  5.         InputStream in = null ;  
  6.         //缓存CountryRegion的name属性值  
  7.         String countryName = "";  
  8.         //缓存CountryRegion的code属性值  
  9.         String countryCode = "";  
  10.         //缓存city或state节点的name属性值  
  11.         String stateName = "";  
  12.         //缓存city或state节点的code属性值  
  13.         String stateCode = "";  
  14.         //初始化字符输入流  
  15.         InputStreamReader reader =null;  
  16.         try {  
  17.             //获得文件的输入流  
  18.             in =new FileInputStream("LocList.xml");  
  19.             //给设置字符输入流设置编码格式  
  20.             reader = new InputStreamReader(in, "UTF-8");  
  21.             //通过SAXBuilder对象的build方法获取xml的Document对象  
  22.             //报错:前言中不允许有内容,解决办法:使用notepad++ utf-8保存一下  
  23.             Document document = builder.build(reader);  
  24.             //获取根节点Location  
  25.             Element rootElement = document.getRootElement();  
  26.             //获取根节点Location的子节点  
  27.             List<Element> coutryList = rootElement.getChildren();  
  28.             //遍历子节点  
  29.             for(Element country : coutryList){  
  30.                 if (country.hasAttributes()){  
  31.                     countryName = country.getAttributeValue("Name");  
  32.                     countryCode = country.getAttributeValue("Code");  
  33.                     System.out.println("国家:" + countryName + "  代码:" + countryCode);  
  34.                     //获取country的子节点state  
  35.                     List<Element> stateList = country.getChildren();  
  36.                     //遍历state  
  37.                     for (Element state : stateList){  
  38.                         //判断是否拥有属性外国的state节点都是没有属性的,有  
  39.                         if(state.hasAttributes()){  
  40.                             stateName = state.getAttributeValue("Name");  
  41.                             stateCode = state.getAttributeValue("Code");  
  42.                             //当是中国时才遍历state下的子节点  
  43.                             if("中华人民共和国".equals(countryName)){  
  44.                                 //获取state的子节点city  
  45.                                 List<Element> cityList = state.getChildren();  
  46.                                 //遍历city  
  47.                                 for (Element city : cityList){  
  48.                                     if(city.hasAttributes()){  
  49.                                         String cityName = city.getAttributeValue("Name");  
  50.                                         String cityCode = city.getAttributeValue("Code");  
  51.                                         System.out.println(countryName + stateName + "的城市或地区: " + cityName + "  代码:" + cityCode);  
  52.                                     }  
  53.                                 }  
  54.                             }else{  
  55.                                 System.out.println(countryName + "的一级城市: " + stateName + "  代码:" + stateCode);  
  56.                             }  
  57.                         }else{  
  58.                             //获取state的子节点city  
  59.                             List<Element> cityList = state.getChildren();  
  60.                             //遍历city  
  61.                             for (Element city : cityList){  
  62.                                 if(city.hasAttributes()){  
  63.                                     String cityName = city.getAttributeValue("Name");  
  64.                                     String cityCode = city.getAttributeValue("Code");  
  65.                                     System.out.println(countryName + "的一级城市: " + cityName + "  代码:" + cityCode);  
  66.                                 }  
  67.                             }  
  68.                         }  
  69.                     }  
  70.                 }  
  71.             }  
  72.               
  73.         } catch (UnsupportedEncodingException e1) {  
  74.             e1.printStackTrace();  
  75.         } catch (FileNotFoundException e1) {  
  76.             e1.printStackTrace();  
  77.         } catch (JDOMException e) {  
  78.             e.printStackTrace();  
  79.         } catch (IOException e) {  
  80.             e.printStackTrace();  
  81.         } finally{  
  82.               
  83.                 try {  
  84.                     if(in !=null)  
  85.                     in.close();  
  86.                     if (reader != null)  
  87.                     reader.close();  
  88.                 } catch (IOException e) {  
  89.                     e.printStackTrace();  
  90.                 }  
  91.         }  
  92.     }  

2、JDom写

[java] view plain copy
  1. /** 
  2.      *jdom方法生成xml文件 
  3.      */  
  4.     public static void jdomCreateXml(){  
  5.         //创建根节点  
  6.         Element root = new Element("Location");  
  7.         //创建document对象  
  8.         Document document = new Document(root);   
  9.         //添加子节点  
  10.         Element child = new Element("CountryRegion");  
  11.         child.setAttribute("Name""中国");  
  12.         child.setAttribute("Code""1");  
  13.         //添加子节点  
  14.         Element subchild = new Element("State");  
  15.         subchild.setAttribute("Name""四川");  
  16.         subchild.setAttribute("Code""sc");  
  17.         //添加子节点  
  18.         Element subsubchild = new Element("City");  
  19.         subsubchild.setAttribute("Name""成都");  
  20.         subsubchild.setAttribute("Code""cd");  
  21.         //添加孙子节点  
  22.         subchild.addContent(subsubchild);  
  23.         //添加子节点  
  24.         child.addContent(subchild);  
  25.         //添加节点  
  26.         root.addContent(child);  
  27.         //创建Format对象,格式化xml  
  28.         Format formater =Format.getPrettyFormat();  
  29.         //创建XMLOutputter对象  
  30.         XMLOutputter outputer = new XMLOutputter(formater);  
  31.         //初始化输出流,局部变量必须初始化  
  32.         OutputStream out = null;  
  33.         //创建xml文件  
  34.         File file = new File("LocListJdom.xml");  
  35.         try {  
  36.             if (!file.exists()){  
  37.                     if (!file.createNewFile()){  
  38.                         throw new FileCanNotCreateException();  
  39.                     }  
  40.             }  
  41.             //创建输出流  
  42.             out = new FileOutputStream(file);  
  43.             //XMLOutputter写入  
  44.             outputer.output(document, out);  
  45.         } catch (IOException e) {  
  46.             e.printStackTrace();  
  47.             e.printStackTrace();  
  48.         } catch (FileCanNotCreateException e) {  
  49.             e.printStackTrace();  
  50.         } finally{  
  51.             //关闭流  
  52.             try {  
  53.                 out.close();  
  54.             } catch (IOException e) {  
  55.                 e.printStackTrace();  
  56.             }  
  57.         }  
  58.           
  59.     }  


四、采用Dom4j方式读写

1、Dom4j读

[java] view plain copy
  1. public static void dom4jParseTest(){  
  2.         //缓存CountryRegion的name属性值  
  3.         String countryName = "";  
  4.         //缓存CountryRegion的code属性值  
  5.         String countryCode = "";  
  6.         //缓存city或state节点的name属性值  
  7.         String stateName = "";  
  8.         //缓存city或state节点的code属性值  
  9.         String stateCode = "";  
  10.         //创建InputStream对象并初始化变量null  
  11.         InputStream in = null;  
  12.         SAXReader reader = new SAXReader();  
  13.         //获得文件的字符输入流  
  14.         InputStreamReader isr =null;  
  15.         try {  
  16.             in =new FileInputStream("LocList.xml");  
  17.             //给设置输入流直射编码格式  
  18.             isr = new InputStreamReader(in, "UTF-8");  
  19.             //使用read方法将输入流加载到SAXBuilder中获得xml的Document对象  
  20.             Document document = reader.read(isr);  
  21.             //获取根节点Location  
  22.             Element rootElement = document.getRootElement();  
  23.             //获取根节点Location的子节点  
  24.             @SuppressWarnings("unchecked")  
  25.             List<Element> coutryList = rootElement.elements();  
  26.             //遍历子节点  
  27.             for(Element country : coutryList){  
  28.                 if (country.attributes()!=null && country.attributes().size()>0){  
  29.                     countryName = country.attributeValue("Name");  
  30.                     countryCode = country.attributeValue("Code");  
  31.                     System.out.println("国家:" + countryName + "  代码:" + countryCode);  
  32.                     //获取country的子节点state  
  33.                     @SuppressWarnings("unchecked")  
  34.                     List<Element> stateList = country.elements();  
  35.                     //遍历state  
  36.                     for (Element state : stateList){  
  37.                         //判断是否拥有属性外国的state节点都是没有属性的,有  
  38.                         if(state.attributes()!=null && state.attributes().size()>0){  
  39.                             stateName = state.attributeValue("Name");  
  40.                             stateCode = state.attributeValue("Code");  
  41.                             //当是中国时才遍历state下的子节点  
  42.                             if("中华人民共和国".equals(countryName)){  
  43.                                 //获取state的子节点city  
  44.                                 @SuppressWarnings("unchecked")  
  45.                                 List<Element> cityList = state.elements();  
  46.                                 //遍历city  
  47.                                 for (Element city : cityList){  
  48.                                     if(city.attributes()!=null && city.attributes().size()>0){  
  49.                                         String cityName = city.attributeValue("Name");  
  50.                                         String cityCode = city.attributeValue("Code");  
  51.                                         System.out.println(countryName + stateName + "的城市或地区: " + cityName + "  代码:" + cityCode);  
  52.                                     }  
  53.                                 }  
  54.                             }else{  
  55.                                 System.out.println(countryName + "的一级城市: " + stateName + "  代码:" + stateCode);  
  56.                             }  
  57.                         }else{  
  58.                             //获取state的子节点city  
  59.                             @SuppressWarnings("unchecked")  
  60.                             List<Element> cityList = state.elements();  
  61.                             //遍历city  
  62.                             for (Element city : cityList){  
  63.                                 if(city.attributes()!=null && city.attributes().size()>0){  
  64.                                     String cityName = city.attributeValue("Name");  
  65.                                     String cityCode = city.attributeValue("Code");  
  66.                                     System.out.println(countryName + "的一级城市: " + cityName + "  代码:" + cityCode);  
  67.                                 }  
  68.                             }  
  69.                         }  
  70.                     }  
  71.                 }  
  72.             }  
  73.         } catch (FileNotFoundException e) {  
  74.             e.printStackTrace();  
  75.         }catch (DocumentException e) {  
  76.             e.printStackTrace();  
  77.         }catch (UnsupportedEncodingException e) {  
  78.             e.printStackTrace();  
  79.         } finally{  
  80.             //关闭流  
  81.             try {  
  82.                 if(in != null)  
  83.                     in.close();  
  84.                 if (isr != null)  
  85.                     isr.close();  
  86.             } catch (IOException e) {  
  87.                 e.printStackTrace();  
  88.             }  
  89.               
  90.         }  
  91.     }  

2、Dom4j写

[java] view plain copy
  1. /** 
  2.      * 生成xml文件 
  3.      */  
  4.     public static void Dom4jCreateXml(){  
  5.         //初始化输出流  
  6.         OutputStream out = null;  
  7.         //通过DocumentHelper创建document对象  
  8.         Document document = DocumentHelper.createDocument();  
  9.         //创建根节点  
  10.         Element root = document.addElement("Location");  
  11.         //添加子节点  
  12.         Element child =root.addElement("CountryRegion");  
  13.         child.addAttribute("Name""中国");  
  14.         child.addAttribute("Code""1");  
  15.         //添加子节点  
  16.         Element subchild = child.addElement("State");  
  17.         subchild.addAttribute("Name""四川");  
  18.         subchild.addAttribute("Code""sc");  
  19.         //添加子节点  
  20.         Element subsubchild = subchild.addElement("City");  
  21.         subsubchild.addAttribute("Name""成都");  
  22.         subsubchild.addAttribute("Code""cd");  
  23.         //将文件输出  
  24.         try {  
  25.             //创建输出流  
  26.             out = new FileOutputStream("LocListDom4j.xml");  
  27.             //createPrettyPrint格式化xml并返回一个OutPutFormat对象  
  28.             OutputFormat of = OutputFormat.createPrettyPrint();  
  29.             //创建一个XMLWriter对象  
  30.             XMLWriter writer = new XMLWriter(out,of);  
  31.             writer.write(document);  
  32.             writer.close();  
  33.         } catch (IOException e) {  
  34.             e.printStackTrace();  
  35.         }  
  36.           
  37.     }  

五、四种方式性能对比

四种方法中sax读写都是最快,但是sax没办法往回读的。dom4j是第二最关键的代码量少啊,在实际的应用比较多(spring就是用的dom4j)。jdom和dom都差不多,dom的性能还要好一些(我没测试过几次啊,目测)。

阅读更多
想对作者说点什么?

博主推荐

换一批

没有更多推荐了,返回首页