java文件操作工具类

import java.io.BufferedInputStream;
import java.io.BufferedWriter;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileWriter;
import java.io.IOException;
import java.io.RandomAccessFile;
import java.nio.ByteBuffer;
import java.nio.MappedByteBuffer;
import java.nio.channels.FileChannel;
import java.nio.channels.FileChannel.MapMode;
import java.util.ArrayList;
import java.util.List;
public class FileUtil {
/**
 * 创建目录
 * 
 * @param destDirName
 *            目标目录名
 * @return 目录创建成功返回true，否则返回false
 */
public static boolean exists(String destDir) {
if(null!=destDir&&!destDir.equals("")){
File dir = new File(destDir);
return dir.exists();
}else{
return false;
}
}
/**
 * 创建目录
 * 
 * @param destDirName
 *            目标目录名
 * @return 目录创建成功返回true，否则返回false
 */
public static boolean createDir(String destDirName) {
File dir = new File(destDirName);
if (dir.exists()) {
return false;
}
File parentFile = dir.getParentFile();
if (!parentFile.exists()) {
createDir(parentFile.getAbsolutePath());
}
if (!destDirName.endsWith(File.separator)) {
destDirName = destDirName + File.separator;
}
// 创建单个目录
if (dir.mkdirs()) {
return true;
} else {
return false;
}
}
public static boolean renameFile(String oldPath,String newPath){ 
        if(!oldPath.equals(newPath)){//新的文件名和以前文件名不同时,才有必要进行重命名 
            File oldfile=new File(oldPath); 
            File newfile=new File(newPath); 
            if(!oldfile.exists()){
                return false;//重命名文件不存在
            }
            if(newfile.exists())//若在该目录下已经有一个文件和新文件名相同，则不允许重命名 
             return false;
            else{ 
                oldfile.renameTo(newfile); 
                return true;
            } 
        }else{
        return false;
        }
    }
/**
 * 根据路径删除指定的目录或文件，无论存在与否
 *
 * @param sPath
 *            要删除的目录或文件
 * @return 删除成功返回 true，否则返回 false。
 */
public static boolean DeleteFolder(String sPath) {
boolean flag = false;
File file = new File(sPath);
// 判断目录或文件是否存在
if (!file.exists()) { // 不存在返回 false
return flag;
} else {
// 判断是否为文件
if (file.isFile()) { // 为文件时调用删除文件方法
return deleteFile(sPath);
} else { // 为目录时调用删除目录方法
return deleteDirectory(sPath);
}
}
}
/**
 * 删除单个文件
 * 
 * @param sPath
 *            被删除文件的文件名
 * @return 单个文件删除成功返回true，否则返回false
 */
public static boolean deleteFile(String sPath) {
boolean flag = false;
File file = new File(sPath);
// 路径为文件且不为空则进行删除
if (file.isFile() && file.exists()) {
file.delete();
flag = true;
}
return flag;
}
/**
 * 删除目录（文件夹）以及目录下的文件
 * 
 * @param sPath
 *            被删除目录的文件路径
 * @return 目录删除成功返回true，否则返回false
 */
public static boolean deleteDirectory(String sPath) {
// 如果sPath不以文件分隔符结尾，自动添加文件分隔符
if (!sPath.endsWith(File.separator)) {
sPath = sPath + File.separator;
}
File dirFile = new File(sPath);
// 如果dir对应的文件不存在，或者不是一个目录，则退出
if (!dirFile.exists() || !dirFile.isDirectory()) {
return false;
}
boolean flag = true;
// 删除文件夹下的所有文件(包括子目录)
File[] files = dirFile.listFiles();
for (int i = 0; i < files.length; i++) {
// 删除子文件
if (files[i].isFile()) {
flag = deleteFile(files[i].getAbsolutePath());
if (!flag)
break;
} // 删除子目录
else {
flag = deleteDirectory(files[i].getAbsolutePath());
if (!flag)
break;
}
}
if (!flag)
return false;
// 删除当前目录
if (dirFile.delete()) {
return true;
} else {
return false;
}
}
/**
 * 读取到字节数组1
 * 
 * @param filePath
 *            //路径
 * @throws IOException
 */
public static byte[] getContent(String filePath) throws IOException {
File file = new File(filePath);
long fileSize = file.length();
if (fileSize > Integer.MAX_VALUE) {
System.out.println("file too big...");
return null;
}
FileInputStream fi = new FileInputStream(file);
byte[] buffer = new byte[(int) fileSize];
int offset = 0;
int numRead = 0;
while (offset < buffer.length
&& (numRead = fi.read(buffer, offset, buffer.length - offset)) >= 0) {
offset += numRead;
}
// 确保所有数据均被读取
if (offset != buffer.length) {
throw new IOException("Could not completely read file "
+ file.getName());
}
fi.close();
return buffer;
}
/**
 * 读取到字节数组1
 * 
 * @param filePath
 *            //路径
 * @throws IOException
 */
public static boolean write(String filePath,String content) {
try{
   File file = new File(filePath);
   if (!file.exists()) {
    file.createNewFile();
   }
   FileWriter fw = new FileWriter(file.getAbsoluteFile());
   BufferedWriter bw = new BufferedWriter(fw);
   bw.write(content);
   bw.close();
} catch (IOException e) {
  return false;
}
   return true;
}
/**
 * 读取到字节数组2
 * 
 * @param filePath
 * @return
 * @throws IOException
 */
public static byte[] toByteArray(String filePath) throws IOException {
File f = new File(filePath);
if (!f.exists()) {
throw new FileNotFoundException(filePath);
}
ByteArrayOutputStream bos = new ByteArrayOutputStream((int) f.length());
BufferedInputStream in = null;
try {
in = new BufferedInputStream(new FileInputStream(f));
int buf_size = 1024;
byte[] buffer = new byte[buf_size];
int len = 0;
while (-1 != (len = in.read(buffer, 0, buf_size))) {
bos.write(buffer, 0, len);
}
return bos.toByteArray();
} catch (IOException e) {
e.printStackTrace();
throw e;
} finally {
try {
in.close();
} catch (IOException e) {
e.printStackTrace();
}
bos.close();
}
}
/**
 * 读取到字节数组3
 * 
 * @param filePath
 * @return
 * @throws IOException
 */
public static byte[] toByteArray2(String filePath) throws IOException {
File f = new File(filePath);
if (!f.exists()) {
throw new FileNotFoundException(filePath);
}
FileChannel channel = null;
FileInputStream fs = null;
try {
fs = new FileInputStream(f);
channel = fs.getChannel();
ByteBuffer byteBuffer = ByteBuffer.allocate((int) channel.size());
while ((channel.read(byteBuffer)) > 0) {
// do nothing
// System.out.println("reading");
}
return byteBuffer.array();
} catch (IOException e) {
e.printStackTrace();
throw e;
} finally {
try {
channel.close();
} catch (IOException e) {
e.printStackTrace();
}
try {
fs.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
/**
 * Mapped File way MappedByteBuffer 可以在处理大文件时，提升性能
 * 
 * @param filename
 * @return
 * @throws IOException
 */
public static byte[] toByteArray3(String filePath) throws IOException {
FileChannel fc = null;
try {
fc = new RandomAccessFile(filePath, "r").getChannel();
MappedByteBuffer byteBuffer = fc.map(MapMode.READ_ONLY, 0,
fc.size()).load();
// System.out.println(byteBuffer.isLoaded());
byte[] result = new byte[(int) fc.size()];
if (byteBuffer.remaining() > 0) {
// System.out.println("remain");
byteBuffer.get(result, 0, byteBuffer.remaining());
}
return result;
} catch (IOException e) {
e.printStackTrace();
throw e;
} finally {
try {
fc.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
/**
    * 使用文件通道的方式复制文件
    * @param s
    *            源文件
    * @param t
    *            复制到的新文件
    */
    public static boolean fileCopyChannel(File s, File t) {
    boolean result = false;
        FileInputStream fi = null;
        FileOutputStream fo = null;
        FileChannel in = null;
        FileChannel out = null;
        try {
            fi = new FileInputStream(s);
            fo = new FileOutputStream(t);
            in = fi.getChannel();//得到对应的文件通道
            out = fo.getChannel();//得到对应的文件通道
            in.transferTo(0, in.size(), out);//连接两个通道，并且从in通道读取，然后写入out通道
            result= true;
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                fi.close();
                in.close();
                fo.close();
                out.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return result;
    }
}