对文件操作的常用的几个方法

前几天看了下文件的操作，顺便练习了一下，写了一个简单的类，写得不好，还需要不断改进，希望各位高手多多指教哈！

package com.myclover.utils.file;

import java.io.File;

import java.io.FileInputStream;

import java.io.FileOutputStream;

import java.io.IOException;

import java.io.InputStream;

import java.io.OutputStream;

import java.util.Enumeration;

import java.util.zip.ZipEntry;

import java.util.zip.ZipFile;

import java.util.zip.ZipOutputStream;

/**

* <pre>

* 功能描述：文件操作工具类

* 实现文件的创建、删除、复制、压缩、解压以及目录的创建、删除、复制、压缩解压等功能

* </pre>

* @author 方方 <p>

* Blog: http://myclover.javaeye.com <p>

* 日 期： 2010-07-26 <p>

* @version 0.1 <p>

* {@code com.myclover.utils.file.FileOperateUtils.java}

*

*/

public class FileOperateUtils {



/**

*

* 功能描述：复制单个文件，如果目标文件存在，则不覆盖

* @param srcFileName 待复制的文件名

* @param descFileName 目标文件名

* @return 返回：

* 如果复制成功，则返回true，否则返回false

*/

public static boolean copyFile(String srcFileName , String descFileName)

{

return FileOperateUtils.copyFileCover(srcFileName, descFileName, false);

}





/**

*

* 功能描述：复制单个文件

* @param srcFileName 待复制的文件名

* @param descFileName 目标文件名

* @param coverlay 如果目标文件已存在，是否覆盖

* @return 返回：

* 如果复制成功，则返回true，否则返回false

*/

public static boolean copyFileCover(String srcFileName , String descFileName , boolean coverlay)

{

File srcFile = new File(srcFileName);

//判断源文件是否存在

if(!srcFile.exists())

{

System.out.println("复制文件失败，源文件" + srcFileName + "不存在!");

return false;

}

//判断源文件是否是合法的文件

else if(!srcFile.isFile())

{

System.out.println("复制文件失败，" + srcFileName + "不是一个文件!");

return false;

}

File descFile = new File(descFileName);

//判断目标文件是否存在

if(descFile.exists())

{

//如果目标文件存在，并且允许覆盖

if(coverlay)

{

System.out.println("目标文件已存在，准备删除!");

if(!FileOperateUtils.delFile(descFileName))

{

System.out.println("删除目标文件" + descFileName + "失败!");

return false;

}

}

else

{

System.out.println("复制文件失败，目标文件" + descFileName + "已存在!");

return false;

}

}

else

{

if(!descFile.getParentFile().exists())

{

//如果目标文件所在的目录不存在，则创建目录

System.out.println("目标文件所在的目录不存在，创建目录!");

//创建目标文件所在的目录

if(!descFile.getParentFile().mkdirs())

{

System.out.println("创建目标文件所在的目录失败!");

return false;

}

}

}



//准备复制文件

//读取的位数

int readByte = 0;

InputStream ins = null;

OutputStream outs = null;

try

{

//打开源文件

ins = new FileInputStream(srcFile);

//打开目标文件的输出流

outs = new FileOutputStream(descFile);

byte[] buf = new byte[1024];

//一次读取1024个字节，当readByte为-1时表示文件已经读取完毕

while((readByte = ins.read(buf)) != -1)

{

//将读取的字节流写入到输出流

outs.write(buf, 0, readByte);

}

System.out.println("复制单个文件" + srcFileName + "到" + descFileName + "成功!");

return true;

}

catch(Exception e)

{

System.out.println("复制文件失败：" + e.getMessage());

return false;

}

finally

{

//关闭输入输出流，首先关闭输出流，然后再关闭输入流

if(outs != null)

{

try

{

outs.close();

}

catch(IOException oute)

{

oute.printStackTrace();

}

}

if(ins != null)

{

try

{

ins.close();

}

catch(IOException ine)

{

ine.printStackTrace();

}

}

}

}





/**

*

* 功能描述：复制整个目录的内容，如果目标目录存在，则不覆盖

* @param srcDirName 源目录名

* @param descDirName 目标目录名

* @return 返回：

* 如果复制成功返回true，否则返回false

*/

public static boolean copyDirectory(String srcDirName , String descDirName)

{

return FileOperateUtils.copyDirectoryCover(srcDirName, descDirName, false);

}





/**

*

* 功能描述：复制整个目录的内容

* @param srcDirName 源目录名

* @param descDirName 目标目录名

* @param coverlay 如果目标目录存在，是否覆盖

* @return 返回：

* 如果复制成功返回true，否则返回false

*/

public static boolean copyDirectoryCover(String srcDirName , String descDirName , boolean coverlay)

{

File srcDir = new File(srcDirName);

//判断源目录是否存在

if(!srcDir.exists())

{

System.out.println("复制目录失败，源目录" + srcDirName + "不存在!");

return false;

}

//判断源目录是否是目录

else if(!srcDir.isDirectory())

{

System.out.println("复制目录失败，" + srcDirName + "不是一个目录!");

return false;

}

//如果目标文件夹名不以文件分隔符结尾，自动添加文件分隔符

if(!descDirName.endsWith(File.separator))

{

descDirName = descDirName + File.separator;

}

File descDir = new File(descDirName);

//如果目标文件夹存在

if(descDir.exists())

{

if(coverlay)

{

//允许覆盖目标目录

System.out.println("目标目录已存在，准备删除!");

if(!FileOperateUtils.delFile(descDirName))

{

System.out.println("删除目录" + descDirName + "失败!");

return false;

}

}

else

{

System.out.println("目标目录复制失败，目标目录" + descDirName + "已存在!");

return false;

}

}

else

{

//创建目标目录

System.out.println("目标目录不存在，准备创建!");

if(!descDir.mkdirs())

{

System.out.println("创建目标目录失败!");

return false;

}



}



boolean flag = true;

//列出源目录下的所有文件名和子目录名

File[] files = srcDir.listFiles();

for(int i = 0 ; i < files.length ; i++)

{

//如果是一个单个文件，则直接复制

if(files[i].isFile())

{

flag = FileOperateUtils.copyFile(files[i].getAbsolutePath(), descDirName + files[i].getName());

//如果拷贝文件失败，则退出循环

if(!flag)

{

break;

}

}

//如果是子目录，则继续复制目录

if(files[i].isDirectory())

{

flag = FileOperateUtils.copyDirectory(files[i].getAbsolutePath(), descDirName + files[i].getName());

//如果拷贝目录失败，则退出循环

if(!flag)

{

break;

}

}

}



if(!flag)

{

System.out.println("复制目录" + srcDirName + "到" + descDirName + "失败!");

return false;

}

System.out.println("复制目录" + srcDirName + "到" + descDirName + "成功!");

return true;



}





/**

*

* 功能描述：删除文件，可以删除单个文件或文件夹

* @param fileName 被删除的文件名

* @return 返回：

* 如果删除成功，则返回true，否是返回false

*/

public static boolean delFile(String fileName)

{

File file = new File(fileName);

if(!file.exists())

{

System.out.println("删除文件失败，" + fileName + "文件不存在!");

return false;

}

else

{

if(file.isFile())

{

return FileOperateUtils.deleteFile(fileName);

}

else

{

return FileOperateUtils.deleteDirectory(fileName);

}

}

}





/**

*

* 功能描述：删除单个文件

* @param fileName 被删除的文件名

* @return 返回：

* 如果删除成功，则返回true，否则返回false

*/

public static boolean deleteFile(String fileName)

{

File file = new File(fileName);

if(file.exists() && file.isFile())

{

if(file.delete())

{

System.out.println("删除单个文件" + fileName + "成功!");

return true;

}

else

{

System.out.println("删除单个文件" + fileName + "失败!");

return false;

}

}

else

{

System.out.println("删除单个文件失败，" + fileName + "文件不存在!");

return false;

}

}





/**

*

* 功能描述：删除目录及目录下的文件

* @param dirName 被删除的目录所在的文件路径

* @return 返回：

* 如果目录删除成功，则返回true，否则返回false

*/

public static boolean deleteDirectory(String dirName)

{

if(!dirName.endsWith(File.separator))

{

dirName = dirName + File.separator;

}

File dirFile = new File(dirName);

if(!dirFile.exists() || !dirFile.isDirectory())

{

System.out.println("删除目录失败" + dirName + "目录不存在!");

return false;

}

boolean flag = true;

//列出全部文件及子目录

File[] files = dirFile.listFiles();

for(int i = 0 ; i < files.length ; i++)

{

//删除子文件

if(files[i].isFile())

{

flag = FileOperateUtils.deleteFile(files[i].getAbsolutePath());

//如果删除文件失败，则退出循环

if(!flag)

{

break;

}

}

//删除子目录

else if(files[i].isDirectory())

{

flag = FileOperateUtils.deleteDirectory(files[i].getAbsolutePath());

//如果删除子目录失败，则退出循环

if(!flag)

{

break;

}

}

}



if(!flag)

{

System.out.println("删除目录失败!");

return false;

}

//删除当前目录

if(dirFile.delete())

{

System.out.println("删除目录" + dirName + "成功!");

return true;

}

else

{

System.out.println("删除目录" + dirName + "失败!");

return false;

}



}





/**

*

* 功能描述：创建单个文件

* @param descFileName 文件名，包含路径

* @return 返回：

* 如果创建成功，则返回true，否则返回false

*/

public static boolean createFile(String descFileName)

{

File file = new File(descFileName);

if(file.exists())

{

System.out.println("文件" + descFileName + "已存在!");

return false;

}

if(descFileName.endsWith(File.separator))

{

System.out.println(descFileName + "为目录，不能创建目录!");

return false;

}

if(!file.getParentFile().exists())

{

//如果文件所在的目录不存在，则创建目录

if(!file.getParentFile().mkdirs())

{

System.out.println("创建文件所在的目录失败!");

return false;

}

}



//创建文件

try

{

if(file.createNewFile())

{

System.out.println(descFileName + "文件创建成功!");

return true;

}

else

{

System.out.println(descFileName + "文件创建失败!");

return false;

}

}

catch(Exception e)

{

e.printStackTrace();

System.out.println(descFileName + "文件创建失败!");

return false;

}



}





/**

*

* 功能描述：创建目录

* @param descDirName 目录名,包含路径

* @return 返回：

* 如果创建成功，则返回true，否则返回false

*/

public static boolean createDirectory(String descDirName)

{

if(!descDirName.endsWith(File.separator))

{

descDirName = descDirName + File.separator;

}

File descDir = new File(descDirName);

if(descDir.exists())

{

System.out.println("目录" + descDirName + "已存在!");

return false;

}

//创建目录

if(descDir.mkdirs())

{

System.out.println("目录" + descDirName + "创建成功!");

return true;

}

else

{

System.out.println("目录" + descDirName + "创建失败!");

return false;

}



}





/**

*

* 功能描述：压缩文件或目录

* @param srcDirName 压缩的根目录

* @param fileName 根目录下的待压缩的文件名或文件夹名，其中*或""表示跟目录下的全部文件

* @param descFileName 目标zip文件

*/

public static void zipFiles(String srcDirName , String fileName , String descFileName)

{

//判断目录是否存在

if(srcDirName == null)

{

System.out.println("文件压缩失败，目录" + srcDirName + "不存在!");

return ;

}

File fileDir = new File(srcDirName);

if(!fileDir.exists() || !fileDir.isDirectory())

{

System.out.println("文件压缩失败，目录" + srcDirName + "不存在!");

return ;

}

String dirPath = fileDir.getAbsolutePath();

File descFile = new File(descFileName);

try

{

ZipOutputStream zouts = new ZipOutputStream(new FileOutputStream(descFile));

if("*".equals(fileName) || "".equals(fileName))

{

FileOperateUtils.zipDirectoryToZipFile(dirPath, fileDir, zouts);

}

else

{

File file = new File(fileDir , fileName);

if(file.isFile())

{

FileOperateUtils.zipFilesToZipFile(dirPath, file, zouts);

}

else

{

FileOperateUtils.zipDirectoryToZipFile(dirPath, file, zouts);

}

}

zouts.close();

System.out.println(descFileName + "文件压缩成功!");

}

catch(Exception e)

{

System.out.println("文件压缩失败：" + e.getMessage());

e.printStackTrace();

}



}





/**

* 功能描述：解压缩ZIP文件，将ZIP文件里的内容解压到descFileName目录下

* @param zipFileName 需要解压的ZIP文件

* @param descFileName 目标文件

*/

public static void unZipFiles(String zipFileName , String descFileName)

{

if(!descFileName.endsWith(File.separator))

{

descFileName = descFileName + File.separator;

}

try

{

//根据ZIP文件创建ZipFile对象

ZipFile zipFile = new ZipFile(zipFileName);

ZipEntry entry = null;

String entryName = null;

String descFileDir = null;

byte[] buf = new byte[4096];

int readByte = 0;

//获取ZIP文件里所有的entry

Enumeration enums = zipFile.entries();

//遍历所有entry

while(enums.hasMoreElements())

{

entry = (ZipEntry)enums.nextElement();

//获得entry的名字

entryName = entry.getName();

descFileDir = descFileName + entryName;

if(entry.isDirectory())

{

//如果entry是一个目录，则创建目录

new File(descFileDir).mkdirs();

continue;

}

else

{

//如果entry是一个文件，则创建父目录

new File(descFileDir).getParentFile().mkdirs();

}

File file = new File(descFileDir);

//打开文件输出流

FileOutputStream fouts = new FileOutputStream(file);

//从ZipFile对象中打开entry的输入流

InputStream ins = zipFile.getInputStream(entry);

while((readByte = ins.read(buf)) != -1)

{

fouts.write(buf, 0, readByte);

}

fouts.close();

ins.close();

}

System.out.println("文件解压成功!");

}

catch(Exception e)

{

System.out.println("文件解压失败：" + e.getMessage());

}



}





/**

*

* 功能描述：将目录压缩到ZIP输出流

* @param dirPath 目录路径

* @param fileDir 文件信息

* @param zouts 输出流

*/

public static void zipDirectoryToZipFile(String dirPath , File fileDir , ZipOutputStream zouts)

{

if(fileDir.isDirectory())

{

File[] files = fileDir.listFiles();

//空的文件夹

if(files.length == 0)

{

//目录信息

ZipEntry entry = new ZipEntry(getEntryName(dirPath , fileDir));

try

{

zouts.putNextEntry(entry);

zouts.closeEntry();

}

catch(Exception e)

{

e.printStackTrace();

}

return ;

}



for(int i = 0 ; i < files.length ; i++)

{

if(files[i].isFile())

{

//如果是文件，则调用文件压缩方法

FileOperateUtils.zipFilesToZipFile(dirPath, files[i], zouts);

}

else

{

//如果是目录，则递归调用

FileOperateUtils.zipDirectoryToZipFile(dirPath, files[i], zouts);

}

}



}



}





/**

*

* 功能描述：将文件压缩到ZIP输出流

* @param dirPath 目录路径

* @param file 文件

* @param zouts 输出流

*/

public static void zipFilesToZipFile(String dirPath , File file , ZipOutputStream zouts)

{

FileInputStream fin = null;

ZipEntry entry = null;

//创建复制缓冲区

byte[] buf = new byte[4096];

int readByte = 0;

if(file.isFile())

{

try

{

//创建一个文件输入流

fin = new FileInputStream(file);

//创建一个ZipEntry

entry = new ZipEntry(getEntryName(dirPath , file));

//存储信息到压缩文件

zouts.putNextEntry(entry);

//复制字节到压缩文件

while((readByte = fin.read(buf)) != -1)

{

zouts.write(buf, 0, readByte);

}

zouts.closeEntry();

fin.close();

System.out.println("添加文件" + file.getAbsolutePath() + "到zip文件中!");

}

catch(Exception e)

{

e.printStackTrace();

}

}



}





/**

*

* 功能描述：获取待压缩文件在ZIP文件中entry的名字，即相对于跟目录的相对路径名

* @param dirPath 目录名

* @param file entry文件名

* @return

*/

private static String getEntryName(String dirPath , File file)

{

if(!dirPath.endsWith(File.separator))

{

dirPath = dirPath + File.separator;

}

String filePath = file.getAbsolutePath();

// 对于目录，必须在entry名字后面加上"/"，表示它将以目录项存储

if(file.isDirectory())

{

filePath += "/";

}

int index = filePath.indexOf(dirPath);



return filePath.substring(index + dirPath.length());

}





}