/**
* 文件操作大全（文件接口均是使用文件路径名）
* 1）创建文件
* 2）删除文件
* 3）移动文件
* 4）合并文件
* 5）分割文件
* 6）读取文件
* 7）列举文件
* @author Sking
*/
package file;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.RandomAccessFile;
import java.io.Reader;
import java.util.Random;
public class FileUtil {
/***-----------1.创建文件---------***/
/**
* 创建指定文件或目录，成功创建则返回true，否则false，
* 如果指定文件或目录的父目录不存在，则递归创建父目录。
* @param destFile 待创建的指定文件或目录
* @return 成功创建指定文件或目录则返回true，
* 如果目标文件或目录已存在或创建失败，返回false。
*/
public static boolean createFile(String destFile) {
File file = new File(destFile);
if (file.exists()) { //判断该文件是否存在
System.out.println("目标文件已存在!");
return false;//目标文件存在，返回false
}
//目标文件名是以文件分隔符结尾的，则为目录
if (destFile.endsWith(File.separator)) {
if(file.mkdirs()){
System.out.println("目录创建成功！");
return true;
}
}
//判断目标文件所在的目录是否存在
if (!file.getParentFile().exists()) {
//如果目标文件父目录不存在，则创建父目录
System.out.println("父目录不存在，正在创建！");
//递归创建父目录，如果创建失败则返回false
if (!file.getParentFile().mkdirs()) {
System.out.println("父目录创建失败！");
return false;
}
}
//创建目标文件
try {
if (file.createNewFile()) {
System.out.println("创建文件成功！");
return true;
} else {
System.out.println("创建文件失败！");
return false;
}
} catch (IOException e) {
e.printStackTrace();
System.out.println("创建文件失败！" + e.getMessage());
return false;
}
}
/***-----------2.删除文件---------***/
/**
* 删除指定的目录或文件，如果目录不为空则递归删除，
* 成功删除返回true，否则返回false。
* @param fileName 待删除的文件或目录
* @return 成功删除指定的文件或目录返回true，否则返回false
*/
public static boolean deleteFileOrDir(String fileName) {
File file = new File(fileName);
if (!file.exists()) {
System.out.println("待删除的目标文件不存在！");
return false;
} else {
if (file.isFile()) {//删除文件
return deleteFile(fileName);
} else {//删除目录
return deleteDir(fileName);
}
}
}
/**
* 删除指定文件，成功则返回true，否则返回false
* @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("待删除文件不存在！");
return false;
}
}
/**
* 递归删除指定目录，成功则返回true，否则返回false
* @param dir 待删除目录
* @return 成功删除指定目录返回true，否则返回false
*/
public static boolean deleteDir(String dir) {
//如果dir不以文件名称分隔符结尾，自动添加文件分隔符。
if (!dir.endsWith(File.separator)) {
dir = dir + File.separator;
}
File dirFile = new File(dir);
//文件不存在，或者不是一个目录，返回false
if (!dirFile.exists() || (!dirFile.isDirectory())) {
System.out.println("待删除目录不存在！");
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;//遇到一次不成功操作则直接退出，返回false
}
}
else if (files[i].isDirectory()) {//子目录
flag = deleteDir(files[i].getAbsolutePath());
if (!flag) {
break;
}
}
}
if (!flag) {
System.out.println("删除目录失败！");
return false;
}
//删除当前目录
if (dirFile.delete()) {
System.out.println("目录：" + dir + "删除成功！");
return true;
} else {
return false;
}
}
/***-----------3.分割文件---------***/
/**
* 分割文件操作
* @param name 待分割的文件名
* @param size 分割后的小文件大小，字节为单位，
* 如果为负数，则默认大小为源文件的一半。
* @return 分割后的文件路径名数组
* @throws Exception 指定文件不存在，抛出异常
*/
public static String[] divide(String name, long size) throws Exception {
File file = new File(name);
if (!file.exists() || (!file.isFile())) {
throw new Exception("指定文件不存在！");
}
File parentFile = file.getParentFile();// 父目录抽象路径
long fileLength = file.length();
if (size <= 0) {
size = fileLength / 2;
}
int num=(int)(fileLength/size);
if(fileLength % size != 0)
num++;//分割后的小文件个数
String[] fileNames = new String[num];
FileInputStream in = new FileInputStream(file);
long end = 0;
int begin = 0;
// 根据要分割的数目输出文件
int index=file.getName().lastIndexOf('.');
String suffix=file.getName().substring(index);//文件后缀
for (int i = 0; i < num; i++) {
String fileName=file.getName().substring(0,index)+i+suffix;
File outFile = new File(parentFile, fileName);
FileOutputStream out = new FileOutputStream(outFile);
end += size;//将结束下标后移size
end = (end > fileLength) ? fileLength : end;
for (; begin < end; begin++) {
out.write(in.read());
}
out.close();
fileNames[i] = outFile.getAbsolutePath();
}
in.close();
return fileNames;
}
/***-----------4.合并文件---------***/
/**
* 合并文件操作
* @param fileNames 待合并的文件路径名列表
* @param TargetFileName 合并后文件的路径名
* @throws Exception IO异常
*/
public static void merge(String[] fileNames, String TargetFileName)
throws Exception{
File fin = null;
File fout = new File(TargetFileName);
FileOutputStream out = new FileOutputStream(fout);
for (int i = 0; i < fileNames.length; i++) {
fin = new File(fileNames[i]);
FileInputStream in = new FileInputStream(fin);
int c;
while ((c = in.read()) != -1) {
out.write(c);
}
in.close();
}
out.close();
}
/***-----------5.移动文件---------***/
/**
* 移动指定的文件，已存在目标文件则不覆盖
* @param sourceFileName 源文件
* @param targetFileName 目标文件
* @return 移动成功则返回true，否则false
*/
public static boolean moveFile(String sourceFileName, String targetFileName) {
return moveFile(sourceFileName, targetFileName, false);
}
/**
* 移动源文件sourceFile到目标文件targetFile，
* 根据isOverlay选择在目标文件已存在情况下是否进行覆盖
* @param sourceFile 源文件
* @param targetFile 目标文件
* @param isOverlay 是否进行覆盖的标志
* @return 如果成功移动文件返回true，否则返回false
*/
public static boolean moveFile(String sourceFile, String targetFile,
boolean isOverlay) {
// 判断原文件是否存在
File source = new File(sourceFile);
if (!source.exists()) {
System.out.println("源文件不存在！");
return false;
} else if (!source.isFile()) {
System.out.println("源文件不是文件！");
return false;
}
File target = new File(targetFile);
if (target.exists()) {//目标文件是否存在
if (isOverlay) {//目标文件存在，允许覆盖目标文件
// 删除已存在的目标文件，无论目标文件是目录还是文件
System.out.println("目标文件已存在，准备删除它！");
if (!deleteFileOrDir(targetFile)) {
System.out.println("目标文件删除失败");
return false;
}
} else {//目标文件已存在，且不进行覆盖，则返回false
System.out.println("文件移动失败，目标文件已存在！");
return false;
}
} else {
if (!target.getParentFile().exists()) {
// 如果目标文件父目录不存在，则创建目录
System.out.println("目标文件父目录不存在，正在创建！");
if (!target.getParentFile().mkdirs()) {
System.out.println("创建目标文件父目录失败！");
return false;
}
}
}
// 调用函数renameTo()移动原文件至目标文件
if (source.renameTo(target)) {
System.out.println("移动文件成功！");
return true;
} else {
System.out.println("移动文件失败！");
return false;
}
}
/**
*移动源目录到目标目录，不覆盖已存在目录
* @param sourceDirName 源目录
* @param targetDirName 目标目录
* @return 成功移动目录则返回true，否则返回false
*/
public static boolean moveDir(String sourceDirName, String targetDirName) {
return moveDir(sourceDirName, targetDirName, false);
}
/**
* 移动源目录到目标目录，根据标志 isOverlay确定是否覆盖已存在目录
* @param sourceDirName 源目录
* @param targetDirName 目标目录
* @param isOverlay 是否覆盖已存在目录的标志
* @return 成功移动则返回true，否则返回false
*/
public static boolean moveDir(String sourceDirName, String targetDirName,
boolean isOverlay) {
// 判断原目录是否存在
File sourceDir = new File(sourceDirName);
if (!sourceDir.exists()) {
System.out.println("原始目录不存在！");
return false;
} else if (!sourceDir.isDirectory()) {
System.out.println("源不是目录！");
return false;
}
//自动添加文件分隔符
if (!targetDirName.endsWith(File.separator)) {
targetDirName = targetDirName + File.separator;
}
File targetDir = new File(targetDirName);
if (targetDir.exists()) {//目标文件夹存在，
if (isOverlay) {//是否覆盖
System.out.println("目录已存在，准备删除它！");
if (!deleteFileOrDir(targetDirName)) {
System.out.println("删除已存在目录失败！");
}
} else {
System.out.println("目录已存在！");
return false;
}
} else {// 创建目标目录
System.out.println("该目录不存在，正在创建！");
if (!targetDir.mkdirs()) {
System.out.println("创建目标目录失败！");
return false;
}
}
boolean flag = true;
//移动原目录下的文件和子目录到目标目录下
File[] files = sourceDir.listFiles();
for (int i = 0; i < files.length; i++) {
if (files[i].isFile()) {// 移动子文件
//构造移动后新生成的文件路径
flag = moveFile(files[i].getAbsolutePath(),
targetDirName + files[i].getName(), isOverlay);
if (!flag) {
break;
}
}
else if (files[i].isDirectory()) {// 移动子目录
flag = moveDir(files[i].getAbsolutePath(), targetDirName
+ files[i].getName(), isOverlay);
if (!flag) {
break;
}
}
}
if (!flag) {
System.out.println("目录移动失败！");
return false;
}
// 删除原目录
if (deleteDir(sourceDirName)) {
System.out.println("目录移动成功！");
return true;
} else {
System.out.println("目录移动失败！");
return false;
}
}
/***-----------6.列举文件---------***/
/**
* 打印指定目录的目录结构
* @param dirName 指定目录
* @param deep 深度，实现缩进打印
*/
public static void getAllFiles(String dirName, int deep) {
//如果dir不以文件分隔符结尾，自动添加文件分隔符。
if (!dirName.endsWith(File.separator)) {
dirName = dirName + File.separator;
}
File dirFile = new File(dirName);
//文件不存在，或不是目录，则退出
if (!dirFile.exists() || (!dirFile.isDirectory())) {
System.out.println("找不到指定目录");
return;
}
//列出目录下所有文件（包括子目录）
File[] fileArray = dirFile.listFiles();
for (int i = 0; i < fileArray.length; i++) {
if (fileArray[i].isFile()) {
// 只打印文件名，而非完整路径
print(deep, fileArray[i].getName());
} else if (fileArray[i].isDirectory()) {
print(deep, fileArray[i].getName());//目录
getAllFiles(fileArray[i].getAbsolutePath(), deep + 1);
}
}
}
/**
* 实现层次缩进打印目录结构
* @param deep 深度
* @param msg 消息
*/
private static void print(int deep, String msg) {
for (int i = 1; i <= deep; i++)
System.out.print(" ");
System.out.println(msg);
}
/***-----------7.读取文件---------***/
/**1. 按字节读取文件，常用于读二进制文件，如图片、声音、影像文件等*/
/**
* 1.1 按字节读取文件， 一次读取一个字节
* @param fileName 文件路径名
*/
public static void readFileByByte(String fileName) {
File file = new File(fileName);
FileInputStream in = null;
try {
in = new FileInputStream(file);
int tempbyte;
//一次读取一个字节的方式
while ((tempbyte = in.read()) != -1) {
System.out.write(tempbyte);
}
in.close();
} catch (IOException e) {
e.printStackTrace();
return;
}finally {
if (in != null) {
try {
in.close();
} catch (IOException e1) {
}
}
}
}
/**
* 1.2 按字节读取文件， 一次读取多个字节
* @param fileName 文件路径名
*/
public static void readFileByBytes(String fileName) {
File file = new File(fileName);
FileInputStream in = null;
try {
in = new FileInputStream(file);
// 一次读取多个字节的方式
byte[] tempbytes = new byte[100];
int byteread = 0;
in = new FileInputStream(fileName);
// 读入多个字节到字节数组中，byteread为一次读入的字节数
while ((byteread = in.read(tempbytes)) != -1) {
System.out.write(tempbytes, 0, byteread);
}
} catch (Exception e1) {
e1.printStackTrace();
} finally {
if (in != null) {
try {
in.close();
} catch (IOException e1) {
}
}
}
}
/**2. 以字符为单位读取文件，常用于读文本，数字等类型文件*/
/**
* 2.1 以字符为单位读取文件，一次读取一个字符
* @param fileName 文件路径名
*/
public static void readFileByChar(String fileName) {
File file = new File(fileName);
Reader reader = null;
try {
reader = new InputStreamReader(new FileInputStream(file));
int tempchar;
//一次读一个字符
while ((tempchar = reader.read()) != -1) {
// 对于windows下，\r\n这两个字符在一起时，表示一个换行。
// 但如果这两个字符分开显示时，会换两次行。
// 因此，屏蔽掉\r，或者屏蔽\n。否则，将会多出很多空行。
if (((char) tempchar) != '\r') {
System.out.print((char) tempchar);
}
}
reader.close();
} catch (Exception e) {
e.printStackTrace();
}finally {
if (reader != null) {
try {
reader.close();
} catch (IOException e1) {
}
}
}
}
/**
* 2.2 以字符为单位读取文件，一次读取多个字符
* @param fileName 文件路径名
*/
public static void readFileByChars(String fileName) {
File file = new File(fileName);
Reader reader = null;
try {
reader = new InputStreamReader(new FileInputStream(file));
// 一次读多个字符
char[] tempchars = new char[30];
int charread = 0;
reader = new InputStreamReader(new FileInputStream(fileName));
// 读入多个字符到字符数组中，charread为一次读取字符数
while ((charread = reader.read(tempchars)) != -1) {
// 同样屏蔽掉\r不显示
if ((charread == tempchars.length)
&& (tempchars[tempchars.length - 1] != '\r')) {
System.out.print(tempchars);
} else {
for (int i = 0; i < charread; i++) {
if (tempchars[i] == '\r') {
continue;
} else {
System.out.print(tempchars[i]);
}
}
}
}
} catch (Exception e1) {
e1.printStackTrace();
} finally {
if (reader != null) {
try {
reader.close();
} catch (IOException e1) {
}
}
}
}
/**
* 3. 以行为单位读取文件，常用于读面向行的格式化文件
* @param fileName 文件路径名
*/
public static void readFileByLines(String fileName) {
File file = new File(fileName);
BufferedReader reader = null;
try {
reader = new BufferedReader(new FileReader(file));
String tempString = null;
int line = 1;
// 一次读入一行，直到读入null为文件结束
while ((tempString = reader.readLine()) != null) {
// 显示行号
System.out.println("line " + line + ": " + tempString);
line++;
}
reader.close();
} catch (IOException e) {
e.printStackTrace();
} finally {
if (reader != null) {
try {
reader.close();
} catch (IOException e1) {
}
}
}
}
/**
* 4. 随机读取文件内容
* @param fileName 文件路径名
*/
public static void readFileByRandomAccess(String fileName) {
RandomAccessFile randomFile = null;
try {
// 打开一个随机访问文件流，按只读方式
randomFile = new RandomAccessFile(fileName, "r");
// 文件长度，字节数
long fileLength = randomFile.length();
// 读文件的起始位置
Random r=new Random();
//随机初始读取位置
int beginIndex=r.nextInt((int)fileLength);
// 将读文件的开始位置移到beginIndex位置。
randomFile.seek(beginIndex);
byte[] bytes = new byte[10];
int byteread = 0;
// 一次读10个字节，如果文件内容不足10个字节，则读剩下的字节。
// 将一次读取的字节数赋给byteread
while ((byteread = randomFile.read(bytes)) != -1) {
System.out.write(bytes, 0, byteread);
}
} catch (IOException e) {
e.printStackTrace();
} finally {
if (randomFile != null) {
try {
randomFile.close();
} catch (IOException e1) {
}
}
}
}
}
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
