文件操作工具类



package com.rainteen.framework.util.io;

import java.io.BufferedInputStream;
import java.io.Closeable;
import java.io.File;
import java.io.FileFilter;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.FilenameFilter;
import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Date;
import java.util.Enumeration;
import java.util.Iterator;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.zip.ZipEntry;
import java.util.zip.ZipFile;
import java.util.zip.ZipOutputStream;

import org.apache.commons.io.FileUtils;
import org.apache.commons.lang.StringUtils;
import org.apache.log4j.Logger;

/**
 * 文件名过滤器
 *
 * @author rainteen
 */
class RegExpFileFilter implements FilenameFilter {
 private String regExp = null;
 private boolean onlyFile = false;

 public RegExpFileFilter() {
  this.regExp = null;
  this.onlyFile = false;
 }

 /**
  *
  * @param regExp
  *            正则表达式
  * @param onlyFile
  *            只匹配文件的标志, false则目录与文件都进行匹配
  */
 public RegExpFileFilter(String regExp, boolean onlyFile) {
  super();
  this.regExp = regExp;
  this.onlyFile = onlyFile;
 }

 public boolean accept(File dir, String name) {
  if (regExp == null) {
   return true;
  } else {
   String str = name;
   Pattern pattern = Pattern.compile(this.regExp);
   if (onlyFile) {
    str = name;
   } else {
    str = dir.getAbsolutePath() + File.separator + name;
   }
   Matcher matcher = pattern.matcher(str);
   return matcher.find();
  }
 }
}

class EntityDirFilter implements FileFilter {
 public boolean accept(File path) {
  if (path.exists() && path.isDirectory()) {
   return true;
  }
  return false;
 }
}

class EntityFileFilter implements FileFilter {
 public boolean accept(File path) {
  if (path.exists() && path.isFile()) {
   return true;
  }
  return false;
 }
}

/**
 * 文件处理器
 *
 * @author rainteen
 * @version 1.0
 */
public class FileUtil {
 public static final int DEFAULT_BUFFER_SIZE = 1024 * 4;
 private static Logger logger = Logger.getLogger(FileUtil.class);

 private FileUtil() {
 }

 public static void closeStream(Closeable... closeable) {
  if (closeable == null) {
   return;
  }
  for (Closeable item : closeable) {
   if (item != null) {
    try {
     item.close();
     item = null;
    } catch (Exception ex) {
     logger.error("", ex);
    }
   }
  }
 }

 public static boolean isValidParam(Object... paramArray) {
  if (paramArray == null) {
   return false;
  }
  for (Object param : paramArray) {
   if (param == null) {
    return false;
   } else if (param instanceof String) {
    if (StringUtils.isEmpty(param.toString())) {
     return false;
    }
   }
  }
  return true;
 }

 public static boolean isValidEntityFile(File srcFile) {
  if (srcFile == null || !srcFile.exists() || !srcFile.isFile()) {
   return false;
  }
  return true;
 }

 public static boolean isValidEntityDirectory(File srcFile) {
  if (srcFile == null || !srcFile.exists() || !srcFile.isDirectory()) {
   return false;
  }
  return true;
 }

 public static boolean copyFile(File srcFile, String destPath,
   boolean forceReplace) {
  if (!isValidEntityFile(srcFile) || !isValidParam(destPath)) {
   throw new IllegalArgumentException("Parameters are invalid.");
  }
  File destDir = new File(destPath);
  if (!isValidEntityDirectory(destDir)) {
   destDir.mkdirs();
  }
  File destFile = new File(destPath + File.separator + srcFile.getName());
  if (forceReplace && isValidEntityFile(destFile)) {
   destFile.delete();
  }
  try {
   FileUtils.copyFile(srcFile, destFile);
   destFile = new File(destPath + File.separator + srcFile.getName());
   return destFile.exists();
  } catch (IOException ioe) {
   logger.error("Copy file failed.", ioe);
  }
  return false;
 }

 /**
  *
  * @param srcFile
  * @param destDir
  * @param forceReplace
  * @return
  */
 public static boolean copyFile(File srcFile, File destDir,
   boolean forceReplace) {
  if (!isValidEntityFile(srcFile) || !isValidParam(destDir)) {
   throw new IllegalArgumentException("Parameters are invalid.");
  }
  if (isValidEntityFile(destDir) && forceReplace) {
   destDir.delete();
  } else if (!isValidEntityDirectory(destDir)) {
   destDir.mkdirs();
  }
  try {
   FileUtils.copyFileToDirectory(srcFile, destDir);
   File destFile = new File(destDir.getAbsolutePath() + File.separator
     + srcFile.getName());
   return destFile.exists();
  } catch (IOException ioe) {
   logger.error("Copy file error.", ioe);
  }
  return false;
 }

 public static boolean copyDir(File srcDir, File destDir,
   boolean forceReplace) {
  File destSubDir = new File(destDir.getAbsolutePath() + File.separator
    + srcDir.getName());
  if (forceReplace) {
   deleteAll(destSubDir);
  }
  try {
   FileUtils.copyDirectoryToDirectory(srcDir, destDir);
   return destDir.exists();
  } catch (IOException ioe) {
   logger.error("Copy directory to directory failed.", ioe);
  }
  return false;
 }
 /**
  *
  * @param srcPath
  * @param destPath
  * @param forceReplace
  * @return
  */
 public static boolean copyDir(String srcPath, String destPath,
   boolean forceReplace) {
  File srcDir = new File(srcPath);
  File destDir = new File(destPath);
  boolean flag = copyDir(srcDir, destDir, forceReplace);
  return flag;
 }

 /**
  * 删除dir目录，包括dir自身
  *
  * @param dir
  * @return
  */
 public static boolean deleteDir(File dir) {
  if (!isValidEntityDirectory(dir)) {
   throw new IllegalArgumentException("Parameter is invalid.");
  }
  File[] subFiles = dir.listFiles();
  for (int index = 0; index < subFiles.length; index++) {
   File subFile = subFiles[index];
   if (subFile.isDirectory()) {
    deleteDir(subFile);
   } else {
    subFile.delete();
   }
  }
  dir.delete();
  return !dir.exists();
 }

 /**
  * 删除目标文件; 如果是目录, 则删除目标目录中的所有文件及其子目录; 但不删除dest目录
  *
  * @param destPath
  * @return
  */
 public static boolean deleteAll(String dest) {
  if (!isValidParam(dest)) {
   throw new IllegalArgumentException("Parameter is invalid.");
  }
  File destFile = new File(dest);
  if (!isValidEntityFile(destFile) && !isValidEntityDirectory(destFile)) {
   throw new IllegalArgumentException("Parameters are invalid.");
  }
  boolean flag = false;
  File file = new File(dest);
  if (file.exists()) {
   if (file.isFile()) {
    flag = file.delete();
   } else if (file.isDirectory()) {
    flag = deleteDir(file);
   }
  }
  return flag;
 }

 /**
  *
  * @param dest
  * @return
  */
 public static boolean deleteAll(File dest) {
  if (!isValidParam(dest)) {
   throw new IllegalArgumentException("Parameter is invalid.");
  }
  boolean flag = false;
  if (dest.exists()) {
   if (dest.isFile()) {
    flag = dest.delete();
   } else if (dest.isDirectory()) {
    flag = deleteDir(dest);
   }
  }
  return flag;
 }

 /**
  *
  * @param srcFile
  * @param destPath
  * @param forceReplace
  * @return
  */
 public static boolean moveFile(File srcFile, String destPath,
   boolean forceReplace) {
  if (!isValidEntityFile(srcFile)) {
   throw new IllegalArgumentException("Parameters are invalid.");
  }
  File destDir = new File(destPath);
  boolean cpyFlag = copyFile(srcFile, destDir, forceReplace);
  srcFile.delete();
  return cpyFlag;
 }

 /**
  *
  * @param srcFile
  * @param destDir
  * @param forceReplace
  * @return
  */
 public static boolean moveFile(File srcFile, File destDir,
   boolean forceReplace) {
  if (!isValidEntityFile(srcFile) || !isValidParam(destDir)) {
   throw new IllegalArgumentException("Parameters are invalid.");
  }
  boolean cpyFlag = copyFile(srcFile, destDir, forceReplace);
  srcFile.delete();
  return cpyFlag;
 }

 /**
  *
  * @param srcDir
  * @param destDir
  * @param forceReplace
  * @return
  */
 public static boolean moveDir(File srcDir, File destDir,
   boolean forceReplace) {
  if (!isValidEntityDirectory(srcDir) || !isValidParam(destDir)) {
   throw new IllegalArgumentException("Parameters are invalid.");
  }
  File destSubDir = new File(destDir.getAbsolutePath()
    + File.separator + srcDir.getName());
  if (forceReplace && destSubDir.exists()) {
   deleteAll(destSubDir);
  }
  boolean cpyFlag = copyDir(srcDir, destDir, forceReplace);
  deleteAll(srcDir);
  return cpyFlag;
 }

 /**
  *
  * @param dir
  * @param subDirList
  * @return
  */
 private static List<File> listSubDirs(File dir, List<File> subDirList) {
  if (subDirList == null) {
   subDirList = new ArrayList<File>();
  }
  FileFilter entityFileFilter = new EntityFileFilter();
  File[] subDirs = dir.listFiles(entityFileFilter);
  subDirs = (subDirs == null) ? new File[0] : subDirs;
  List<File> tmpList = Arrays.asList(subDirs);
  tmpList = (tmpList == null) ? new ArrayList<File>() : tmpList;
  subDirList.addAll(tmpList);
  for (int idx = 0; (subDirs != null) && (idx < subDirs.length); idx++) {
   File subDir = subDirs[idx];
   subDirList = listSubDirs(subDir, subDirList);
  }
  return subDirList;
 }

 /**
  * 列出目录 dir 中所有子目录(recursion=true时递归所有子级目录)
  *
  * @param dir
  * @param recursion
  * @return
  */
 public static List<File> listSubDirs(File dir, boolean recursion) {
  if (!isValidEntityDirectory(dir)) {
   throw new IllegalArgumentException("Parameter is invalid.");
  }
  List<File> subDirList = new ArrayList<File>();
  if (recursion) {
   subDirList = listSubDirs(dir, subDirList);
  } else {
   FileFilter entityDirFilter = new EntityDirFilter();
   File[] subDirs = dir.listFiles(entityDirFilter);
   subDirList = Arrays.asList(subDirs);
  }
  return subDirList;
 }

 /**
  * 递归列出目录 dir 中所有文件
  *
  * @param dir
  * @param fileList
  * @return
  */
 private static List<File> listFiles(File dir, List<File> fileList) {
  if (fileList == null) {
   fileList = new ArrayList<File>();
  }
  FileFilter entityFileFilter = new EntityFileFilter();
  File[] files = dir.listFiles(entityFileFilter);
  files = (files == null) ? new File[0] : files;
  List<File> tmpList = Arrays.asList(files);
  tmpList = (tmpList == null) ? new ArrayList<File>() : tmpList;
  fileList.addAll(tmpList);
  FileFilter entityDirFilter = new EntityDirFilter();
  File[] subDirs = dir.listFiles(entityDirFilter);
  for (int idx = 0; (subDirs != null) && (idx < subDirs.length); idx++) {
   File subDir = subDirs[idx];
   fileList = listFiles(subDir, fileList);
  }
  return fileList;
 }

 /**
  * 列出目录 dir 中的所有文件(recursion=true时递归所有子级目录)
  *
  * @param dir
  * @param recursion
  * @return
  */
 public static List<File> listFiles(File dir, boolean recursion) {
  if (!isValidEntityDirectory(dir)) {
   throw new IllegalArgumentException("Parameter is invalid.");
  }
  List<File> fileList = new ArrayList<File>();
  if (recursion) {
   fileList = listFiles(dir, fileList);
  } else {
   FileFilter entityFileFilter = new EntityFileFilter();
   File[] files = dir.listFiles(entityFileFilter);
   List<File> tmpList = Arrays.asList(files);
   fileList.addAll(tmpList);
  }
  return fileList;
 }

 /**
  * 搜索目录 dir 中匹配 正则表达式 regExp 的文件(onlyFile=true) 或目录(onlyFile=false)
  *
  * @param dir
  * @param regExp
  * @param onlyFile
  * @param fileList
  * @return
  */
 private static List<File> search(File dir, String regExp, boolean onlyFile,
   List<File> fileList) {
  if (fileList == null) {
   fileList = new ArrayList<File>();
  }
  FilenameFilter filenameFilter = new RegExpFileFilter(regExp, onlyFile);
  File[] files = dir.listFiles(filenameFilter);
  files = files == null ? new File[0] : files;
  List<File> tmpList = Arrays.asList(files);
  tmpList = (tmpList != null) ? tmpList : new ArrayList<File>();
  fileList.addAll(tmpList);
  FileFilter dirFilter = new EntityDirFilter();
  File[] subDirs = dir.listFiles(dirFilter);
  for (int idx = 0; (subDirs != null) && (idx < subDirs.length); idx++) {
   File subDir = subDirs[idx];
   fileList = search(subDir, regExp, onlyFile, fileList);
  }
  return fileList;
 }

 /**
  * 搜索目录 dir 中匹配正则表达式 regExp 的所有文件(只匹配文件)
  *
  * @param dir
  * @param regExp
  * @return
  */
 public static List<File> searchFile(File dir, String regExp) {
  if (!isValidEntityDirectory(dir)) {
   throw new IllegalArgumentException("Parameter is invalid.");
  }
  List<File> fileList = new ArrayList<File>();
  fileList = search(dir, regExp, true, fileList);
  return fileList;
 }

 /**
  * 搜索目录 dir 中匹配正则表达式 regExp 的所有文件或目录
  *
  * @param dir
  * @param regExp
  * @return
  */
 public static List<File> searchAll(File dir, String regExp) {
  if (!isValidEntityDirectory(dir)) {
   throw new IllegalArgumentException("Parameter is invalid.");
  }
  List<File> fileList = new ArrayList<File>();
  fileList = search(dir, regExp, false, fileList);
  return fileList;
 }

 /**
  * 全盘搜索名称(而不是内容)匹配的文件或目录
  *
  * @param regExp
  * @return
  */
 public static List<File> searchOnDisk(String regExp) {
  List<File> list = new ArrayList<File>();
  File[] roots = File.listRoots();
  for (int idx = 0; (roots != null) && (idx < roots.length); idx++) {
   File root = roots[idx];
   list = search(root, regExp, false, list);
  }
  return list;
 }

 /**
  * 压缩目录
  *
  * @param dir
  *            目标目录
  * @param zipFileName
  *            目标文件
  * @return
  */
 public static void zipDir(File dir, String zipFileName) {
  ZipOutputStream zipOutputStream = null;
  FileOutputStream fileOutputStream = null;
  try {
   if (!".zip".equalsIgnoreCase(zipFileName.substring(zipFileName
     .length() - 4))) {
    zipFileName = zipFileName + ".zip";
   }
   fileOutputStream = new FileOutputStream(zipFileName);
   zipOutputStream = new ZipOutputStream(fileOutputStream);
   zip(zipOutputStream, dir, "");
  } catch (Exception ex) {
   logger.error("", ex);
  } finally {
   closeStream(zipOutputStream);
  }
 }

 private static void zip(ZipOutputStream zipOutputStream, File inFile,
   String base) throws Exception {
  if (inFile.isDirectory()) {
   File[] subFiles = inFile.listFiles();
   zipOutputStream.putNextEntry(new ZipEntry(base + "/"));
   base = (base.length() == 0) ? "" : base + "/";
   for (int i = 0; i < subFiles.length; i++) {
    String fName = subFiles[i].getName();
    zip(zipOutputStream, subFiles[i], base
      + new String(fName.getBytes("utf-8"), "gb2312"));
   }
  } else {
   FileInputStream fileInput = null;
   try {
    if (base.length() > 0) {
     zipOutputStream.putNextEntry(new ZipEntry(base));
    } else {
     String fName = inFile.getName();
     zipOutputStream.putNextEntry(new ZipEntry(new String(fName
       .getBytes("utf-8"), "gb2312")));
    }
    fileInput = new FileInputStream(inFile);
    int data = fileInput.read();
    while (data != -1) {
     zipOutputStream.write(data);
     data = fileInput.read();
    }
    zipOutputStream.closeEntry();
   } catch (Exception ex) {
    logger.error("zip exception.", ex);
   } finally {
    closeStream(fileInput);
   }
  }
 }

 /**
  * 压缩文件 inFile 为 zipFileName 压缩包
  *
  * @param inFile
  *            目标文件
  * @param zipFileName
  *            压缩文件的名称(含路径)
  */
 public static void zipFile(File inFile, String zipFileName) {
  if (!isValidEntityFile(inFile)) {
   return;
  }
  ZipOutputStream zipOutputStream = null;
  FileOutputStream fileOutputStream = null;
  BufferedInputStream bufferedInputStream = null;
  try {
   fileOutputStream = new FileOutputStream(zipFileName);
   zipOutputStream = new ZipOutputStream(fileOutputStream);
   bufferedInputStream = new BufferedInputStream(new FileInputStream(
     inFile));
   ZipEntry entry = new ZipEntry("" + inFile.getName());
   zipOutputStream.putNextEntry(entry);
   int count = 0;
   byte[] data = new byte[DEFAULT_BUFFER_SIZE];
   while ((count = bufferedInputStream.read(data, 0,
     DEFAULT_BUFFER_SIZE)) != -1) {
    zipOutputStream.write(data, 0, count);
   }
   bufferedInputStream.close();
  } catch (Exception e) {
   throw new RuntimeException(e);
  } finally {
   closeStream(bufferedInputStream, zipOutputStream, fileOutputStream);
  }
  return;
 }

 /**
  * 将压缩文件 zipInFile解压到 destPath 目录下的 zipInFile文件名目录下 如将 F:\\test.zip 文件解压缩到
  * g:\\ 目录下的 test 目录下
  *
  * @param zipInFile
  *            压缩包文件(zip格式)
  * @param destPath
  *            目标目录
  * @return
  */
 public static void unzipFile(File zipInFile, File destDir,
   boolean forceReplace) throws Exception {
  if (!isValidEntityDirectory(destDir)) {
   throw new IllegalArgumentException("Parameters are invalid.");
  }
  String fName = zipInFile.getName().substring(0,
    zipInFile.getName().lastIndexOf("."));
  File destSubDir = new File(destDir.getAbsolutePath() + File.separator
    + fName);
  if (forceReplace && destSubDir.exists()) {
   deleteAll(destSubDir);
   destSubDir.mkdirs();
  }
  ZipFile zipFile = null;
  zipFile = new ZipFile(zipInFile.getAbsolutePath());
  Enumeration enumeration = zipFile.entries();
  while (enumeration.hasMoreElements()) {
   ZipEntry zipEntry = (ZipEntry) enumeration.nextElement();
   if (zipEntry.isDirectory()) {
    String dirName = zipEntry.getName();
    dirName = dirName.substring(0, dirName.length() - 1);
    File tmpFile = new File(destSubDir.getPath() + File.separator
      + dirName);
    tmpFile.mkdirs();
   } else {
    unzipFile(zipInFile, destSubDir, zipEntry);
   }
  }
  return;
 }
 private static void unzipFile(File zipInFile, File destSubDir, ZipEntry zipEntry) {
  InputStream inputStream = null;
  FileOutputStream fileOutputStream = null;
  try {
   ZipFile zipFile = new ZipFile(zipInFile.getAbsolutePath());
   File tmpFile = new File(destSubDir.getPath()
     + File.separator + zipEntry.getName());
   tmpFile.createNewFile();
   inputStream = zipFile.getInputStream(zipEntry);
   fileOutputStream = new FileOutputStream(tmpFile);
   byte[] buff = new byte[DEFAULT_BUFFER_SIZE];
   int data = inputStream.read(buff);
   while (data != -1) {
    fileOutputStream.write(buff, 0, data);
    data = inputStream.read(buff);
   }
  } catch (IOException ioe) {
   logger.error("", ioe);
  } finally {
   closeStream(inputStream, fileOutputStream);
  }
 }
 /**
  * 修改文件的最后访问时间为指定时间
  *
  * @param file
  *            目标文件
  * @param newTime
  *            新的访问时间
  * @return
  */
 public static File changeLastModified(File file, Date newTime) {
  if (!isValidEntityFile(file) || newTime == null) {
   throw new IllegalArgumentException("The parameters are invalid.");
  }
  file.setLastModified(newTime.getTime());
  return file;
 }

 public static void printList(List<File> list) {
  if (list == null)
   return;
  for (Iterator iter = list.iterator(); iter.hasNext();) {
   File file = (File) iter.next();
   System.out.println(file.getAbsolutePath());
  }
 }

 public static void main(String[] args) {
  File srcFile = new File("g:\\设计模式_责任链模式.vsd");
  File destDir = new File("F:\\backup\\test");
  boolean flag = FileUtil.copyFile(srcFile, "F:\\backup\\test", true);
  System.out.println(flag);
 }
}