文件遍历器
获取指定目录及其子目录下的指定格式文件的文件
FileUtils.listDirFiles(path, null,true/false);1
FileUtils.listDirFiles(path, null,true/false);
FileUtils.listDirFiles(path, new MyFilenameFilter(".java", 1024), false);x
1
FileUtils.listDirFiles(path, new MyFilenameFilter(".java", 1024), false);
打印文件目录
获取指定目录及其子目录下的指定格式文件的文件名，并对文件名进行格式化
FileUtils.listDirFilesNames(path, null, true, true, 1);x
1
FileUtils.listDirFilesNames(path, null, true, true, 1);
FileUtils.listDirFilesNames(path, null, true, true, 10);x
1
FileUtils.listDirFilesNames(path, null, true, true, 10);
FileUtils.listDirFilesNames(path, null, true, false, 4);FileUtils.listDirFilesNames(path, null, true, false, 4);
x
1
FileUtils.listDirFilesNames(path, null, true, false, 4);
FileUtils.listDirFilesNames(path, null, false, false, 4);x
1
FileUtils.listDirFilesNames(path, null, false, false, 4);
FileUtils.listDirFilesNames(path, new MyFilenameFilter(".java", 1024), false, false, 4);x
1
FileUtils.listDirFilesNames(path, new MyFilenameFilter(".java", 1024), false, false, 4);
删除目录下的文件
FileUtils.deleateFiles(path, true);1
FileUtils.deleateFiles(path, true);
FileUtils.deleateFiles(path, false);1
FileUtils.deleateFiles(path, false);
源码
Test
public class Test {
public static void main(String[] args) {
String path = "D:/lizhifm/voicebusiness/carfm";
FileUtils.listDirFiles(path, null, true);
FileUtils.listDirFilesNames(path, new MyFilenameFilter(".java", 1024), true, false, 4);
FileUtils.deleateFiles(path, true);
}
}Test
x
1
public class Test {
2
public static void main(String[] args) {
3
String path = "D:/lizhifm/voicebusiness/carfm";
4
FileUtils.listDirFiles(path, null, true);
5
FileUtils.listDirFilesNames(path, new MyFilenameFilter(".java", 1024), true, false, 4);
6
FileUtils.deleateFiles(path, true);
7
}
8
}
MyFilenameFilter
public class MyFilenameFilter implements FilenameFilter {
private String type;
private long size;
/**
* 检索规则
* @param type 指定后缀名的文件
* @param size 不小于指定大小的文件，单位：字节
*/
public MyFilenameFilter(String type, long size) {
this.type = type;
this.size = size;
}
public boolean accept(File dir, String name) {
long fileSize = new File(dir, name).length();
return fileSize >= size && name.endsWith(type);
}
}x
1
public class MyFilenameFilter implements FilenameFilter {
2
private String type;
3
private long size;
4
5
/**
6
* 检索规则
7
* @param type 指定后缀名的文件
8
* @param size 不小于指定大小的文件，单位：字节
9
*/
10
public MyFilenameFilter(String type, long size) {
11
this.type = type;
12
this.size = size;
13
}
14
15
public boolean accept(File dir, String name) {
16
long fileSize = new File(dir, name).length();
17
return fileSize >= size && name.endsWith(type);
18
}
19
}
FileUtils
public class FileUtils {
/**
* 获取指定目录及其子目录下的指定格式文件的文件
*
* @param dirPath 要遍历的目录，必须是一个目录
* @param filter 只遍历目录中的指定类型的文件，如果要遍历所有文件请设为 null
* @param isContainDir 是否包含目录文件。注意，这里的意思并不是：是否遍历目录下的文件
*/
public static List<File> listDirFiles(String dirPath, FilenameFilter filter, boolean isContainDir) {
List<File> files = new ArrayList<>();
getDirFiles(files, dirPath, filter, isContainDir);
System.out.println("------------------------【文件总数：" + files.size() + "】------------------------");
for (File file : files) {
if (file.isDirectory()) {
System.out.println(file.getName());
} else {
System.out.println(file.getName() + "\t" + getDataSize(file.length()));
}
}
return files;
}
/**
* 获取指定目录及其子目录下的指定格式文件的文件名，并对文件名进行格式化
*
* @param dirPath 要遍历的目录，必须是一个目录
* @param filter 只遍历目录中的指定类型文件，如果要遍历所有文件请设为null
* @param isFormat 是否格式化
* @param isShowNum 是否显示编号；isFormat=true时有效
* @param maxLeval 要遍历的最大层级（多少层目录）；isFormat=true时有效
*/
public static List<String> listDirFilesNames(String dirPath, FilenameFilter filter, boolean isFormat, boolean isShowNum, int maxLeval) {
List<String> list = new ArrayList<>();
getDirFormatFilesNames(list, dirPath, filter, isFormat, isShowNum, maxLeval, 0, null);
System.out.println("------------------------【文件总数：" + list.size() + "】------------------------");
for (String path : list) {
System.out.println(path);
}
return list;
}
/**
* 删除一个目录下的所有文件
*
* @param dirPath 要删除的目录，可以是一个文件
* @param isDeleateDir 是否删除目录，false时只删除目录下的文件而不删除目录
*/
public static void deleateFiles(String dirPath, boolean isDeleateDir) {
if (Objects.isNull(dirPath)) {
return;
}
File dirFile = new File(dirPath);
if (dirFile.isDirectory()) {//是目录
File[] files = dirFile.listFiles();//如果是文件的话，调用listFiles()返回空null
if (files != null) {
for (File file : files) {
deleateFiles(file.getAbsolutePath(), isDeleateDir);//递归
}
}
if (isDeleateDir) {
System.out.println("\t★ 目录 " + dirFile.getAbsolutePath() + " 删除结果：" + (dirFile.delete() ? "成功" : "失败"));//删除文件后再删除目录
}
} else {//是文件
System.out.println("文件 " + dirFile.getAbsolutePath() + " 删除结果：" + (dirFile.delete() ? "成功" : "失败"));
}
}
/**
* 格式化文件大小
* @param size 文件大小
*/
public static String getDataSize(long size) {
DecimalFormat formater = new DecimalFormat("####.00");
if (size < 1024) return size + "B";
else if (size < Math.pow(1024, 2)) return formater.format(size * Math.pow(1024, -1)) + "KB";
else if (size < Math.pow(1024, 3)) return formater.format(size * Math.pow(1024, -2)) + "MB";
else if (size < Math.pow(1024, 4)) return formater.format(size * Math.pow(1024, -3)) + "GB";
else if (size < Math.pow(1024, 5)) return formater.format(size * Math.pow(1024, -4)) + "TB";
else return "";
}
/**
* 对指定目录中的文件进行深度遍历，并按照指定过滤器进行过滤，将过滤后的内容存储到一个指定的集合中
*
* @param fileList 将结果保存到指定的集合中。由于要递归遍历，不能定义为局部变量，否则每次递归时都是把结果放到了一个新的集合中
* @param dirPath 要遍历的目录，必须是一个目录
* @param filter 只遍历目录中的指定类型的文件，如果要遍历所有文件请设为 null
* @param isContainDir 是否包含目录文件。注意，这里的意思并不是：是否遍历目录下的文件
*/
private static void getDirFiles(List<File> fileList, String dirPath, FilenameFilter filter, boolean isContainDir) {
if (Objects.isNull(fileList) || Objects.isNull(dirPath)) {
return;
}
File dirFile = new File(dirPath);
if (!dirFile.exists() || !dirFile.isDirectory()) {
return;
}
File[] files = dirFile.listFiles();//也可以使用dir.listFiles(filter)在获取列表时直接过滤，注意这种方式检索时不要遗漏了目录文件
if (files == null) {
return;
}
for (File file : files) {
if (file.isDirectory()) {
if (isContainDir) {
fileList.add(file);
}
getDirFiles(fileList, file.getAbsolutePath(), filter, isContainDir);//递归
} else {
if (filter == null || filter.accept(dirFile, file.getName())) {//是否满足过滤规则
fileList.add(file);
}
}
}
}
/**
* 获取指定目录及其子目录下的指定格式文件的文件名，并对文件名进行格式化，并存储到一个指定的集合中
*
* @param filePathList 将结果保存到指定的集合中
* @param dirPath 要遍历的目录，必须是一个目录
* @param filter 只遍历目录中的指定类型文件，如果要遍历所有文件请设为null
* @param isFormat 是否格式化
* @param isShowNum 是否显示编号；isFormat=true时有效
* @param maxLeval 要遍历的最大层级（多少层目录）；isFormat=true时有效
* @param curLeval 记录当前递归所在层级；isFormat=true时有效
* @param indexBegin 记录当前递归到的文件编号的前缀；isFormat=true 并且 isShowNum=true 时有效
*/
private static void getDirFormatFilesNames(List<String> filePathList, String dirPath, FilenameFilter filter, boolean isFormat, boolean isShowNum,
int maxLeval, int curLeval, String indexBegin) {
if (Objects.isNull(filePathList) || Objects.isNull(dirPath)) {
return;
}
File dirFile = new File(dirPath);
if (!dirFile.exists() || !dirFile.isDirectory()) {
return;
}
if (curLeval < maxLeval) {
curLeval++;
File[] files = dirFile.listFiles();
if (files == null) {
return;
}
StringBuilder curIndex = new StringBuilder();
for (int x = 0, y = files.length; x < y; x++) {
StringBuilder filePathBuilder = new StringBuilder();
if (isFormat) {//格式化
filePathBuilder.append(getSpace(curLeval));//缩进
if (isShowNum) {//显示序号
curIndex = new StringBuilder();
if (!Objects.isNull(indexBegin)) {
curIndex.append(indexBegin).append(".");
}
curIndex.append(x + 1);
filePathBuilder.append(curIndex).append(" ");//序号
}
}
filePathBuilder.append(files[x].getAbsolutePath());//路径
if (filter == null || filter.accept(dirFile, files[x].getName())) {//是否满足过滤规则
filePathList.add(filePathBuilder.toString());
}
if (files[x].isDirectory()) {//如果是目录，则递归
getDirFormatFilesNames(filePathList, files[x].getAbsolutePath(), filter, isFormat, isShowNum, maxLeval, curLeval, curIndex.toString());//递归
}
}
}
}
/***
* 格式化目录
* @param level 目录层次，也即"| _ _"的个数
*/
private static String getSpace(int level) {
StringBuilder sb = new StringBuilder();
for (int x = 1; x < level; x++) {
sb.append(" ").append("|").append("\t").append(" ");
}
return sb.toString();
}
}183
1
public class FileUtils {
2
/**
3
* 获取指定目录及其子目录下的指定格式文件的文件
4
*
5
* @param dirPath 要遍历的目录，必须是一个目录
6
* @param filter 只遍历目录中的指定类型的文件，如果要遍历所有文件请设为 null
7
* @param isContainDir 是否包含目录文件。注意，这里的意思并不是：是否遍历目录下的文件
8
*/
9
public static List<File> listDirFiles(String dirPath, FilenameFilter filter, boolean isContainDir) {
10
List<File> files = new ArrayList<>();
11
getDirFiles(files, dirPath, filter, isContainDir);
12
System.out.println("------------------------【文件总数：" + files.size() + "】------------------------");
13
for (File file : files) {
14
if (file.isDirectory()) {
15
System.out.println(file.getName());
16
} else {
17
System.out.println(file.getName() + "\t" + getDataSize(file.length()));
18
}
19
}
20
return files;
21
}
22
23
/**
24
* 获取指定目录及其子目录下的指定格式文件的文件名，并对文件名进行格式化
25
*
26
* @param dirPath 要遍历的目录，必须是一个目录
27
* @param filter 只遍历目录中的指定类型文件，如果要遍历所有文件请设为null
28
* @param isFormat 是否格式化
29
* @param isShowNum 是否显示编号；isFormat=true时有效
30
* @param maxLeval 要遍历的最大层级（多少层目录）；isFormat=true时有效
31
*/
32
public static List<String> listDirFilesNames(String dirPath, FilenameFilter filter, boolean isFormat, boolean isShowNum, int maxLeval) {
33
List<String> list = new ArrayList<>();
34
getDirFormatFilesNames(list, dirPath, filter, isFormat, isShowNum, maxLeval, 0, null);
35
36
System.out.println("------------------------【文件总数：" + list.size() + "】------------------------");
37
for (String path : list) {
38
System.out.println(path);
39
}
40
return list;
41
}
42
43
/**
44
* 删除一个目录下的所有文件
45
*
46
* @param dirPath 要删除的目录，可以是一个文件
47
* @param isDeleateDir 是否删除目录，false时只删除目录下的文件而不删除目录
48
*/
49
public static void deleateFiles(String dirPath, boolean isDeleateDir) {
50
if (Objects.isNull(dirPath)) {
51
return;
52
}
53
File dirFile = new File(dirPath);
54
if (dirFile.isDirectory()) {//是目录
55
File[] files = dirFile.listFiles();//如果是文件的话，调用listFiles()返回空null
56
if (files != null) {
57
for (File file : files) {
58
deleateFiles(file.getAbsolutePath(), isDeleateDir);//递归
59
}
60
}
61
if (isDeleateDir) {
62
System.out.println("\t★ 目录 " + dirFile.getAbsolutePath() + " 删除结果：" + (dirFile.delete() ? "成功" : "失败"));//删除文件后再删除目录
63
}
64
} else {//是文件
65
System.out.println("文件 " + dirFile.getAbsolutePath() + " 删除结果：" + (dirFile.delete() ? "成功" : "失败"));
66
}
67
}
68
69
/**
70
* 格式化文件大小
71
* @param size 文件大小
72
*/
73
public static String getDataSize(long size) {
74
DecimalFormat formater = new DecimalFormat("####.00");
75
if (size < 1024) return size + "B";
76
else if (size < Math.pow(1024, 2)) return formater.format(size * Math.pow(1024, -1)) + "KB";
77
else if (size < Math.pow(1024, 3)) return formater.format(size * Math.pow(1024, -2)) + "MB";
78
else if (size < Math.pow(1024, 4)) return formater.format(size * Math.pow(1024, -3)) + "GB";
79
else if (size < Math.pow(1024, 5)) return formater.format(size * Math.pow(1024, -4)) + "TB";
80
else return "";
81
}
82
83
/**
84
* 对指定目录中的文件进行深度遍历，并按照指定过滤器进行过滤，将过滤后的内容存储到一个指定的集合中
85
*
86
* @param fileList 将结果保存到指定的集合中。由于要递归遍历，不能定义为局部变量，否则每次递归时都是把结果放到了一个新的集合中
87
* @param dirPath 要遍历的目录，必须是一个目录
88
* @param filter 只遍历目录中的指定类型的文件，如果要遍历所有文件请设为 null
89
* @param isContainDir 是否包含目录文件。注意，这里的意思并不是：是否遍历目录下的文件
90
*/
91
private static void getDirFiles(List<File> fileList, String dirPath, FilenameFilter filter, boolean isContainDir) {
92
if (Objects.isNull(fileList) || Objects.isNull(dirPath)) {
93
return;
94
}
95
File dirFile = new File(dirPath);
96
if (!dirFile.exists() || !dirFile.isDirectory()) {
97
return;
98
}
99
100
File[] files = dirFile.listFiles();//也可以使用dir.listFiles(filter)在获取列表时直接过滤，注意这种方式检索时不要遗漏了目录文件
101
if (files == null) {
102
return;
103
}
104
for (File file : files) {
105
if (file.isDirectory()) {
106
if (isContainDir) {
107
fileList.add(file);
108
}
109
getDirFiles(fileList, file.getAbsolutePath(), filter, isContainDir);//递归
110
} else {
111
if (filter == null || filter.accept(dirFile, file.getName())) {//是否满足过滤规则
112
fileList.add(file);
113
}
114
}
115
}
116
}
117
118
/**
119
* 获取指定目录及其子目录下的指定格式文件的文件名，并对文件名进行格式化，并存储到一个指定的集合中
120
*
121
* @param filePathList 将结果保存到指定的集合中
122
* @param dirPath 要遍历的目录，必须是一个目录
123
* @param filter 只遍历目录中的指定类型文件，如果要遍历所有文件请设为null
124
* @param isFormat 是否格式化
125
* @param isShowNum 是否显示编号；isFormat=true时有效
126
* @param maxLeval 要遍历的最大层级（多少层目录）；isFormat=true时有效
127
* @param curLeval 记录当前递归所在层级；isFormat=true时有效
128
* @param indexBegin 记录当前递归到的文件编号的前缀；isFormat=true 并且 isShowNum=true 时有效
129
*/
130
private static void getDirFormatFilesNames(List<String> filePathList, String dirPath, FilenameFilter filter, boolean isFormat, boolean isShowNum,
131
int maxLeval, int curLeval, String indexBegin) {
132
if (Objects.isNull(filePathList) || Objects.isNull(dirPath)) {
133
return;
134
}
135
File dirFile = new File(dirPath);
136
if (!dirFile.exists() || !dirFile.isDirectory()) {
137
return;
138
}
139
140
if (curLeval < maxLeval) {
141
curLeval++;
142
File[] files = dirFile.listFiles();
143
if (files == null) {
144
return;
145
}
146
StringBuilder curIndex = new StringBuilder();
147
for (int x = 0, y = files.length; x < y; x++) {
148
StringBuilder filePathBuilder = new StringBuilder();
149
if (isFormat) {//格式化
150
filePathBuilder.append(getSpace(curLeval));//缩进
151
if (isShowNum) {//显示序号
152
curIndex = new StringBuilder();
153
if (!Objects.isNull(indexBegin)) {
154
curIndex.append(indexBegin).append(".");
155
}
156
curIndex.append(x + 1);
157
filePathBuilder.append(curIndex).append(" ");//序号
158
}
159
}
160
filePathBuilder.append(files[x].getAbsolutePath());//路径
161
162
if (filter == null || filter.accept(dirFile, files[x].getName())) {//是否满足过滤规则
163
filePathList.add(filePathBuilder.toString());
164
}
165
if (files[x].isDirectory()) {//如果是目录，则递归
166
getDirFormatFilesNames(filePathList, files[x].getAbsolutePath(), filter, isFormat, isShowNum, maxLeval, curLeval, curIndex.toString());//递归
167
}
168
}
169
}
170
}
171
172
/***
173
* 格式化目录
174
* @param level 目录层次，也即"| _ _"的个数
175
*/
176
private static String getSpace(int level) {
177
StringBuilder sb = new StringBuilder();
178
for (int x = 1; x < level; x++) {
179
sb.append(" ").append("|").append("\t").append(" ");
180
}
181
return sb.toString();
182
}
183
}
2017-12-18
时间： 2024-10-07 12:21:18