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);
}
}