FileUtils---FileUtils介绍

1. [java] view plain copy print ?

   1. import org.apache.commons.io.FileUtils;   
   2. import org.apache.commons.io.filefilter.*;   
   3. import org.apache.commons.logging.Log;   
   4. import org.apache.commons.logging.LogFactory;  
   5.   
   6. import java.io.*;  
   7.   
   8. /**  
   9. * 文件工具箱  
   10. *  
   11. * @author leizhimin 2008-12-15 13:59:16  
   12. */   
   13. public final class FileToolkit {   
   14.         private static final Log log = LogFactory.getLog(FileToolkit.class);  
   15.   
   16.         /**  
   17.          * 复制文件或者目录,复制前后文件完全一样。  
   18.          *  
   19.          * @param resFilePath 源文件路径  
   20.          * @param distFolder    目标文件夹  
   21.          * @IOException 当操作发生异常时抛出  
   22.          */   
   23.         public static void copyFile(String resFilePath, String distFolder) throws IOException {   
   24.                 File resFile = new File(resFilePath);   
   25.                 File distFile = new File(distFolder);   
   26.                 if (resFile.isDirectory()) {   
   27.                         FileUtils.copyDirectoryToDirectory(resFile, distFile);   
   28.                 } else if (resFile.isFile()) {   
   29.                         FileUtils.copyFileToDirectory(resFile, distFile, true);   
   30.                 }   
   31.         }  
   32.   
   33.         /**  
   34.          * 删除一个文件或者目录  
   35.          *  
   36.          * @param targetPath 文件或者目录路径  
   37.          * @IOException 当操作发生异常时抛出  
   38.          */   
   39.         public static void deleteFile(String targetPath) throws IOException {   
   40.                 File targetFile = new File(targetPath);   
   41.                 if (targetFile.isDirectory()) {   
   42.                         FileUtils.deleteDirectory(targetFile);   
   43.                 } else if (targetFile.isFile()) {   
   44.                         targetFile.delete();   
   45.                 }   
   46.         }  
   47.   
   48.         /**  
   49.          * 移动文件或者目录,移动前后文件完全一样,如果目标文件夹不存在则创建。  
   50.          *  
   51.          * @param resFilePath 源文件路径  
   52.          * @param distFolder    目标文件夹  
   53.          * @IOException 当操作发生异常时抛出  
   54.          */   
   55.         public static void moveFile(String resFilePath, String distFolder) throws IOException {   
   56.                 File resFile = new File(resFilePath);   
   57.                 File distFile = new File(distFolder);   
   58.                 if (resFile.isDirectory()) {   
   59.                         FileUtils.moveDirectoryToDirectory(resFile, distFile, true);   
   60.                 } else if (resFile.isFile()) {   
   61.                         FileUtils.moveFileToDirectory(resFile, distFile, true);   
   62.                 }   
   63.         }  
   64.   
   65.   
   66.         /**  
   67.          * 重命名文件或文件夹  
   68.          *  
   69.          * @param resFilePath 源文件路径  
   70.          * @param newFileName 重命名  
   71.          * @return 操作成功标识  
   72.          */   
   73.         public static boolean renameFile(String resFilePath, String newFileName) {   
   74.                 String newFilePath = StringToolkit.formatPath(StringToolkit.getParentPath(resFilePath) + "/" + newFileName);   
   75.                 File resFile = new File(resFilePath);   
   76.                 File newFile = new File(newFilePath);   
   77.                 return resFile.renameTo(newFile);   
   78.         }  
   79.   
   80.         /**  
   81.          * 读取文件或者目录的大小  
   82.          *  
   83.          * @param distFilePath 目标文件或者文件夹  
   84.          * @return 文件或者目录的大小，如果获取失败，则返回-1  
   85.          */   
   86.         public static long genFileSize(String distFilePath) {   
   87.                 File distFile = new File(distFilePath);   
   88.                 if (distFile.isFile()) {   
   89.                         return distFile.length();   
   90.                 } else if (distFile.isDirectory()) {   
   91.                         return FileUtils.sizeOfDirectory(distFile);   
   92.                 }   
   93.                 return -1L;   
   94.         }  
   95.   
   96.         /**  
   97.          * 判断一个文件是否存在  
   98.          *  
   99.          * @param filePath 文件路径  
   100.          * @return 存在返回true，否则返回false  
   101.          */   
   102.         public static boolean isExist(String filePath) {   
   103.                 return new File(filePath).exists();   
   104.         }  
   105.   
   106.         /**  
   107.          * 本地某个目录下的文件列表（不递归）  
   108.          *  
   109.          * @param folder ftp上的某个目录  
   110.          * @param suffix 文件的后缀名（比如.mov.xml)  
   111.          * @return 文件名称列表  
   112.          */   
   113.         public static String[] listFilebySuffix(String folder, String suffix) {   
   114.                 IOFileFilter fileFilter1 = new SuffixFileFilter(suffix);   
   115.                 IOFileFilter fileFilter2 = new NotFileFilter(DirectoryFileFilter.INSTANCE);   
   116.                 FilenameFilter filenameFilter = new AndFileFilter(fileFilter1, fileFilter2);   
   117.                 return new File(folder).list(filenameFilter);   
   118.         }  
   119.   
   120.         /**  
   121.          * 将字符串写入指定文件(当指定的父路径中文件夹不存在时，会最大限度去创建，以保证保存成功！)  
   122.          *  
   123.          * @param res            原字符串  
   124.          * @param filePath 文件路径  
   125.          * @return 成功标记  
   126.          */   
   127.         public static boolean string2File(String res, String filePath) {   
   128.                 boolean flag = true;   
   129.                 BufferedReader bufferedReader = null;   
   130.                 BufferedWriter bufferedWriter = null;   
   131.                 try {   
   132.                         File distFile = new File(filePath);   
   133.                         if (!distFile.getParentFile().exists()) distFile.getParentFile().mkdirs();   
   134.                         bufferedReader = new BufferedReader(new StringReader(res));   
   135.                         bufferedWriter = new BufferedWriter(new FileWriter(distFile));   
   136.                         char buf[] = new char[1024];         //字符缓冲区   
   137.                         int len;   
   138.                         while ((len = bufferedReader.read(buf)) != -1) {   
   139.                                 bufferedWriter.write(buf, 0, len);   
   140.                         }   
   141.                         bufferedWriter.flush();   
   142.                         bufferedReader.close();   
   143.                         bufferedWriter.close();   
   144.                 } catch (IOException e) {   
   145.                         flag = false;   
   146.                         e.printStackTrace();   
   147.                 }   
   148.                 return flag;   
   149.         }   
   150. }   
   151. -------------------------------------------------------------------------------------------------------------  
   152. import java.io.File;  
   153. import java.util.ArrayList;  
   154. import java.util.List;  
   155. import java.util.Properties;  
   156.   
   157.   
   158. /** 
   159. * 字符串工具箱 
   160. * 
   161. * @author leizhimin 2008-12-15 22:40:12 
   162. */  
   163. public final class StringToolkit {  
   164.   /** 
   165.   * 将一个字符串的首字母改为大写或者小写 
   166.   * 
   167.   * @param srcString 源字符串 
   168.   * @param flag     大小写标识，ture小写，false大些 
   169.   * @return 改写后的新字符串 
   170.   */  
   171.   public static String toLowerCaseInitial(String srcString, boolean flag) {  
   172.     StringBuilder sb = new StringBuilder();  
   173.     if (flag) {  
   174.         sb.append(Character.toLowerCase(srcString.charAt(0)));  
   175.     } else {  
   176.         sb.append(Character.toUpperCase(srcString.charAt(0)));  
   177.     }  
   178.     sb.append(srcString.substring(1));  
   179.     return sb.toString();  
   180.   }  
   181.   
   182.   /** 
   183.   * 将一个字符串按照句点（.）分隔，返回最后一段 
   184.   * 
   185.   * @param clazzName 源字符串 
   186.   * @return 句点（.）分隔后的最后一段字符串 
   187.   */  
   188.   public static String getLastName(String clazzName) {  
   189.     String[] ls = clazzName.split("\\.");  
   190.     return ls[ls.length - 1];  
   191.   }  
   192.   
   193.   /** 
   194.   * 格式化文件路径，将其中不规范的分隔转换为标准的分隔符,并且去掉末尾的"/"符号。 
   195.   * 
   196.   * @param path 文件路径 
   197.   * @return 格式化后的文件路径 
   198.   */  
   199.   public static String formatPath(String path) {  
   200.     String reg0 = "\\\\＋";  
   201.     String reg = "\\\\＋|/＋";  
   202.     String temp = path.trim().replaceAll(reg0, "/");  
   203.     temp = temp.replaceAll(reg, "/");  
   204.     if (temp.endsWith("/")) {  
   205.         temp = temp.substring(0, temp.length() - 1);  
   206.     }  
   207.     if (System.getProperty("file.separator").equals("\\")) {  
   208.       temp= temp.replace('/','\\');  
   209.     }  
   210.     return temp;  
   211.   }  
   212.   
   213.   /** 
   214.   * 格式化文件路径，将其中不规范的分隔转换为标准的分隔符,并且去掉末尾的"/"符号(适用于FTP远程文件路径或者Web资源的相对路径)。 
   215.   * 
   216.   * @param path 文件路径 
   217.   * @return 格式化后的文件路径 
   218.   */  
   219.   public static String formatPath4Ftp(String path) {  
   220.     String reg0 = "\\\\＋";  
   221.     String reg = "\\\\＋|/＋";  
   222.     String temp = path.trim().replaceAll(reg0, "/");  
   223.     temp = temp.replaceAll(reg, "/");  
   224.     if (temp.endsWith("/")) {  
   225.         temp = temp.substring(0, temp.length() - 1);  
   226.     }  
   227.     return temp;  
   228.   }  
   229.   
   230.   public static void main(String[] args) {  
   231.     System.out.println(System.getProperty("file.separator"));  
   232.     Properties p = System.getProperties();  
   233.     System.out.println(formatPath("C:///\\xxxx\\\\\\\\\\///\\\\R5555555.txt"));  
   234.   
   235. //     List<String> result = series2List("asdf | sdf|siii|sapp|aaat| ", "\\|");  
   236. //     System.out.println(result.size());   
   237. //     for (String s : result) {  
   238. //         System.out.println(s);   
   239. //     }   
   240.   }  
   241.   
   242.   /** 
   243.   * 获取文件父路径 
   244.   * 
   245.   * @param path 文件路径 
   246.   * @return 文件父路径 
   247.   */  
   248.   public static String getParentPath(String path) {  
   249.     return new File(path).getParent();  
   250.   }  
   251.   
   252.   /** 
   253.   * 获取相对路径 
   254.   * 
   255.   * @param fullPath 全路径 
   256.   * @param rootPath 根路径 
   257.   * @return 相对根路径的相对路径 
   258.   */  
   259.   public static String getRelativeRootPath(String fullPath, String rootPath) {  
   260.     String relativeRootPath = null;  
   261.     String _fullPath = formatPath(fullPath);  
   262.     String _rootPath = formatPath(rootPath);  
   263.   
   264.     if (_fullPath.startsWith(_rootPath)) {  
   265.         relativeRootPath = fullPath.substring(_rootPath.length());  
   266.     } else {  
   267.         throw new RuntimeException("要处理的两个字符串没有包含关系，处理失败！");  
   268.     }  
   269.     if (relativeRootPath == null) return null;  
   270.     else  
   271.         return formatPath(relativeRootPath);  
   272.   }  
   273.   
   274.   /** 
   275.   * 获取当前系统换行符 
   276.   * 
   277.   * @return 系统换行符 
   278.   */  
   279.   public static String getSystemLineSeparator() {  
   280.     return System.getProperty("line.separator");  
   281.   }  
   282.   
   283.   /** 
   284.   * 将用“|”分隔的字符串转换为字符串集合列表，剔除分隔后各个字符串前后的空格 
   285.   * 
   286.   * @param series 将用“|”分隔的字符串 
   287.   * @return 字符串集合列表 
   288.   */  
   289.   public static List<String> series2List(String series) {  
   290.     return series2List(series, "\\|");  
   291.   }  
   292.   
   293.   /** 
   294.   * 将用正则表达式regex分隔的字符串转换为字符串集合列表，剔除分隔后各个字符串前后的空格 
   295.   * 
   296.   * @param series 用正则表达式分隔的字符串 
   297.   * @param regex 分隔串联串的正则表达式 
   298.   * @return 字符串集合列表 
   299.   */  
   300.   private static List<String> series2List(String series, String regex) {  
   301.     List<String> result = new ArrayList<String>();  
   302.     if (series != null && regex != null) {  
   303.         for (String s : series.split(regex)) {  
   304.           if (s.trim() != null && !s.trim().equals("")) result.add(s.trim());  
   305.         }  
   306.     }  
   307.     return result;  
   308.   }  
   309.   
   310.   /** 
   311.   * @param strList 字符串集合列表 
   312.   * @return 通过“|”串联为一个字符串 
   313.   */  
   314.   public static String list2series(List<String> strList) {  
   315.     StringBuffer series = new StringBuffer();  
   316.     for (String s : strList) {  
   317.         series.append(s).append("|");  
   318.     }  
   319.     return series.toString();  
   320.   }  
   321.   
   322.   /** 
   323.   * 将字符串的首字母转为小写 
   324.   * 
   325.   * @param resStr 源字符串 
   326.   * @return 首字母转为小写后的字符串 
   327.   */  
   328.   public static String firstToLowerCase(String resStr) {  
   329.     if (resStr == null) {  
   330.         return null;  
   331.     } else if ("".equals(resStr.trim())) {  
   332.         return "";  
   333.     } else {  
   334.         StringBuffer sb = new StringBuffer();  
   335.         Character c = resStr.charAt(0);  
   336.         if (Character.isLetter(c)) {  
   337.           if (Character.isUpperCase(c))  
   338.             c = Character.toLowerCase(c);  
   339.           sb.append(resStr);  
   340.           sb.setCharAt(0, c);  
   341.           return sb.toString();  
   342.         }  
   343.     }  
   344.     return resStr;  
   345.   }  
   346.   
   347.   /** 
   348.   * 将字符串的首字母转为大写 
   349.   * 
   350.   * @param resStr 源字符串 
   351.   * @return 首字母转为大写后的字符串 
   352.   */  
   353.   public static String firstToUpperCase(String resStr) {  
   354.     if (resStr == null) {  
   355.         return null;  
   356.     } else if ("".equals(resStr.trim())) {  
   357.         return "";  
   358.     } else {  
   359.         StringBuffer sb = new StringBuffer();  
   360.         Character c = resStr.charAt(0);  
   361.         if (Character.isLetter(c)) {  
   362.           if (Character.isLowerCase(c))  
   363.             c = Character.toUpperCase(c);  
   364.           sb.append(resStr);  
   365.           sb.setCharAt(0, c);  
   366.           return sb.toString();  
   367.         }  
   368.     }  
   369.     return resStr;  
   370.   }  
   371.   
   372. }  

   import org.apache.commons.io.FileUtils; 
   import org.apache.commons.io.filefilter.*; 
   import org.apache.commons.logging.Log; 
   import org.apache.commons.logging.LogFactory;
   
   import java.io.*;
   
   /** 
   * 文件工具箱 
   * 
   * @author leizhimin 2008-12-15 13:59:16 
   */ 
   public final class FileToolkit { 
           private static final Log log = LogFactory.getLog(FileToolkit.class);
   
           /** 
            * 复制文件或者目录,复制前后文件完全一样。 
            * 
            * @param resFilePath 源文件路径 
            * @param distFolder    目标文件夹 
            * @IOException 当操作发生异常时抛出 
            */ 
           public static void copyFile(String resFilePath, String distFolder) throws IOException { 
                   File resFile = new File(resFilePath); 
                   File distFile = new File(distFolder); 
                   if (resFile.isDirectory()) { 
                           FileUtils.copyDirectoryToDirectory(resFile, distFile); 
                   } else if (resFile.isFile()) { 
                           FileUtils.copyFileToDirectory(resFile, distFile, true); 
                   } 
           }
   
           /** 
            * 删除一个文件或者目录 
            * 
            * @param targetPath 文件或者目录路径 
            * @IOException 当操作发生异常时抛出 
            */ 
           public static void deleteFile(String targetPath) throws IOException { 
                   File targetFile = new File(targetPath); 
                   if (targetFile.isDirectory()) { 
                           FileUtils.deleteDirectory(targetFile); 
                   } else if (targetFile.isFile()) { 
                           targetFile.delete(); 
                   } 
           }
   
           /** 
            * 移动文件或者目录,移动前后文件完全一样,如果目标文件夹不存在则创建。 
            * 
            * @param resFilePath 源文件路径 
            * @param distFolder    目标文件夹 
            * @IOException 当操作发生异常时抛出 
            */ 
           public static void moveFile(String resFilePath, String distFolder) throws IOException { 
                   File resFile = new File(resFilePath); 
                   File distFile = new File(distFolder); 
                   if (resFile.isDirectory()) { 
                           FileUtils.moveDirectoryToDirectory(resFile, distFile, true); 
                   } else if (resFile.isFile()) { 
                           FileUtils.moveFileToDirectory(resFile, distFile, true); 
                   } 
           }
   
   
           /** 
            * 重命名文件或文件夹 
            * 
            * @param resFilePath 源文件路径 
            * @param newFileName 重命名 
            * @return 操作成功标识 
            */ 
           public static boolean renameFile(String resFilePath, String newFileName) { 
                   String newFilePath = StringToolkit.formatPath(StringToolkit.getParentPath(resFilePath) + "/" + newFileName); 
                   File resFile = new File(resFilePath); 
                   File newFile = new File(newFilePath); 
                   return resFile.renameTo(newFile); 
           }
   
           /** 
            * 读取文件或者目录的大小 
            * 
            * @param distFilePath 目标文件或者文件夹 
            * @return 文件或者目录的大小，如果获取失败，则返回-1 
            */ 
           public static long genFileSize(String distFilePath) { 
                   File distFile = new File(distFilePath); 
                   if (distFile.isFile()) { 
                           return distFile.length(); 
                   } else if (distFile.isDirectory()) { 
                           return FileUtils.sizeOfDirectory(distFile); 
                   } 
                   return -1L; 
           }
   
           /** 
            * 判断一个文件是否存在 
            * 
            * @param filePath 文件路径 
            * @return 存在返回true，否则返回false 
            */ 
           public static boolean isExist(String filePath) { 
                   return new File(filePath).exists(); 
           }
   
           /** 
            * 本地某个目录下的文件列表（不递归） 
            * 
            * @param folder ftp上的某个目录 
            * @param suffix 文件的后缀名（比如.mov.xml) 
            * @return 文件名称列表 
            */ 
           public static String[] listFilebySuffix(String folder, String suffix) { 
                   IOFileFilter fileFilter1 = new SuffixFileFilter(suffix); 
                   IOFileFilter fileFilter2 = new NotFileFilter(DirectoryFileFilter.INSTANCE); 
                   FilenameFilter filenameFilter = new AndFileFilter(fileFilter1, fileFilter2); 
                   return new File(folder).list(filenameFilter); 
           }
   
           /** 
            * 将字符串写入指定文件(当指定的父路径中文件夹不存在时，会最大限度去创建，以保证保存成功！) 
            * 
            * @param res            原字符串 
            * @param filePath 文件路径 
            * @return 成功标记 
            */ 
           public static boolean string2File(String res, String filePath) { 
                   boolean flag = true; 
                   BufferedReader bufferedReader = null; 
                   BufferedWriter bufferedWriter = null; 
                   try { 
                           File distFile = new File(filePath); 
                           if (!distFile.getParentFile().exists()) distFile.getParentFile().mkdirs(); 
                           bufferedReader = new BufferedReader(new StringReader(res)); 
                           bufferedWriter = new BufferedWriter(new FileWriter(distFile)); 
                           char buf[] = new char[1024];         //字符缓冲区 
                           int len; 
                           while ((len = bufferedReader.read(buf)) != -1) { 
                                   bufferedWriter.write(buf, 0, len); 
                           } 
                           bufferedWriter.flush(); 
                           bufferedReader.close(); 
                           bufferedWriter.close(); 
                   } catch (IOException e) { 
                           flag = false; 
                           e.printStackTrace(); 
                   } 
                   return flag; 
           } 
   } 
   -------------------------------------------------------------------------------------------------------------
   import java.io.File;
   import java.util.ArrayList;
   import java.util.List;
   import java.util.Properties;
   
   
   /**
   * 字符串工具箱
   *
   * @author leizhimin 2008-12-15 22:40:12
   */
   public final class StringToolkit {
     /**
     * 将一个字符串的首字母改为大写或者小写
     *
     * @param srcString 源字符串
     * @param flag     大小写标识，ture小写，false大些
     * @return 改写后的新字符串
     */
     public static String toLowerCaseInitial(String srcString, boolean flag) {
       StringBuilder sb = new StringBuilder();
       if (flag) {
           sb.append(Character.toLowerCase(srcString.charAt(0)));
       } else {
           sb.append(Character.toUpperCase(srcString.charAt(0)));
       }
       sb.append(srcString.substring(1));
       return sb.toString();
     }
   
     /**
     * 将一个字符串按照句点（.）分隔，返回最后一段
     *
     * @param clazzName 源字符串
     * @return 句点（.）分隔后的最后一段字符串
     */
     public static String getLastName(String clazzName) {
       String[] ls = clazzName.split("\\.");
       return ls[ls.length - 1];
     }
   
     /**
     * 格式化文件路径，将其中不规范的分隔转换为标准的分隔符,并且去掉末尾的"/"符号。
     *
     * @param path 文件路径
     * @return 格式化后的文件路径
     */
     public static String formatPath(String path) {
       String reg0 = "\\\\＋";
       String reg = "\\\\＋|/＋";
       String temp = path.trim().replaceAll(reg0, "/");
       temp = temp.replaceAll(reg, "/");
       if (temp.endsWith("/")) {
           temp = temp.substring(0, temp.length() - 1);
       }
       if (System.getProperty("file.separator").equals("\\")) {
         temp= temp.replace('/','\\');
       }
       return temp;
     }
   
     /**
     * 格式化文件路径，将其中不规范的分隔转换为标准的分隔符,并且去掉末尾的"/"符号(适用于FTP远程文件路径或者Web资源的相对路径)。
     *
     * @param path 文件路径
     * @return 格式化后的文件路径
     */
     public static String formatPath4Ftp(String path) {
       String reg0 = "\\\\＋";
       String reg = "\\\\＋|/＋";
       String temp = path.trim().replaceAll(reg0, "/");
       temp = temp.replaceAll(reg, "/");
       if (temp.endsWith("/")) {
           temp = temp.substring(0, temp.length() - 1);
       }
       return temp;
     }
   
     public static void main(String[] args) {
       System.out.println(System.getProperty("file.separator"));
       Properties p = System.getProperties();
       System.out.println(formatPath("C:///\\xxxx\\\\\\\\\\///\\\\R5555555.txt"));
   
   //     List<String> result = series2List("asdf | sdf|siii|sapp|aaat| ", "\\|");
   //     System.out.println(result.size());
   //     for (String s : result) {
   //         System.out.println(s);
   //     }
     }
   
     /**
     * 获取文件父路径
     *
     * @param path 文件路径
     * @return 文件父路径
     */
     public static String getParentPath(String path) {
       return new File(path).getParent();
     }
   
     /**
     * 获取相对路径
     *
     * @param fullPath 全路径
     * @param rootPath 根路径
     * @return 相对根路径的相对路径
     */
     public static String getRelativeRootPath(String fullPath, String rootPath) {
       String relativeRootPath = null;
       String _fullPath = formatPath(fullPath);
       String _rootPath = formatPath(rootPath);
   
       if (_fullPath.startsWith(_rootPath)) {
           relativeRootPath = fullPath.substring(_rootPath.length());
       } else {
           throw new RuntimeException("要处理的两个字符串没有包含关系，处理失败！");
       }
       if (relativeRootPath == null) return null;
       else
           return formatPath(relativeRootPath);
     }
   
     /**
     * 获取当前系统换行符
     *
     * @return 系统换行符
     */
     public static String getSystemLineSeparator() {
       return System.getProperty("line.separator");
     }
   
     /**
     * 将用“|”分隔的字符串转换为字符串集合列表，剔除分隔后各个字符串前后的空格
     *
     * @param series 将用“|”分隔的字符串
     * @return 字符串集合列表
     */
     public static List<String> series2List(String series) {
       return series2List(series, "\\|");
     }
   
     /**
     * 将用正则表达式regex分隔的字符串转换为字符串集合列表，剔除分隔后各个字符串前后的空格
     *
     * @param series 用正则表达式分隔的字符串
     * @param regex 分隔串联串的正则表达式
     * @return 字符串集合列表
     */
     private static List<String> series2List(String series, String regex) {
       List<String> result = new ArrayList<String>();
       if (series != null && regex != null) {
           for (String s : series.split(regex)) {
             if (s.trim() != null && !s.trim().equals("")) result.add(s.trim());
           }
       }
       return result;
     }
   
     /**
     * @param strList 字符串集合列表
     * @return 通过“|”串联为一个字符串
     */
     public static String list2series(List<String> strList) {
       StringBuffer series = new StringBuffer();
       for (String s : strList) {
           series.append(s).append("|");
       }
       return series.toString();
     }
   
     /**
     * 将字符串的首字母转为小写
     *
     * @param resStr 源字符串
     * @return 首字母转为小写后的字符串
     */
     public static String firstToLowerCase(String resStr) {
       if (resStr == null) {
           return null;
       } else if ("".equals(resStr.trim())) {
           return "";
       } else {
           StringBuffer sb = new StringBuffer();
           Character c = resStr.charAt(0);
           if (Character.isLetter(c)) {
             if (Character.isUpperCase(c))
               c = Character.toLowerCase(c);
             sb.append(resStr);
             sb.setCharAt(0, c);
             return sb.toString();
           }
       }
       return resStr;
     }
   
     /**
     * 将字符串的首字母转为大写
     *
     * @param resStr 源字符串
     * @return 首字母转为大写后的字符串
     */
     public static String firstToUpperCase(String resStr) {
       if (resStr == null) {
           return null;
       } else if ("".equals(resStr.trim())) {
           return "";
       } else {
           StringBuffer sb = new StringBuffer();
           Character c = resStr.charAt(0);
           if (Character.isLetter(c)) {
             if (Character.isLowerCase(c))
               c = Character.toUpperCase(c);
             sb.append(resStr);
             sb.setCharAt(0, c);
             return sb.toString();
           }
       }
       return resStr;
     }
   
   }
   

   
   Java的文件操作太基础，缺乏很多实用工具，比如对目录的操作，支持就非常的差了。如果你经常用Java操作文件或文件夹，你会觉得反复编写这些代码是令人沮丧的问题，而且要大量用到递归。

       下面是的一个解决方案，借助Apache Commons IO工具包（commons-io-1.1.jar）来简单实现文件（夹）的复制、移动、删除、获取大小等操作。