由于工作需要，写了一个关于支持通配符的批量删除文件或文件夹

实习中，公司需要支持如下格式的删除文件：

"E:\DelFIle\Test\test*.txt"或者类似的，反正带*号的删除。

 

话不多说直接上代码，希望你们用到的时候有个参考。

 

[html]  view plain copy

1. package com.covics.zfh;  
2.   
3. import java.io.File;  
4. import java.io.FilenameFilter;  
5. /**  
6.  * 实现带*号的删除文件  
7.  * @author doudou  
8.  *  
9.  */  
10. public class TestDeleteFile {  
11.   
12.     public static void main(String args[]) {  
13.          boolean delFile =  
14.          deleteFileWithSign("E:\\fileDeleteTest\\test\\t*ve.txt");  
15.          System.out.println("main---->"+delFile);  
16.     }  
17.   
18.     /**  
19.      * 删除带*的文件  
20.      * @param fileName  
21.      * @return  
22.      */  
23.     public static boolean deleteFileWithSign(String fileName) {  
24.         // 文件夹名称  
25.         String dirName = "";  
26.         // 要删除的文件类型  
27.         String fileType = "";  
28.         // 不带后缀的文件名  
29.         String nameWithoutType = "";  
30.         // *号个数  
31.         int num = 0;  
32.         if (null == fileName || "".equals(fileName)) {  
33.             return false;  
34.         }  
35.         int index = fileName.lastIndexOf("\\") + 1;  
36.         nameWithoutType = fileName.substring(index, fileName.lastIndexOf("."));  
37.         fileType = fileName  
38.                 .substring(fileName.lastIndexOf("."), fileName.length());  
39.           
40.         dirName = fileName.substring(0, index);  
41.         File dir = new File(dirName);  
42.         System.out.println("dir:"+dir);  
43.         System.out.println("exits"+dir.exists());  
44.         System.out.println("dir.isDirectory()"+dir.isDirectory());  
45.         if (!dir.exists() || !dir.isDirectory()) {  
46.             return false;  
47.         }  
48.         // *号的位置  
49.         int start = -1, end = -1;  
50.         start = nameWithoutType.indexOf("*");  
51.         end = nameWithoutType.lastIndexOf("*");  
52.           
53.         int length = nameWithoutType.length();  
54.         for (int i=0;i<length;i++) {  
55.             if ('*' == nameWithoutType.charAt(i)) {  
56.                 num++;  
57.             }  
58.         }  
59.         System.out.println("num---->"+num);  
60.           
61.         // 删除的类型  
62.         int delType = 0;  
63.         switch (num) {  
64.         case 0 :  
65.             return deleteFile(fileName);  
66.               
67.         case 1 : // 只有一个*号的情况  
68.             if (0==start) { // 在开始的位置  
69.                 delType = 1; // 只调用endWith方法  
70.             } else if (length-1 == start) { // 在结束的位置  
71.                 delType = 2; // 只调用startWith方法  
72.             } else {  // 在中间  
73.                 delType = 3; // 只调用contain方法  
74.             }  
75.             break;  
76.               
77.         default : // 有两个或多个*号的情况  
78.             if (0 == start && length-1 == end) { // 在开始的位置和结束的位置都有*号  
79.                 delType = 4; // 只调用contain方法  
80.             } else if (0 == start && length-1 != end) { // 开始的位置有*号且结束的位置没有*号  
81.                 delType = 5; // 调用contain和endWith方法  
82.             } else if (0 != start && length-1 == end) { // 开始的位置没有*号且结束的位置有*号  
83.                 delType = 6; // 调用startWith和contain方法  
84.             } else { // *号在中间 的情况（开始和结束都没有*号）  
85.                 delType = 7; // 只调用contain方法  
86.             }  
87.             break;  
88.         }  
89.           
90.         boolean flag = false;  
91.         String[] names = dir  
92.                 .list(new DelFileFilter(nameWithoutType, fileType, delType));  
93.         System.out.println("names.length---->"+names.length);  
94.         for (int i = 0; i < names.length; i++) {  
95.             System.out.println("f--names-->"+dirName+names[i]);  
96.             File f = new File(dirName + names[i]);  
97.             if (!f.exists() || !f.isFile()) {  
98.                 return false;  
99.             }  
100.             flag = deleteFile(f.getAbsolutePath());  
101.             if (!flag) {  
102.                 break;  
103.             }  
104.         }  
105.         return flag;  
106.     }  
107.   
108.     /**  
109.      * 删除单个文件  
110.      *   
111.      * @param fileName  
112.      * @return  
113.      */  
114.     public static boolean deleteFile(String fileName) {  
115.         File file = new File(fileName);  
116.         if (file.isFile() && file.exists()) {  
117.             file.delete();  
118.             return true;  
119.         }  
120.         return false;  
121.     }  
122.   
123.     /**  
124.      * 删除文件夹  
125.      *   
126.      * @param dir  
127.      * @return  
128.      */  
129.     public static boolean deleteDir(String dir) {  
130.         // 判断是否有带文件夹符号。  
131.         if (!dir.endsWith(File.separator)) {  
132.             dir = dir + File.separator;  
133.         }  
134.         File file = new File(dir);  
135.         if (!file.isDirectory() || !file.exists()) {  
136.             return false;  
137.         }  
138.         boolean flag = true;  
139.         File[] files = file.listFiles();  
140.         for (int i = 0; i < files.length; i++) {  
141.             if (files[i].isFile()) { // 删除文件  
142.                 flag = deleteFile(files[i].getAbsolutePath());  
143.                 if (!flag) {  
144.                     break;  
145.                 }  
146.             } else if (files[i].isDirectory()) { // 删除文件夹  
147.                 flag = deleteDir(files[i].getAbsolutePath());  
148.                 if (!flag) {  
149.                     break;  
150.                 }  
151.             } else {  
152.                 return false;  
153.             }  
154.         }  
155.         if (file.delete()) { // 删除自身  
156.             return true;  
157.         }  
158.         return false;  
159.   
160.     }  
161. }  
162. /**  
163.  * FileFilter类  
164.  * 删除带*文件  
165.  * @author doudou  
166.  *  
167.  */  
168. class DelFileFilter implements FilenameFilter {  
169.       
170.     // 传进来的文件URL  
171.     String fileName;  
172.     String fileType; // 文件类型  
173.     // 删除的类型。   1:*号在开头； 2：*号在末尾  
174.     int delType;  
175.     public DelFileFilter(String name, String fileType, int delType) {  
176.         this.fileType = fileType;  
177.         this.delType = delType;  
178.         this.fileName = name;  
179.     }  
180.       
181.     @Override  
182.     public boolean accept(File dir, String name) {  
183.         // 将文件名分割顾字符串  
184.         String[] ss = fileName.split("[*]");  
185.         // 首先判断是否是要删除的文件类型  
186.         if (!isThisTypeFile(name)) {  
187.             return false;  
188.         }  
189.         boolean flag = true;  
190.         switch (delType) {  
191.         case 1 :  
192.             for (String s : ss) {  
193.                 if (!"".equals(s)){  
194.                     flag = endWithS(name, s);  
195.                 }  
196.             }  
197.             return flag;  
198.         case 2 :  
199.             for (String s : ss) {  
200.                 if (!"".equals(s)){  
201.                     flag = endWithS(name, s);  
202.                 }  
203.             }  
204.             return flag;  
205.         case 3 :  
206.         case 4 :  
207.         case 7 :  
208.             for (String s : ss) {  
209.                 if (!"".equals(s)) {   
210.                     flag = contains(name, s);  
211.                     if (!flag) {  
212.                         break;  
213.                     }  
214.                 }  
215.             }  
216.             return flag;  
217.         case 5 :  
218.             boolean flag1 = false, flag2 = false;  
219.             for (int i=0;i<ss.length;i++) {  
220.                 if (!"".equals(ss[i])) {  
221.                     if (i != ss.length-1 && !"".equals(ss[i])) {  
222.                         flag1 = contains(name, ss[i]);  
223.                         if (!flag1) {  
224.                             break;  
225.                         }  
226.                     }  
227.                     if (i == ss.length-1) {  
228.                         flag2 = endWithS(name, ss[i]);  
229.                     }  
230.                 }  
231.             }  
232.             flag = flag1 && flag2;  
233.             return flag;  
234.         case 6 :  
235.             boolean flag3 = false, flag4 = false;  
236.             flag3 = startWithS(name, ss[0]);  
237.             for (int i=1;i<ss.length;i++) {  
238.                 if (!"".equals(ss[i])) {  
239.                     flag4 = contains(name, ss[i]);  
240.                     if (!flag4)   
241.                         break;  
242.                 }  
243.             }  
244.             flag = flag3 && flag4;  
245.             return flag;  
246.         default :  
247.             flag = false;  
248.             return flag;  
249.         }  
250.     }  
251.       
252.     /**  
253.      * 判断是否是该类型的文件  
254.      * @param file  
255.      * @return  
256.      */  
257.     public boolean isThisTypeFile(String file) {  
258.         return file.toLowerCase().endsWith(fileType);  
259.     }  
260.     /**  
261.      * 包含某字符  
262.      * @param file  
263.      * @param str  
264.      * @return  
265.      */  
266.     public boolean contains(String file, String str) {  
267.         return (file.toLowerCase().contains(str));  
268.     }  
269.     /**  
270.      * 以某字符开始  
271.      * @param file  
272.      * @param str  
273.      * @return  
274.      */  
275.     public boolean startWithS(String file, String str) {  
276.         return file.toLowerCase().startsWith(str);  
277.     }  
278.     /**  
279.      * 以file字符结束  
280.      * @param file  
281.      * @param str  
282.      * @return  
283.      */  
284.     public boolean endWithS(String file, String str) {  
285.         return file.toLowerCase().endsWith(str+fileType);  
286.     }  
287. }