comeon-liming http://comeon-liming.javaeye.com UTF-8 Copyright 2003-2008, JavaEye.com http://blogs.law.harvard.edu/tech/rss JavaEye - 做最棒的软件开发交流社区 常用的文件操作方法 comeon-liming 作者: comeon-liming  链接：http://comeon-liming.javaeye.com/blog/146898  发表时间: 2007年12月08日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

java 代码
  1.   
  2. import java.io.*;   
  3.   
  4. /**  
  5.  * name：FileUtil.java  
  6.  *   
  7.  * desc: 本类是文件操作实用类，提供常用的文件操作方法。  
  8.  *   
  9.  *  
  10.  */  
  11. public class FileUtil   
  12. {   
  13.     /**  
  14.      * 方法根据指定参数名创建一个空文件  
  15.      * @param filePath 文件路径名  
  16.      * @throws IOException  
  17.      */  
  18.     public static File makeFile(String filePath)throws IOException, Exception   
  19.     {   
  20.         //参数无效   
  21.         if (filePath == null || filePath.trim().length() == 0)   
  22.         {   
  23.             throw new IllegalArgumentException("argument is not valid!");   
  24.         }   
  25.         File file = new File(filePath);   
  26.         file.getParentFile().mkdirs();   
  27.         file.createNewFile();   
  28.            
  29.         //文件不存在   
  30.         if (!file.exists())   
  31.         {   
  32.             throw new Exception("create file '"  + filePath + "' failed");   
  33.         }   
  34.         return file;   
  35.     }   
  36.        
  37.     /**  
  38.      * 方法根据指定参数创建目录  
  39.      * @param path 路径名  
  40.      * @throws IOException  
  41.      * @throws Exception  
  42.      */  
  43.     public static void makeDir(String path)throws IOException, Exception   
  44.     {   
  45.         //参数无效   
  46.         if (path == null || path.trim().length() == 0)   
  47.         {   
  48.             throw new IllegalArgumentException("argument is not valid!");   
  49.         }   
  50.         File file = new File(path);   
  51.            
  52.         //目录不存在时，创建目录   
  53.         if (!file.exists())   
  54.         {   
  55.             //创建目录失败时，延时1秒再创建   
  56.             if (!file.mkdirs())   
  57.             {   
  58.                 try  
  59.                 {   
  60.                     final long sleepTime = 1000;   
  61.                     Thread.sleep(sleepTime);   
  62.                     file.mkdirs();   
  63.                 }   
  64.                 catch(InterruptedException ie)   
  65.                 {   
  66.                     file.mkdirs();   
  67.                 }   
  68.             }   
  69.         }   
  70.            
  71.         //目录创建失败   
  72.         if (!file.exists())   
  73.         {   
  74.             throw new Exception("create dir '" + path + "' failed!");    
  75.         }   
  76.     }   
  77.   
  78.     /**  
  79.      * 方法执行文件的拷贝，不支持递归拷贝  
  80.      * @param src 源文件  
  81.      * @param dest 目的文件  
  82.      * @throws IOException  
  83.      * @throws Exception  
  84.      */  
  85.     public static void copy(File src, File dest)throws IOException, Exception   
  86.     {   
  87.         //参数无效   
  88.         if (src == null || dest == null)   
  89.         {   
  90.             throw new IllegalArgumentException("argument is not valid!");   
  91.         }   
  92.            
  93.         //参数相等   
  94.         if (src.equals(dest))   
  95.         {   
  96.             throw new IllegalArgumentException("src file equals to dest file!");   
  97.         }   
  98.            
  99.         org.apache.tools.ant.util.FileUtils fileUtils =   
  100.                                     org.apache.tools.ant.util.FileUtils.newFileUtils();   
  101.            
  102.         fileUtils.copyFile(src, dest, null, true, false);   
  103.     }   
  104.        
  105.     /**  
  106.      * 方法执行文件的拷贝，不支持递归拷贝  
  107.      * @param src 源文件path  
  108.      * @param dest 目的文件path  
  109.      * @throws Exception  
  110.      */  
  111.     public static void copy(String src, String dest)throws Exception   
  112.     {   
  113.         File srcFile = new File(src);   
  114.         File desFile = new File(dest);   
  115.         copy(srcFile, desFile);   
  116.     }   
  117.        
  118.     /**  
  119.      * 复制整个文件夹的内容  
  120.      * @param oldPath 源目录  
  121.      * @param newPath 目的目录  
  122.      * @return  
  123.      */  
  124.     public static void copyFolder(String oldPath, String newPath)throws  
  125.         IOException, Exception   
  126.     {   
  127.         FileInputStream input = null;   
  128.         FileOutputStream output = null;   
  129. //        try   
  130. //        {   
  131.         new File(newPath).mkdirs(); // 如果文件夹不存在 则建立新文件夹   
  132.         File a = new File(oldPath);   
  133.         String[] file = a.list();   
  134.         File temp = null;   
  135.         for (int i = 0; i < file.length; i++)   
  136.         {   
  137.             try  
  138.             {   
  139.                 if (oldPath.endsWith(File.separator))   
  140.                 {   
  141.                     temp = new File(oldPath + file[i]);   
  142.                 }   
  143.                 else  
  144.                 {   
  145.                     temp = new File(oldPath + File.separator + file[i]);   
  146.                 }   
  147.                 if (temp.isFile())   
  148.                 {   
  149.                     input = new FileInputStream(temp);   
  150.                     output = new FileOutputStream(newPath + File.separator   
  151.                             + temp.getName());   
  152.                     byte[] b = new byte[1024 * 5];   
  153.                     int len;   
  154.                     while ((len = input.read(b)) != -1)   
  155.                     {   
  156.                         output.write(b, 0, len);   
  157.                     }   
  158.                 }   
  159.                 // 如果是子文件夹   
  160.                 if (temp.isDirectory())   
  161.                 {   
  162.                     copyFolder(oldPath + File.separator + file[i], newPath   
  163.                             + File.separator + file[i]);   
  164.                 }   
  165.             }   
  166.             catch (Exception e)   
  167.             {   
  168.                 throw e;   
  169.             }   
  170.             finally  
  171.             {   
  172.                 try  
  173.                 {   
  174.                     if (output != null)   
  175.                     {   
  176.                         output.flush();   
  177.                         output.close();   
  178.                         output = null;   
  179.                     }   
  180.                        
  181.                     if (input != null)   
  182.                     {   
  183.                         input.close();   
  184.                         input = null;   
  185.                     }   
  186.                 }   
  187.                 catch (IOException ioe)   
  188.                 {   
  189.                     // do nothing;   
  190.                 }   
  191.   
  192.             }   
  193.         }   
  194.     }   
  195. // catch (Exception e)   
  196. // {   
  197. // throw e;   
  198. // }   
  199. // finally   
  200. // {   
  201. // try   
  202. // {   
  203. // output.flush();   
  204. // output.close();   
  205. // output = null;   
  206. // input.close();   
  207. // input = null;   
  208. // }   
  209. // catch(IOException ioe)   
  210. // {   
  211. // //do nothing;   
  212. // }   
  213. //   
  214. // }   
  215. // }   
  216.        
  217.     /**  
  218.      * 文件打包方法，完成一个ｔａｒ包的创建  
  219.      *   
  220.      * @param tarFile  
  221.      *            ｔａｒ包名  
  222.      * @param subFiles  
  223.      *            打包文件  
  224.      * @throws Exception  
  225.      */  
  226.     public static void tar(String tarFile, String[] subFiles)throws Exception   
  227.     {   
  228.         // 参数为空   
  229.         if (tarFile == null || subFiles == null)   
  230.         {   
  231.             throw new IllegalArgumentException("argument is null!");   
  232.         }   
  233.            
  234.         //压缩包格式不正确   
  235.         if (!tarFile.toLowerCase().endsWith(".tar"))   
  236.         {   
  237.             throw new IllegalArgumentException("must be a tar file!");   
  238.         }   
  239.         String currentPath = System.getProperty("user.dir");   
  240.         String commandPath = currentPath + File.separator + "tar";   
  241.         StringBuffer cmdBuffer = new StringBuffer(commandPath + " -cvf " + tarFile);   
  242.         for (int i = 0; i < subFiles.length; i++)   
  243.         {   
  244.             cmdBuffer.append(" " + subFiles[i]);   
  245.         }   
  246.         Process p = null;   
  247.         try  
  248.         {   
  249.             p = Runtime.getRuntime().exec(cmdBuffer.toString());   
  250.             //压缩文件失败   
  251.             if (p.waitFor() != 0)   
  252.             {   
  253.                 throw new IOException("tar -cvf " + tarFile + " failed!");   
  254.             }   
  255.         }   
  256.         //关闭输入输出流   
  257.         finally  
  258.         {   
  259.             if (p != null)   
  260.             {   
  261.                 p.getErrorStream().close();   
  262.                 p.getInputStream().close();   
  263.                 p.getOutputStream().close();   
  264.             }   
  265.         }   
  266.     }   
  267.     /**  
  268.      * 文件打包方法，完成一个ｔａｒ包的创建  
  269.      *   
  270.      * @param tarFile  
  271.      *            ｔａｒ包名  
  272.      * @param subFiles  
  273.      *            打包文件  
  274.      * @throws Exception  
  275.      */  
  276.     public static void tar(String commandPath, String tarFile, String[] subFiles)   
  277.     throws Exception   
  278.     {   
  279.         if (commandPath == null || tarFile == null || subFiles == null)   
  280.         {   
  281.             throw new IllegalArgumentException("argument is null!");   
  282.         }   
  283.            
  284.         if (!tarFile.toLowerCase().endsWith(".tar"))   
  285.         {   
  286.             throw new IllegalArgumentException("must be a tar file!");   
  287.         }   
  288.         commandPath = commandPath + "/tar";   
  289.         StringBuffer cmdBuffer = new StringBuffer(commandPath + " -cvf " + tarFile);   
  290.         for (int i = 0; i < subFiles.length; i++)   
  291.         {   
  292.             cmdBuffer.append(" " + subFiles[i]);   
  293.         }   
  294.         Process p = null;   
  295.         System.out.println(" command : " + cmdBuffer.toString());   
  296.         try  
  297.         {   
  298.             p = Runtime.getRuntime().exec(cmdBuffer.toString());   
  299.             if (p.waitFor() != 0)   
  300.             {   
  301.                 throw new IOException("tar -cvf " + tarFile + " failed!");   
  302.             }   
  303.         }   
  304.         finally  
  305.         {   
  306.             if (p != null)   
  307.             {   
  308.                 InputStream is = p.getErrorStream();   
  309.                 StringBuffer sb = new StringBuffer();   
  310.                 byte[] buffer = new byte[1024];   
  311.                 while (is.read(buffer, 0, buffer.length) != -1)   
  312.                 {   
  313.                     sb.append(new String(buffer));   
  314.                 }   
  315.                 System.out.println("error message: " + sb.toString());   
  316.                 p.getErrorStream().close();   
  317.                 p.getInputStream().close();   
  318.                 p.getOutputStream().close();   
  319.             }   
  320.         }   
  321.     }   
  322.        
  323.     public static void tar2(String tarFilePath, String baseDirPath)throws Exception   
  324.     {   
  325.         TarUtil tarUtil = new TarUtil();   
  326.         File tarFile = new File(tarFilePath);   
  327.         File baseDir = new File(baseDirPath);   
  328.         tarUtil.setDestFile(tarFile);   
  329.         tarUtil.setBasedir(baseDir);   
  330.         tarUtil.execute(null);   
  331.     }   
  332.        
  333.     /**  
  334.      * 文件解包方法，完成ｔａｒ包的解压  
  335.      * @param tarFile　ｔａｒ包路径  
  336.      * @param storePath 存放路径  
  337.      * @throws Exception  
  338.      * @deprecated replaced by untar2()  
  339.      */  
  340.     public static void untar(String tarFile, String storePath)throws Exception   
  341.     {   
  342.         //参数无效   
  343.         if (tarFile == null || tarFile.trim().length() == 0)   
  344.         {   
  345.             throw new IllegalArgumentException("argument is empty!");   
  346.         }   
  347.            
  348.         //压缩包格式不正确   
  349.         if (!tarFile.toLowerCase().endsWith(".tar"))   
  350.         {   
  351.             throw new IllegalArgumentException("must be a tar file!");   
  352.         }   
  353.         String tarCommand = null;   
  354.         //默认存放路径   
  355.         if (storePath == null || storePath.trim().length() == 0)   
  356.         {   
  357.             tarCommand = "tar -xvf " + tarFile;   
  358.         }   
  359.            
  360.         //制定存放路径   
  361.         else  
  362.         {   
  363.             tarCommand = "tar -C " + storePath + " -xvf " + tarFile;   
  364.         }   
  365.         String path = System.getProperty("java.library.path");   
  366.         System.out.println("path is : " + path);   
  367.         String currentPath = System.getProperty("user.dir");   
  368.         String pathSeparator = System.getProperty("path.separator");   
  369.         System.setProperty("java.library.path", currentPath + pathSeparator + path);   
  370.         String command = tarCommand;   
  371.         Process p = null;   
  372.         try  
  373.         {   
  374.             p = Runtime.getRuntime().exec(command);   
  375.             if (p.waitFor() != 0)   
  376.             {   
  377.                 throw new IOException("tar -xvf " + tarFile + " failed!");   
  378.             }   
  379.         }   
  380.         catch (InterruptedException e)   
  381.         {   
  382.             e.printStackTrace();   
  383.         }   
  384.         //关闭输入输出流   
  385.         finally  
  386.         {   
  387.             if (p != null)   
  388.             {   
  389.                 p.getErrorStream().close(); &n


已有 0 人发表留言，猛击->>这里<<-参与讨论


JavaEye推荐



]]> Sat, 08 Dec 2007 15:22:49 +0800 http://comeon-liming.javaeye.com/blog/146898 http://comeon-liming.javaeye.com/blog/146898 对ｘｍｌ文档操作的常用方法 comeon-liming 作者: comeon-liming  链接：http://comeon-liming.javaeye.com/blog/146896  发表时间: 2007年12月08日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

java 代码
  1.   
  2. import java.io.*;   
  3. import java.util.*;   
  4.   
  5. import javax.xml.XMLConstants;   
  6. import javax.xml.parsers.DocumentBuilder;   
  7. import javax.xml.parsers.DocumentBuilderFactory;   
  8. import javax.xml.transform.Source;   
  9. import javax.xml.transform.dom.DOMSource;   
  10. import javax.xml.transform.stream.StreamSource;   
  11. import javax.xml.validation.Schema;   
  12. import javax.xml.validation.SchemaFactory;   
  13. import javax.xml.validation.Validator;   
  14.   
  15. import org.dom4j.*;   
  16. import org.dom4j.io.*;   
  17. import org.xml.sax.SAXException;   
  18.   
  19. /**  
  20.  * name：XMLUtil.java  
  21.  *   
  22.  * desc: 本类是ｘｍｌ文档操作实用类，提供对ｘｍｌ文档操作的常用方法。  
  23.  *  
  24.  */  
  25.   
  26. public class XMLUtil   
  27. {   
  28.     private Document doc;   
  29.        
  30.     /**  
  31.      * 构造函数  
  32.      *  
  33.      */  
  34.     public XMLUtil()   
  35.     {   
  36.            
  37.     }   
  38.        
  39.     /**  
  40.      * 方法完成xml文件的加载，在调用本类的其他方法前需要调用loadFromFile()或者loadFromString()  
  41.      * @param file xml文件对象  
  42.      * @throws Exception  
  43.      */  
  44.     public void loadFromFile(File file)throws Exception   
  45.     {   
  46.         //参数无效   
  47.         if (file == null || !file.exists() || file.isDirectory())   
  48.         {   
  49.             throw new IllegalArgumentException("xml file is not valid!");   
  50.         }   
  51.         SAXReader saxReader = new SAXReader();   
  52.         doc = saxReader.read(file);   
  53.     }   
  54.        
  55.     /**  
  56.      * 方法完成xml格式字符串的加载，转换成xml文档形式，注意参数必须符合xml格式，  
  57.      * 否则后续操作会出错  
  58.      * @param contents xml格式的字符串  
  59.      * @throws Exception  
  60.      */  
  61.     public void loadFromString(String contents)throws Exception   
  62.     {   
  63.         //参数无效   
  64.         if (contents == null || contents.trim().length() == 0)   
  65.         {   
  66.             throw new IllegalArgumentException("argument is not valid!");   
  67.         }   
  68.         doc = DocumentHelper.parseText(contents);   
  69.     }   
  70.        
  71.     /**  
  72.      * 方法执行xml文档的保存  
  73.      * @param filePath xml文件保存路径  
  74.      * @param encoding xml文件编码格式（gb2312|utf-8|gbk等）  
  75.      * @throws IOException  
  76.      * @throws Exception  
  77.      */  
  78.     public void dump(String filePath, String encoding)throws IOException, Exception   
  79.     {   
  80.         //参数无效   
  81.         if (filePath == null || filePath.trim().length() == 0)   
  82.         {   
  83.             throw new IllegalArgumentException("store path is not valid!");   
  84.         }   
  85.         encoding = (encoding == null || encoding.trim().length() == 0) ? "gb2312" : encoding;   
  86.         OutputFormat format = OutputFormat.createPrettyPrint();   
  87.         format.setEncoding(encoding);   
  88.         format.setIndent("  ");   
  89.         FileWriter fileWriter = new FileWriter(filePath);   
  90.         XMLWriter xmlWriter = new XMLWriter(fileWriter, format);   
  91.         try  
  92.         {   
  93.             xmlWriter.write(doc);   
  94.         }   
  95.         catch(Exception e)   
  96.         {   
  97.             throw e;   
  98.         }   
  99.         finally  
  100.         {   
  101.             xmlWriter.close();   
  102.             xmlWriter = null;   
  103.             fileWriter.close();   
  104.             fileWriter = null;   
  105.         }   
  106.            
  107.     }   
  108.        
  109.        
  110.     /**  
  111.      * 方法获取单个指定节点名的节点  
  112.      * @param name 节点名,支持Xpath  
  113.      * @param index 节点出现的索引位置  
  114.      * @return 找到返回Element,没找到返回null.  
  115.      * @throws Exception  
  116.      */  
  117.     public Element getElement(String name, int index)throws Exception   
  118.     {   
  119.         //节点名无效   
  120.         if (!isValidate(name))   
  121.         {   
  122.             throw new IllegalArgumentException("the element's name is not valid!");   
  123.         }   
  124.            
  125.         //索引位置无效   
  126.         if (index < 0)   
  127.         {   
  128.             throw new IllegalArgumentException("the element's index is not valid!");   
  129.         }   
  130.         List elementsList = doc.selectNodes("//" + name);   
  131.            
  132.         //指定的节点名存在并且索引有效   
  133.         if (elementsList != null && elementsList.size() > index)   
  134.         {   
  135.             return (Element)elementsList.get(index);   
  136.         }   
  137.         return null;   
  138.     }   
  139.        
  140.     /**  
  141.      * 方法获取指定节点名的节点list  
  142.      * @param name 节点名  
  143.      * @return 节点list  
  144.      * @throws Exception  
  145.      */  
  146.     public ArrayList getElements(String name)throws Exception   
  147.     {   
  148.         //节点名无效   
  149.         if (!isValidate(name))   
  150.         {   
  151.             throw new IllegalArgumentException("element name is not valid!");   
  152.         }   
  153.         List list = doc.selectNodes("//" + name);   
  154.         ArrayList <Element>arrayList = new ArrayList<Element>();   
  155.         //存在节点时，循环获取每一个节点   
  156.         if (list != null)   
  157.         {   
  158.             int length = list.size();   
  159.             for (int i = 0; i < length; i++)   
  160.             {   
  161.                 Node node = (Node)list.get(i);   
  162.                    
  163.                 //节点是element实例时，添加到arrayList   
  164.                 if (node instanceof Element)   
  165.                 {   
  166.                     arrayList.add((Element)node);   
  167.                 }   
  168.             }   
  169.         }   
  170.         return arrayList;   
  171.     }   
  172.        
  173.     /**  
  174.      * 方法获取一个节点的子节点信息  
  175.      * @param element 节点  
  176.      * @param subElementName 子节点名称  
  177.      * @return 子节点list，每个list元素是一个Element  
  178.      * @throws Exception  
  179.      */  
  180.     public ArrayList getSubElements(Element element, String subElementName)throws Exception   
  181.     {   
  182.         //参数无效   
  183.         if (element == null)   
  184.         {   
  185.             throw new IllegalArgumentException("element is null!");   
  186.         }   
  187.            
  188.         //参数无效   
  189.         if (!isValidate(subElementName))   
  190.         {   
  191.             throw new IllegalArgumentException("sub element name is invalid!");   
  192.         }   
  193.         return (ArrayList)element.elements(subElementName);   
  194.     }   
  195.        
  196.     /**  
  197.      * 方法获取单个节点值  
  198.      * @param name 节点名  
  199.      * @return 节点值  
  200.      * @throws Exception  
  201.      */  
  202.     public String getElementValue(String name)throws Exception   
  203.     {   
  204.         //invalid argument   
  205.         if (!isValidate(name))   
  206.         {   
  207.             throw new IllegalArgumentException("argument is not valid!");   
  208.         }   
  209.         Node node = doc.selectSingleNode("//" + name);   
  210.            
  211.         //return the value   
  212.         if (node instanceof Element)   
  213.         {   
  214.             return node.getText().trim();   
  215.         }   
  216.         return "";   
  217.     }   
  218.        
  219.        
  220.     /**  
  221.      * 方法获取指定节点名的节点值的properties，重复的节点值将过滤掉  
  222.      * @param name 节点名  
  223.      * @return 节点值properties  
  224.      * @throws Exception  
  225.      */  
  226.     public Properties getElementValues(String name)throws Exception   
  227.     {   
  228.         if (!isValidate(name))   
  229.         {   
  230.             throw new IllegalArgumentException("elememt name is not valid!");   
  231.         }   
  232.         List elementList = doc.selectNodes("//" + name);   
  233.         Properties properties = new Properties();   
  234.         //节点存在   
  235.         if (elementList != null && elementList.size() > 0)   
  236.         {   
  237.                
  238.             int length = elementList.size();   
  239.             for (int i = 0; i < length; i++)   
  240.             {   
  241.                 String elementValue = ((Element)elementList.get(i)).getTextTrim();    
  242.                 properties.put(elementValue, elementValue);   
  243.             }   
  244.             return properties;   
  245.         }   
  246.         return properties;   
  247.     }   
  248.        
  249.     /**  
  250.      * 方法返回指定节点的属性信息  
  251.      * @param element 节点  
  252.      * @return 以name,value形式存在的属性  
  253.      * @throws Exception  
  254.      */  
  255.     public Properties getElementProperties(Element element)throws Exception   
  256.     {   
  257.         //参数无效   
  258.         if (element == null)   
  259.         {   
  260.             throw new IllegalArgumentException("element is null!");   
  261.         }   
  262.         List attributes = element.attributes();   
  263.         Properties properties = new Properties();   
  264.         for (int i = 0; i < attributes.size(); i++)   
  265.         {   
  266.             Attribute attr = (Attribute)attributes.get(i);   
  267.             properties.put(attr.getName(), attr.getValue());   
  268.         }   
  269.         return properties;   
  270.     }   
  271.        
  272.     /**  
  273.      * 方法返回节点的属性信息  
  274.      * @param elementName 节点名称  
  275.      * @return 以name,value形式存在的属性  
  276.      * @throws Exception  
  277.      */  
  278.     public Properties getElementProperties(String elementName)throws Exception   
  279.     {   
  280.         //参数无效   
  281.         if (!isValidate(elementName))   
  282.         {   
  283.             throw new IllegalArgumentException("element name is invalid!");   
  284.         }   
  285.         return this.getElementProperties(this.getElement(elementName, 0));   
  286.     }   
  287.        
  288.     /**  
  289.      * 方法执行节点名的更改  
  290.      * @param oldName 原始节点名  
  291.      * @param newName 更改后节点名  
  292.      * @param index 要更改的节点索引（索引指在xml文件中节点出现的位置）  
  293.      * @throws Exception  
  294.      */  
  295.     public void renameElement(String oldName, String newName, int index)throws Exception   
  296.     {   
  297.         //原始节点名无效   
  298.         if (!isValidate(oldName))   
  299.         {   
  300.             throw new IllegalArgumentException("original element name is not valid!");   
  301.         }   
  302.            
  303.         //新的节点名无效   
  304.         if (!isValidate(newName))   
  305.         {   
  306.             throw new IllegalArgumentException("new element name is not valid!");   
  307.         }   
  308.         Element element = getElement(oldName, index);   
  309.         //指定的节点不存在   
  310.         if (element == null)   
  311.         {   
  312.             throw new Exception("can not find element, which name is : " + oldName   
  313.                                   + " index is : " + index);   
  314.                
  315.         }   
  316.         element.setName(newName);   
  317.     }   
  318.        
  319.     /**  
  320.      * 方法执行节点名的更改  
  321.      * @param oldName 原始节点名  
  322.      * @param newName 更改后节点名  
  323.      * @throws Exception  
  324.      */  
  325.     public void renameElements(String oldName, String newName)throws Exception   
  326.     {   
  327.         //原始节点名无效   
  328.         if (!isValidate(oldName))   
  329.         {   
  330.             throw new IllegalArgumentException("original element name is not valid!");   
  331.         }   
  332.            
  333.         //新的节点名无效   
  334.         if (!isValidate(newName))   
  335.         {   
  336.             throw new IllegalArgumentException("new element name is not valid!");   
  337.         }   
  338.         ArrayList list = getElements(oldName);   
  339.            
  340.         //不存在该节点名   
  341.         if (list == null)   
  342.         {   
  343.             throw new Exception("can not find any element, which name is : " + oldName);   
  344.         }   
  345.            
  346.         //循环更改节点名   
  347.         int length = list.size();   
  348.         for (int i = 0; i < length; i++)   
  349.         {   
  350.             ((Element)list.get(i)).setName(newName);   
  351.         }   
  352.     }   
  353.        
  354.     /**  
  355.      * 方法执行子节点的添加，要添加的子节点必须存在父节点，添加子节点的属性可以为空。  
  356.      * @param parent 父节点名  
  357.      * @param index 父节点的索引（存在同名父节点时，在第index个父节点处添加子节点）  
  358.      * @param current 子节点名  
  359.      * @param currentValue 子节点值  
  360.      * @param attributes 子节点属性  
  361.      * @throws Exception  
  362.      */  
  363.     public void addSubElement(String parent, int index, String current, String currentValue,    
  364.                                 Properties attributes)throws Exception   
  365.     {   
  366.         //父节点无效   
  367.         if (!isValidate(parent))   
  368.         {   
  369.             throw new IllegalArgumentException("parent element is not valid!");   
  370.         }   
  371.            
  372.         //当前节点无效   
  373.         if (!isValidate(current))   
  374.         {   
  375.             throw new IllegalArgumentException("current element is not valid!");   
  376.         }   
  377.            
  378.         Element parentElement = getElement(parent, index);   
  379.            
  380.         //指定的父节点不存在   
  381.         if (parentElement == null)   
  382.         {   
  383.             throw new Exception("can not find the specified parent element, which name is :"  
  384.                                  + parent);   
  385.         }   
  386.         Element currentElement = parentElement.addElement(current);   
  387.            
  388.         //节点值有效   
  389.         if (currentValue != null && currentValue.length() > 0)   
  390.         {   
  391.             currentElement.setText(currentValue);   
  392.         }   
  393.            
  394.         //存在属性时，添加节点属性   
  395.         if (attributes != null)   
  396.         {   
  397.             Enumeration e = attributes.keys();   
  398.             while (e.hasMoreElements())   
  399.             {   
  400.                 Object attrName = e.nextElement();   
  401.