FileUtil

  1 package com.gootrip.util;
  2 
  3 import java.io.BufferedReader;
  4 import java.io.File;
  5 import java.io.FileInputStream;
  6 import java.io.FileOutputStream;
  7 import java.io.FileReader;
  8 import java.io.FileWriter;
  9 import java.io.FilenameFilter;
 10 import java.io.IOException;
 11 import java.net.MalformedURLException;
 12 import java.net.URL;
 13 import java.util.ArrayList;
 14 import java.util.Enumeration;
 15 import java.util.Hashtable;
 16 
 17 import javax.swing.filechooser.FileFilter;
 18 
 19 /**
 20  * 此类中封装一些常用的文件操作。
 21  * 所有方法都是静态方法，不需要生成此类的实例，
 22  * 为避免生成此类的实例，构造方法被申明为private类型的。
 23  * @since  1.0
 24  */
 25 
 26 public class FileUtil {
 27   /**
 28    * 私有构造方法，防止类的实例化，因为工具类不需要实例化。
 29    */
 30   private FileUtil() {
 31 
 32   }
 33 
 34   /**
 35    * 修改文件的最后访问时间。
 36    * 如果文件不存在则创建该文件。
 37    * <b>目前这个方法的行为方式还不稳定，主要是方法有些信息输出，这些信息输出是否保留还在考虑中。</b>
 38    * @param file 需要修改最后访问时间的文件。
 39    * @since  1.0
 40    */
 41   public static void touch(File file) {
 42     long currentTime = System.currentTimeMillis();
 43     if (!file.exists()) {
 44       System.err.println("file not found:" + file.getName());
 45       System.err.println("Create a new file:" + file.getName());
 46       try {
 47         if (file.createNewFile()) {
 48           System.out.println("Succeeded!");
 49         }
 50         else {
 51           System.err.println("Create file failed!");
 52         }
 53       }
 54       catch (IOException e) {
 55         System.err.println("Create file failed!");
 56         e.printStackTrace();
 57       }
 58     }
 59     boolean result = file.setLastModified(currentTime);
 60     if (!result) {
 61       System.err.println("touch failed: " + file.getName());
 62     }
 63   }
 64 
 65   /**
 66    * 修改文件的最后访问时间。
 67    * 如果文件不存在则创建该文件。
 68    * <b>目前这个方法的行为方式还不稳定，主要是方法有些信息输出，这些信息输出是否保留还在考虑中。</b>
 69    * @param fileName 需要修改最后访问时间的文件的文件名。
 70    * @since  1.0
 71    */
 72   public static void touch(String fileName) {
 73     File file = new File(fileName);
 74     touch(file);
 75   }
 76 
 77   /**
 78    * 修改文件的最后访问时间。
 79    * 如果文件不存在则创建该文件。
 80    * <b>目前这个方法的行为方式还不稳定，主要是方法有些信息输出，这些信息输出是否保留还在考虑中。</b>
 81    * @param files 需要修改最后访问时间的文件数组。
 82    * @since  1.0
 83    */
 84   public static void touch(File[] files) {
 85     for (int i = 0; i < files.length; i++) {
 86       touch(files[i]);
 87     }
 88   }
 89 
 90   /**
 91    * 修改文件的最后访问时间。
 92    * 如果文件不存在则创建该文件。
 93    * <b>目前这个方法的行为方式还不稳定，主要是方法有些信息输出，这些信息输出是否保留还在考虑中。</b>
 94    * @param fileNames 需要修改最后访问时间的文件名数组。
 95    * @since  1.0
 96    */
 97   public static void touch(String[] fileNames) {
 98     File[] files = new File[fileNames.length];
 99     for (int i = 0; i < fileNames.length; i++) {
100       files[i] = new File(fileNames[i]);
101     }
102     touch(files);
103   }
104 
105   /**
106    * 判断指定的文件是否存在。
107    * @param fileName 要判断的文件的文件名
108    * @return 存在时返回true，否则返回false。
109    * @since  1.0
110    */
111   public static boolean isFileExist(String fileName) {
112     return new File(fileName).isFile();
113   }
114 
115   /**
116    * 创建指定的目录。
117    * 如果指定的目录的父目录不存在则创建其目录书上所有需要的父目录。
118    * <b>注意：可能会在返回false的时候创建部分父目录。</b>
119    * @param file 要创建的目录
120    * @return 完全创建成功时返回true，否则返回false。
121    * @since  1.0
122    */
123   public static boolean makeDirectory(File file) {
124     File parent = file.getParentFile();
125     if (parent != null) {
126       return parent.mkdirs();
127     }
128     return false;
129   }
130 
131   /**
132    * 创建指定的目录。
133    * 如果指定的目录的父目录不存在则创建其目录书上所有需要的父目录。
134    * <b>注意：可能会在返回false的时候创建部分父目录。</b>
135    * @param fileName 要创建的目录的目录名
136    * @return 完全创建成功时返回true，否则返回false。
137    * @since  1.0
138    */
139   public static boolean makeDirectory(String fileName) {
140     File file = new File(fileName);
141     return makeDirectory(file);
142   }
143 
144   /**
145    * 清空指定目录中的文件。
146    * 这个方法将尽可能删除所有的文件，但是只要有一个文件没有被删除都会返回false。
147    * 另外这个方法不会迭代删除，即不会删除子目录及其内容。
148    * @param directory 要清空的目录
149    * @return 目录下的所有文件都被成功删除时返回true，否则返回false.
150    * @since  1.0
151    */
152   public static boolean emptyDirectory(File directory) {
153     boolean result = true;
154     File[] entries = directory.listFiles();
155     for (int i = 0; i < entries.length; i++) {
156       if (!entries[i].delete()) {
157         result = false;
158       }
159     }
160     return result;
161   }
162 
163   /**
164    * 清空指定目录中的文件。
165    * 这个方法将尽可能删除所有的文件，但是只要有一个文件没有被删除都会返回false。
166    * 另外这个方法不会迭代删除，即不会删除子目录及其内容。
167    * @param directoryName 要清空的目录的目录名
168    * @return 目录下的所有文件都被成功删除时返回true，否则返回false。
169    * @since  1.0
170    */
171   public static boolean emptyDirectory(String directoryName) {
172     File dir = new File(directoryName);
173     return emptyDirectory(dir);
174   }
175 
176   /**
177    * 删除指定目录及其中的所有内容。
178    * @param dirName 要删除的目录的目录名
179    * @return 删除成功时返回true，否则返回false。
180    * @since  1.0
181    */
182   public static boolean deleteDirectory(String dirName) {
183     return deleteDirectory(new File(dirName));
184   }
185 
186   /**
187    * 删除指定目录及其中的所有内容。
188    * @param dir 要删除的目录
189    * @return 删除成功时返回true，否则返回false。
190    * @since  1.0
191    */
192   public static boolean deleteDirectory(File dir) {
193     if ( (dir == null) || !dir.isDirectory()) {
194       throw new IllegalArgumentException("Argument " + dir +
195                                          " is not a directory. ");
196     }
197 
198     File[] entries = dir.listFiles();
199     int sz = entries.length;
200 
201     for (int i = 0; i < sz; i++) {
202       if (entries[i].isDirectory()) {
203         if (!deleteDirectory(entries[i])) {
204           return false;
205         }
206       }
207       else {
208         if (!entries[i].delete()) {
209           return false;
210         }
211       }
212     }
213 
214     if (!dir.delete()) {
215       return false;
216     }
217     return true;
218   }
219 
220   /**
221    * 列出目录中的所有内容，包括其子目录中的内容。
222    * @param fileName 要列出的目录的目录名
223    * @return 目录内容的文件数组。
224    * @since  1.0
225    */
226   /*public static File[] listAll(String fileName) {
227     return listAll(new File(fileName));
228   }*/
229 
230   /**
231    * 列出目录中的所有内容，包括其子目录中的内容。
232    * @param file 要列出的目录
233    * @return 目录内容的文件数组。
234    * @since  1.0
235    */
236   /*public static File[] listAll(File file) {
237     ArrayList list = new ArrayList();
238     File[] files;
239     if (!file.exists() || file.isFile()) {
240       return null;
241     }
242     list(list, file, new AllFileFilter());
243     list.remove(file);
244     files = new File[list.size()];
245     list.toArray(files);
246     return files;
247   }*/
248 
249   /**
250    * 列出目录中的所有内容，包括其子目录中的内容。
251    * @param file 要列出的目录
252    * @param filter 过滤器
253    * @return 目录内容的文件数组。
254    * @since  1.0
255    */
256   public static File[] listAll(File file,
257                                javax.swing.filechooser.FileFilter filter) {
258     ArrayList list = new ArrayList();
259     File[] files;
260     if (!file.exists() || file.isFile()) {
261       return null;
262     }
263     list(list, file, filter);
264     files = new File[list.size()];
265     list.toArray(files);
266     return files;
267   }
268 
269   /**
270    * 将目录中的内容添加到列表。
271    * @param list 文件列表
272    * @param filter 过滤器
273    * @param file 目录
274    */
275   private static void list(ArrayList list, File file,
276                            javax.swing.filechooser.FileFilter filter) {
277     if (filter.accept(file)) {
278       list.add(file);
279       if (file.isFile()) {
280         return;
281       }
282     }
283     if (file.isDirectory()) {
284       File files[] = file.listFiles();
285       for (int i = 0; i < files.length; i++) {
286         list(list, files[i], filter);
287       }
288     }
289 
290   }
291 
292   /**
293    * 返回文件的URL地址。
294    * @param file 文件
295    * @return 文件对应的的URL地址
296    * @throws MalformedURLException
297    * @since  1.0
298    * @deprecated 在实现的时候没有注意到File类本身带一个toURL方法将文件路径转换为URL。
299    *             请使用File.toURL方法。
300    */
301   public static URL getURL(File file) throws MalformedURLException {
302     String fileURL = "file:/" + file.getAbsolutePath();
303     URL url = new URL(fileURL);
304     return url;
305   }
306 
307   /**
308    * 从文件路径得到文件名。
309    * @param filePath 文件的路径，可以是相对路径也可以是绝对路径
310    * @return 对应的文件名
311    * @since  1.0
312    */
313   public static String getFileName(String filePath) {
314     File file = new File(filePath);
315     return file.getName();
316   }
317 
318   /**
319    * 从文件名得到文件绝对路径。
320    * @param fileName 文件名
321    * @return 对应的文件路径
322    * @since  1.0
323    */
324   public static String getFilePath(String fileName) {
325     File file = new File(fileName);
326     return file.getAbsolutePath();
327   }
328 
329   /**
330    * 将DOS/Windows格式的路径转换为UNIX/Linux格式的路径。
331    * 其实就是将路径中的"\"全部换为"/"，因为在某些情况下我们转换为这种方式比较方便，
332    * 某中程度上说"/"比"\"更适合作为路径分隔符，而且DOS/Windows也将它当作路径分隔符。
333    * @param filePath 转换前的路径
334    * @return 转换后的路径
335    * @since  1.0
336    */
337   public static String toUNIXpath(String filePath) {
338     return filePath.replace(‘\\‘, ‘/‘);
339   }
340 
341   /**
342    * 从文件名得到UNIX风格的文件绝对路径。
343    * @param fileName 文件名
344    * @return 对应的UNIX风格的文件路径
345    * @since  1.0
346    * @see #toUNIXpath(String filePath) toUNIXpath
347    */
348   public static String getUNIXfilePath(String fileName) {
349     File file = new File(fileName);
350     return toUNIXpath(file.getAbsolutePath());
351   }
352 
353   /**
354    * 得到文件的类型。
355    * 实际上就是得到文件名中最后一个“.”后面的部分。
356    * @param fileName 文件名
357    * @return 文件名中的类型部分
358    * @since  1.0
359    */
360   public static String getTypePart(String fileName) {
361     int point = fileName.lastIndexOf(‘.‘);
362     int length = fileName.length();
363     if (point == -1 || point == length - 1) {
364       return "";
365     }
366     else {
367       return fileName.substring(point + 1, length);
368     }
369   }
370 
371   /**
372    * 得到文件的类型。
373    * 实际上就是得到文件名中最后一个“.”后面的部分。
374    * @param file 文件
375    * @return 文件名中的类型部分
376    * @since  1.0
377    */
378   public static String getFileType(File file) {
379     return getTypePart(file.getName());
380   }
381 
382   /**
383    * 得到文件的名字部分。
384    * 实际上就是路径中的最后一个路径分隔符后的部分。
385    * @param fileName 文件名
386    * @return 文件名中的名字部分
387    * @since  1.0
388    */
389   public static String getNamePart(String fileName) {
390     int point = getPathLsatIndex(fileName);
391     int length = fileName.length();
392     if (point == -1) {
393       return fileName;
394     }
395     else if (point == length - 1) {
396       int secondPoint = getPathLsatIndex(fileName, point - 1);
397       if (secondPoint == -1) {
398         if (length == 1) {
399           return fileName;
400         }
401         else {
402           return fileName.substring(0, point);
403         }
404       }
405       else {
406         return fileName.substring(secondPoint + 1, point);
407       }
408     }
409     else {
410       return fileName.substring(point + 1);
411     }
412   }
413 
414   /**
415    * 得到文件名中的父路径部分。
416    * 对两种路径分隔符都有效。
417    * 不存在时返回""。
418    * 如果文件名是以路径分隔符结尾的则不考虑该分隔符，例如"/path/"返回""。
419    * @param fileName 文件名
420    * @return 父路径，不存在或者已经是父目录时返回""
421    * @since  1.0
422    */
423   public static String getPathPart(String fileName) {
424     int point = getPathLsatIndex(fileName);
425     int length = fileName.length();
426     if (point == -1) {
427       return "";
428     }
429     else if (point == length - 1) {
430       int secondPoint = getPathLsatIndex(fileName, point - 1);
431       if (secondPoint == -1) {
432         return "";
433       }
434       else {
435         return fileName.substring(0, secondPoint);
436       }
437     }
438     else {
439       return fileName.substring(0, point);
440     }
441   }
442 
443   /**
444    * 得到路径分隔符在文件路径中首次出现的位置。
445    * 对于DOS或者UNIX风格的分隔符都可以。
446    * @param fileName 文件路径
447    * @return 路径分隔符在路径中首次出现的位置，没有出现时返回-1。
448    * @since  1.0
449    */
450   public static int getPathIndex(String fileName) {
451     int point = fileName.indexOf(‘/‘);
452     if (point == -1) {
453       point = fileName.indexOf(‘\\‘);
454     }
455     return point;
456   }
457 
458   /**
459    * 得到路径分隔符在文件路径中指定位置后首次出现的位置。
460    * 对于DOS或者UNIX风格的分隔符都可以。
461    * @param fileName 文件路径
462    * @param fromIndex 开始查找的位置
463    * @return 路径分隔符在路径中指定位置后首次出现的位置，没有出现时返回-1。
464    * @since  1.0
465    */
466   public static int getPathIndex(String fileName, int fromIndex) {
467     int point = fileName.indexOf(‘/‘, fromIndex);
468     if (point == -1) {
469       point = fileName.indexOf(‘\\‘, fromIndex);
470     }
471     return point;
472   }
473 
474   /**
475    * 得到路径分隔符在文件路径中最后出现的位置。
476    * 对于DOS或者UNIX风格的分隔符都可以。
477    * @param fileName 文件路径
478    * @return 路径分隔符在路径中最后出现的位置，没有出现时返回-1。
479    * @since  1.0
480    */
481   public static int getPathLsatIndex(String fileName) {
482     int point = fileName.lastIndexOf(‘/‘);
483     if (point == -1) {
484       point = fileName.lastIndexOf(‘\\‘);
485     }
486     return point;
487   }
488 
489   /**
490    * 得到路径分隔符在文件路径中指定位置前最后出现的位置。
491    * 对于DOS或者UNIX风格的分隔符都可以。
492    * @param fileName 文件路径
493    * @param fromIndex 开始查找的位置
494    * @return 路径分隔符在路径中指定位置前最后出现的位置，没有出现时返回-1。
495    * @since  1.0
496    */
497   public static int getPathLsatIndex(String fileName, int fromIndex) {
498     int point = fileName.lastIndexOf(‘/‘, fromIndex);
499     if (point == -1) {
500       point = fileName.lastIndexOf(‘\\‘, fromIndex);
501     }
502     return point;
503   }
504 
505   /**
506    * 将文件名中的类型部分去掉。
507    * @param filename 文件名
508    * @return 去掉类型部分的结果
509    * @since  1.0
510    */
511   public static String trimType(String filename) {
512     int index = filename.lastIndexOf(".");
513     if (index != -1) {
514       return filename.substring(0, index);
515     }
516     else {
517       return filename;
518     }
519   }
520   /**
521    * 得到相对路径。
522    * 文件名不是目录名的子节点时返回文件名。
523    * @param pathName 目录名
524    * @param fileName 文件名
525    * @return 得到文件名相对于目录名的相对路径，目录下不存在该文件时返回文件名
526    * @since  1.0
527    */
528   public static String getSubpath(String pathName,String fileName) {
529     int index = fileName.indexOf(pathName);
530     if (index != -1) {
531       return fileName.substring(index + pathName.length() + 1);
532     }
533     else {
534       return fileName;
535     }
536   }
537 
538   /**
539    * 检查给定目录的存在性
540    * 保证指定的路径可用，如果指定的路径不存在，那么建立该路径，可以为多级路径
541    * @param path
542    * @return 真假值
543    * @since  1.0
544    */
545    public static final boolean pathValidate(String path)
546    {
547      //String path="d:/web/www/sub";
548      //System.out.println(path);
549      //path = getUNIXfilePath(path);
550 
551      //path = ereg_replace("^\\/+", "", path);
552      //path = ereg_replace("\\/+$", "", path);
553      String[] arraypath = path.split("/");
554      String tmppath = "";
555      for (int i = 0; i < arraypath.length; i++)
556      {
557        tmppath += "/" + arraypath[i];
558        File d = new File(tmppath.substring(1));
559        if (!d.exists()) { //检查Sub目录是否存在
560            System.out.println(tmppath.substring(1));
561          if (!d.mkdir())
562          {
563            return false;
564          }
565        }
566      }
567      return true;
568    }
569 
570    /**
571     * 读取文件的内容
572     * 读取指定文件的内容
573     * @param path 为要读取文件的绝对路径
574     * @return 以行读取文件后的内容。
575     * @since  1.0
576     */
577    public static final String getFileContent(String path) throws IOException
578    {
579      String filecontent = "";
580      try {
581        File f = new File(path);
582        if (f.exists()) {
583          FileReader fr = new FileReader(path);
584          BufferedReader br = new BufferedReader(fr); //建立BufferedReader对象，并实例化为br
585          String line = br.readLine(); //从文件读取一行字符串
586          //判断读取到的字符串是否不为空
587          while (line != null) {
588            filecontent += line + "\n";
589            line = br.readLine(); //从文件中继续读取一行数据
590          }
591          br.close(); //关闭BufferedReader对象
592          fr.close(); //关闭文件
593        }
594 
595      }
596      catch (IOException e) {
597        throw e;
598      }
599      return filecontent;
600    }
601 
602    /**
603     * 根据内容生成文件
604     * @param path要生成文件的绝对路径，
605     * @param 文件的内容。
606     * @return 真假值
607     * @since  1.0
608     */
609    public static final boolean genModuleTpl(String path, String modulecontent)  throws IOException
610    {
611 
612      path = getUNIXfilePath(path);
613      String[] patharray = path.split("\\/");
614      String modulepath = "";
615      for (int i = 0; i < patharray.length - 1; i++) {
616        modulepath += "/" + patharray[i];
617      }
618      File d = new File(modulepath.substring(1));
619      if (!d.exists()) {
620        if (!pathValidate(modulepath.substring(1))) {
621          return false;
622        }
623      }
624      try {
625        FileWriter fw = new FileWriter(path); //建立FileWriter对象，并实例化fw
626        //将字符串写入文件
627        fw.write(modulecontent);
628        fw.close();
629      }
630      catch (IOException e) {
631        throw e;
632      }
633      return true;
634    }
635 
636    /**
637     * 获取图片文件的扩展名（发布系统专用）
638     * @param picname 为图片名称加上前面的路径不包括扩展名
639     * @return 图片的扩展名
640     * @since  1.0
641     */
642    public static final String getPicExtendName(String pic_path)
643    {
644      pic_path = getUNIXfilePath(pic_path);
645      String pic_extend = "";
646      if (isFileExist(pic_path + ".gif"))
647      {
648        pic_extend = ".gif";
649      }
650      if (isFileExist(pic_path + ".jpeg"))
651      {
652        pic_extend = ".jpeg";
653      }
654      if (isFileExist(pic_path + ".jpg"))
655      {
656        pic_extend = ".jpg";
657      }
658      if (isFileExist(pic_path + ".png"))
659      {
660        pic_extend = ".png";
661      }
662      return pic_extend; //返回图片扩展名
663    }
664    //拷贝文件
665    public static final boolean CopyFile(File in, File out) throws Exception {
666        try {
667            FileInputStream fis = new FileInputStream(in);
668            FileOutputStream fos = new FileOutputStream(out);
669            byte[] buf = new byte[1024];
670            int i = 0;
671            while ((i = fis.read(buf)) != -1) {
672                fos.write(buf, 0, i);
673            }
674            fis.close();
675            fos.close();
676            return true;
677        } catch (IOException ie) {
678            ie.printStackTrace();
679            return false;
680        }
681    }
682    //拷贝文件
683    public static final boolean CopyFile(String infile, String outfile) throws Exception {
684        try {
685            File in = new File(infile);
686            File out = new File(outfile);
687            return CopyFile(in, out);
688        } catch (IOException ie) {
689            ie.printStackTrace();
690            return false;
691        }
692 
693    }
694    /**
695     * 计算图片数量
696     * @param id
697     * @param dtime
698     * @return
699     */
700    public static final int countPics(String id,String dtime,String extensions){
701        int counts = 0; 
702        
703        MyFileFilter mfilter = new MyFileFilter(extensions.split(","));
704        PropsUtil pu = new PropsUtil();
705        String PICROOT = pu.readSingleProps("DestinationsPICROOT").trim();
706        String path = PICROOT + "/"+dtime.substring(0, 10) + "/";
707        File lfile = new File(path);
708        String filename;
709        if(lfile.isDirectory()){
710            File[] files = lfile.listFiles(mfilter);
711            for(int i=0;i<files.length;i++){
712                filename = files[i].getName();
713                if((filename.indexOf(id + "_")==0)&&(filename.indexOf("_small")>-1))
714                    counts ++;
715            }
716            files = null;
717        }
718        filename = null;
719        lfile = null;
720        pu = null;
721        mfilter = null;
722            
723        return counts;
724    }
725 
726 }