java刪除文件支持通配符

原文：https://blog.csdn.net/wdzayyt/article/details/7209530

感謝原做者

package com.covics.zfh;
 
import java.io.File;
import java.io.FilenameFilter;
/**
 * 實現帶*號的刪除文件
 * @author doudou
 *
 */
public class TestDeleteFile {
 
    public static void main(String args[]) {
         boolean delFile =
                 //windows
         //deleteFileWithSign("E:\\fileDeleteTest\\test\\t*ve.txt");
                 //linux
                 deleteFileWithSign("/home/work/ssst*ve.txt");
         System.out.println("main---->"+delFile);
    }
 
    /**
     * 刪除帶*的文件
     * @param fileName
     * @return
     */
    public static boolean deleteFileWithSign(String fileName) {
        // 文件夾名稱
        String dirName = "";
        // 要刪除的文件類型
        String fileType = "";
        // 不帶後綴的文件名
        String nameWithoutType = "";
        // *號個數
        int num = 0;
        if (null == fileName || "".equals(fileName)) {
            return false;
        }
        String osName = System.getProperty("os.name")
        if (osName.toLowerCase().contains("windows")){
            int index = fileName.lastIndexOf("\\") + 1;

        }else{
            int index = fileName.lastIndexOf("/") + 1;
        }
        nameWithoutType = fileName.substring(index, fileName.lastIndexOf("."));
        fileType = fileName
                .substring(fileName.lastIndexOf("."), fileName.length());
        
        dirName = fileName.substring(0, index);
        File dir = new File(dirName);
        System.out.println("dir:"+dir);
        System.out.println("exits"+dir.exists());
        System.out.println("dir.isDirectory()"+dir.isDirectory());
        if (!dir.exists() || !dir.isDirectory()) {
            return false;
        }
        // *號的位置
        int start = -1, end = -1;
        start = nameWithoutType.indexOf("*");
        end = nameWithoutType.lastIndexOf("*");
        
        int length = nameWithoutType.length();
        for (int i=0;i<length;i++) {
            if ('*' == nameWithoutType.charAt(i)) {
                num++;
            }
        }
        System.out.println("num---->"+num);
        
        // 刪除的類型
        int delType = 0;
        switch (num) {
        case 0 :
            return deleteFile(fileName);
            
        case 1 : // 只有一個*號的狀況
            if (0==start) { // 在開始的位置
                delType = 1; // 只調用endWith方法
            } else if (length-1 == start) { // 在結束的位置
                delType = 2; // 只調用startWith方法
            } else {  // 在中間
                delType = 3; // 只調用contain方法
            }
            break;
            
        default : // 有兩個或多個*號的狀況
            if (0 == start && length-1 == end) { // 在開始的位置和結束的位置都有*號
                delType = 4; // 只調用contain方法
            } else if (0 == start && length-1 != end) { // 開始的位置有*號且結束的位置沒有*號
                delType = 5; // 調用contain和endWith方法
            } else if (0 != start && length-1 == end) { // 開始的位置沒有*號且結束的位置有*號
                delType = 6; // 調用startWith和contain方法
            } else { // *號在中間 的狀況（開始和結束都沒有*號）
                delType = 7; // 只調用contain方法
            }
            break;
        }
        
        boolean flag = false;
        String[] names = dir
                .list(new DelFileFilter(nameWithoutType, fileType, delType));
        System.out.println("names.length---->"+names.length);
        for (int i = 0; i < names.length; i++) {
            System.out.println("f--names-->"+dirName+names[i]);
            File f = new File(dirName + names[i]);
            if (!f.exists() || !f.isFile()) {
                return false;
            }
            flag = deleteFile(f.getAbsolutePath());
            if (!flag) {
                break;
            }
        }
        return flag;
    }
 
    /**
     * 刪除單個文件
     * 
     * @param fileName
     * @return
     */
    public static boolean deleteFile(String fileName) {
        File file = new File(fileName);
        if (file.isFile() && file.exists()) {
            file.delete();
            return true;
        }
        return false;
    }
 
    /**
     * 刪除文件夾
     * 
     * @param dir
     * @return
     */
    public static boolean deleteDir(String dir) {
        // 判斷是否有帶文件夾符號。
        if (!dir.endsWith(File.separator)) {
            dir = dir + File.separator;
        }
        File file = new File(dir);
        if (!file.isDirectory() || !file.exists()) {
            return false;
        }
        boolean flag = true;
        File[] files = file.listFiles();
        for (int i = 0; i < files.length; i++) {
            if (files[i].isFile()) { // 刪除文件
                flag = deleteFile(files[i].getAbsolutePath());
                if (!flag) {
                    break;
                }
            } else if (files[i].isDirectory()) { // 刪除文件夾
                flag = deleteDir(files[i].getAbsolutePath());
                if (!flag) {
                    break;
                }
            } else {
                return false;
            }
        }
        if (file.delete()) { // 刪除自身
            return true;
        }
        return false;
    }
}
/**
 * FileFilter類
 * 刪除帶*文件
 * @author doudou
 *
 */
class DelFileFilter implements FilenameFilter {
    
    // 傳進來的文件URL
    String fileName;
    String fileType; // 文件類型
    // 刪除的類型。   1:*號在開頭； 2：*號在末尾
    int delType;
    public DelFileFilter(String name, String fileType, int delType) {
        this.fileType = fileType;
        this.delType = delType;
        this.fileName = name;
    }
    
    @Override
    public boolean accept(File dir, String name) {
        // 將文件名分割顧字符串
        String[] ss = fileName.split("[*]");
        // 首先判斷是不是要刪除的文件類型
        if (!isThisTypeFile(name)) {
            return false;
        }
        boolean flag = true;
        switch (delType) {
        case 1 :
            for (String s : ss) {
                if (!"".equals(s)){
                    flag = endWithS(name, s);
                }
            }
            return flag;
        case 2 :
            for (String s : ss) {
                if (!"".equals(s)){
                    flag = startWithS(name, s);
                }
            }
            return flag;
        case 3 :
        case 4 :
        case 7 :
            for (String s : ss) {
                if (!"".equals(s)) { 
                    flag = contains(name, s);
                    if (!flag) {
                        break;
                    }
                }
            }
            return flag;
        case 5 :
            boolean flag1 = false, flag2 = false;
            for (int i=0;i<ss.length;i++) {
                if (!"".equals(ss[i])) {
                    if (i != ss.length-1 && !"".equals(ss[i])) {
                        flag1 = contains(name, ss[i]);
                        if (!flag1) {
                            break;
                        }
                    }
                    if (i == ss.length-1) {
                        flag2 = endWithS(name, ss[i]);
                    }
                }
            }
            flag = flag1 && flag2;
            return flag;
        case 6 :
            boolean flag3 = false, flag4 = false;
            flag3 = startWithS(name, ss[0]);
            for (int i=1;i<ss.length;i++) {
                if (!"".equals(ss[i])) {
                    flag4 = contains(name, ss[i]);
                    if (!flag4) 
                        break;
                }
            }
            flag = flag3 && flag4;
            return flag;
        default :
            flag = false;
            return flag;
        }
    }
    
    /**
     * 判斷是不是該類型的文件
     * @param file
     * @return
     */
    public boolean isThisTypeFile(String file) {
        return file.toLowerCase().endsWith(fileType);
    }
    /**
     * 包含某字符
     * @param file
     * @param str
     * @return
     */
    public boolean contains(String file, String str) {
        return (file.toLowerCase().contains(str));
    }
    /**
     * 以某字符開始
     * @param file
     * @param str
     * @return
     */
    public boolean startWithS(String file, String str) {
        return file.toLowerCase().startsWith(str);
    }
    /**
     * 以file字符結束
     * @param file
     * @param str
     * @return
     */
    public boolean endWithS(String file, String str) {
        return file.toLowerCase().endsWith(str+fileType);
    }
}