Java目錄處理及遍歷解壓

import java.io.File;
import java.io.FileFilter;
import java.io.IOException;

public class DirProcessor {	
	private FileFilter dirFileFilter = new FileFilter() {
	    public boolean accept(File f) {
	        if (f.isDirectory()) {
	            return true;
	        }
	        return false;
	    }
	};
	
	private FileFilter txtFilefilter = new FileFilter() {
        public boolean accept(File f) {
            if (f.isFile() && isTxt(f.getName().toLowerCase())) {
                return true;
            }
            return false;
        }
	};
	
    private FileFilter htmlFilefilter = new FileFilter() {
        public boolean accept(File f) {
            if (f.isFile() && isHtml(f.getName().toLowerCase())) {
                return true;
            }
            return false;
        }       
    };

    private FileFilter docFilefilter = new FileFilter() {
        public boolean accept(File f) {
            if (f.isFile() && isDoc(f.getName().toLowerCase())) {
                return true;
            }
            return false;
        }       
    };    
    
    private FileFilter mhtFilefilter = new FileFilter() {
        public boolean accept(File f) {
            if (f.isFile() && isMht(f.getName().toLowerCase())) {
                return true;
            }
            return false;
        }       
    };    
    
    private FileFilter compressFilefilter = new FileFilter() {
        public boolean accept(File f) {
            if (f.isFile() && isCompress(f.getName().toLowerCase())) {
                return true;
            }
            return false;
        }       
    };
    
    private FileFilter otherFilefilter = new FileFilter() {
        public boolean accept(File f) {
            if (f.isFile() && isOtherFile(f.getName().toLowerCase())) {
                return true;
            }
            return false;
        }       
    };
    
    private FileFilter countFilefilter = new FileFilter() {
        public boolean accept(File f) {
            if (f.isFile()) {
                return true;
            }
            return false;
        }       
    };
    
	private boolean isLinux = CmdUtil.isLinux();
	
	private String destRootDir;
	
	// XXX 統計目錄下文件數
    public void count(String srcDir) {
        File srcDirFile = new File(srcDir);
        if (!srcDirFile.isDirectory()) {
            System.out.println(srcDir + " is not a directory!");
            return;
        }
        
        System.out.println(srcDirFile.getName() + "/  " +  countSubLevel(srcDirFile, 0));
    }
    
    private int countSubLevel(File srcDirFile, int level) {
        File[] files = srcDirFile.listFiles(countFilefilter);
        int fileNum = files.length;
        
        files = srcDirFile.listFiles(dirFileFilter);
        for (File file : files) {
            int subFileNum = countSubLevel(file, level+1);
            System.out.println(getLevelStr(level) + file.getName() + "/  " + subFileNum);
            fileNum += subFileNum;
        }
        
        return fileNum;
    }
	
	// XXX 顯示目錄結構, level 深度
	public void tree(String srcDir, int showLevel) {
		File srcDirFile = new File(srcDir);
		if (!srcDirFile.isDirectory()) {
			System.out.println(srcDir + " is not a directory!");
			return;
		}
		
		System.out.println(srcDirFile.getName());
		showDirLevel(srcDirFile, 0, showLevel);
	}
	
	private void showDirLevel(File srcDirFile, int level, int showLevel) {
	    if (showLevel > 0 && level >= showLevel) {
	        return;
	    }
	    
		File[] files = srcDirFile.listFiles();
		for (File file : files) {
			String fileName = file.getName();
			if (file.isDirectory()) {
				fileName += "/";
			}
			System.out.println(getLevelStr(level) + fileName);
			if (file.isDirectory()) {
				showDirLevel(file, level+1, showLevel);
			}
		}
	}
	
	// XXX 遞歸解壓目錄下壓縮文件
	public void decompressDir(String rootDir, boolean display) {
		File rootDirFile = new File(rootDir);
		if (!rootDirFile.isDirectory()) {
			System.out.println(rootDir + " is not a directory!");
			return;
		}
		
		String backupRootDir = rootDir+"_backup";
		File backupDirFile = new File(backupRootDir);
		if (backupDirFile.exists()) {
			System.out.println(backupRootDir + " dir exists!");
			return;
		}
		
		//backupDirFile.mkdirs();
		if (display) {
			System.out.println(rootDir);
		}
		decompress(rootDirFile.getPath(), 0, display);
	}
	
	private void decompress(String parentDirPath, int level, boolean display) {
		File parentDirFile = new File(parentDirPath);
		//System.out.println("# " + parentDirPath);
		
		// 解壓目錄下壓縮文件
		File[] files = parentDirFile.listFiles(compressFilefilter);
		for (File file : files) {
			String fileName = file.getName();
			
			if (file.isFile()) {
				if (display) {
					System.out.println(getLevelStr(level) + fileName); // structure
				}
				
				// 去除文件名空格（重命名）
				String fileNameNew = fileName.replaceAll("\\s*", "");
				if (!fileNameNew.equals(fileName)) {
				    File fileNew = new File(file.getPath().replaceAll("\\s*", ""));
				    file.renameTo(fileNew);
				    fileName = fileNew.getName();
				}
				
				String srcFile = parentDirPath+"/"+fileName;
				String destDir = parentDirPath+"/"+getName(fileName);
				if (!isLinux) {
				    srcFile = parentDirPath+"\\"+fileName;
				    destDir = parentDirPath+"\\"+getName(fileName);
				}				
				
				String suffix = getSuffix(fileName);
				if (suffix.equalsIgnoreCase("rar")) {					
					File dirnameFile = new File(destDir);
					if (!dirnameFile.exists()) {
						if (dirnameFile.mkdirs()) {
						    if (isLinux) {
						        CmdUtil.exec("unrar x -o+ " + srcFile + " -d " + destDir);
						    }
						    else {
						        CmdUtil.exec("winrar e -o+ \"" + srcFile + "\" " + destDir);
						    }
						}
						else {
							System.out.println("Error: Failed to create dir: " + destDir);
						}
					}
					else {
						System.out.println("unrar: exists " + destDir);
					}
				}
				else if (suffix.equalsIgnoreCase("zip")) {
					File dirnameFile = new File(destDir);
					if (!dirnameFile.exists()) {						
						if (isLinux) {
						    //CmdUtil.exec("unzip   \"" + srcFile + "\" -d " + destDir);
						    CmdUtil.exec("7za x " + srcFile + " -o" + destDir);
						    
						    String convFileName =  "convmv -r -f utf8 -t iso88591 "+destDir+"/* --notest --nosmart";
						    String convFileName2 = "convmv -r -f gbk -t utf8 "+destDir+"/* --notest --nosmart";
						    CmdUtil.exec(convFileName);
						    CmdUtil.exec(convFileName2);
                        }
                        else {
                            if (dirnameFile.mkdirs()) {
                                CmdUtil.exec("winrar e -o+ \"" + srcFile + "\" " + destDir);
                            }
                            else {
                                System.out.println("Error: Failed to create dir: " + destDir);
                            }
                        }
					}
					else {
						System.out.println("unzip: exists " + destDir);
					}
				}
			}
		}
		
		// 處理子目錄
		files = parentDirFile.listFiles(dirFileFilter);
		for (File file : files) {			
			if (file.isDirectory()) {
			    String fileName = file.getName();
			    String filePath = file.getPath();
	             // rename
                String fileNameNew = fileName.replaceAll("\\s*", "");
                if (!fileNameNew.equals(fileName)) {
                    File fileNew = new File(file.getPath().replaceAll("\\s*", ""));
                    file.renameTo(fileNew);
                    fileName = fileNew.getName();
                    filePath = fileNew.getPath();
                }
			    
				if (display) {
					System.out.println(getLevelStr(level) + fileName + "/"); // structure
				}
				decompress(filePath, level+1, display);
			}
		}
	}
	
	// XXX 拷貝目錄結構，採樣
	public void copy(String srcDir, String destDir, int fileNum, int dirNum) {
		File srcDirFile = new File(srcDir);
		if (!srcDirFile.isDirectory()) {
			System.out.println(srcDir + " is not a directory!");
			return;
		}
		
		File destDirFile = new File(destDir);
		if (destDirFile.exists()) {
			System.out.println(destDir + " exists!");
			return;
		}
		destRootDir = destDir;
		
		System.out.println(srcDirFile.getName()+"/");
		doCopy(srcDirFile, srcDirFile.getName(), fileNum, dirNum, 0);
	}
	
	private String getCopyDestDir(String destRelativeDir) {
	    if (destRelativeDir == null || destRelativeDir.isEmpty()) {
	        return destRootDir;
	    }
	    return destRootDir + File.separator  + destRelativeDir;
	}
	
	private void doCopy(File srcDirFile, String destRelativeDir, int fileNum, int dirNum, int level) {		
		File[] files = srcDirFile.listFiles();
		// 採樣文件
		String destDir = getCopyDestDir(destRelativeDir);
		new File(destDir).mkdirs();
		int i = 0;
		for (File file : files) {
		    if (file.isFile()) {
    		    if (++i > fileNum) {
    		        break;
    		    }
                //System.out.println(getLevelStr(level) + file.getName()); // file
                if (isLinux) {
                    CmdUtil.exec("cp -f "+file.getPath()+" "+destDir);
                }
                else {
                    CmdUtil.exec("cmd.exe /c copy /y \""+file.getPath()+"\" "+destDir);
                }
		    }
		}
		
        // 子目錄
        files = srcDirFile.listFiles(dirFileFilter);
        i = 0;
        for (File file : files) {
            if (++i > dirNum) {
                break;
            }
            System.out.println(getLevelStr(level) + file.getName() + "/"); // dir
            doCopy(file, destRelativeDir+File.separator+file.getName(), fileNum, dirNum, level+1);
        }
	}
	
	// XXX 目錄按類型分類
	public void classify(String srcDir, String destDir, boolean rename) {
        File srcDirFile = new File(srcDir);
        if (!srcDirFile.isDirectory()) {
            System.out.println(srcDir + " is not a directory!");
            return;
        }
        
        File destDirFile = new File(destDir);
        if (destDirFile.exists()) {
            System.out.println(destDir + " exists!");
            try {
                System.out.println("Press anykey to continue!");
                System.in.read();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        else {
            if (!destDirFile.mkdirs()) {
                System.out.println("Failed to create dir: " + destDir);
            }
        }
        destRootDir = destDir;
        
        classifyByType(srcDirFile, srcDirFile.getName(), 0, rename);
	}
	
	private void classifyByType(File srcDirFile, String destRelativeDir, int level, boolean rename) {	   
	    // html
	    File[] files = srcDirFile.listFiles(htmlFilefilter);
	    copyFilesToDestDir("html", files, destRelativeDir, level, rename);
	    // txt
	    files = srcDirFile.listFiles(txtFilefilter);
        copyFilesToDestDir("txt", files, destRelativeDir, level, rename);
        // doc
        files = srcDirFile.listFiles(docFilefilter);
        copyFilesToDestDir("doc", files, destRelativeDir, level, rename);
        // mht
        files = srcDirFile.listFiles(mhtFilefilter);
        copyFilesToDestDir("mht", files, destRelativeDir, level, rename);      
        // compressed file
        files = srcDirFile.listFiles(compressFilefilter);
        copyFilesToDestDir("compressed", files, destRelativeDir, level, false);
        // other
        files = srcDirFile.listFiles(otherFilefilter);
        copyFilesToDestDir("other", files, destRelativeDir, level, false);
        
	    // 子目錄
	    files = srcDirFile.listFiles(dirFileFilter);
	    for (File file : files) {
	        System.out.println(getLevelStr(level) + file.getName() + "/");
            classifyByType(file, destRelativeDir+File.separator+file.getName(), level+1, rename);
	    }
	}
	
	private void copyFilesToDestDir(String typeDir, File[] files, String destRelativeDir, int level, boolean rename) {	    
        if (files.length > 0) {
            String destDir = destRootDir + File.separator + typeDir + File.separator  + destRelativeDir;
            File destDirFile = new File(destDir);
            if (destDirFile.exists()) {
                System.out.println("Exists dir: " + destDir);
            }
            else {
                if (!destDirFile.mkdirs()) {
                    System.out.println("Failed to mkdirs: " + destDir);
                }
            }
            for (File file : files) {
                String destFile;
                if (rename) {
                    int pos = file.getName().lastIndexOf(".");
                    destFile = destDir + File.separator + IDManager.getInstance().genID() + file.getName().substring(pos);
                }
                else {
                    destFile = destDir;
                }
                //System.out.println(getLevelStr(level) + file.getName());
                if (isLinux) {
                    CmdUtil.exec("cp -f "+file.getPath()+" "+destFile);
                }
                else {
                    //System.out.println("cmd.exe /c copy /y "+file.getPath()+" "+destDir);
                    CmdUtil.exec("cmd.exe /c copy /y \""+file.getPath()+"\" "+destFile);
                }
            }
        }
	}
	
	private String getLevelStr(int level) {
		StringBuilder sb = new StringBuilder();
		for (int i = 0; i < level; i++) {
			sb.append("+   ");
		}
		sb.append("+-- ");
		return sb.toString();
	}
	
	private String getSuffix(String fileName) {
        if (fileName != null) {
            int pos = fileName.lastIndexOf('.');
            if (pos > -1) {
                return fileName.substring(pos+1);
            }
        }        
        return "";
	}
	
	private String getName(String fileName) {
        if (fileName != null) {
            int pos = fileName.lastIndexOf('.');
            if (pos > -1) {
                return fileName.substring(0, pos);
            }
        }        
        return "";
	}
	
	private boolean isTxt(String fname) {
        return fname.endsWith(".txt");
    }

	private boolean isHtml(String fname) {
        return (fname.endsWith(".html") || fname.endsWith(".htm"));
    }
    
	private boolean isDoc(String fname) {
        return (fname.endsWith(".doc") || fname.endsWith(".docx"));
    }
    
	private boolean isMht(String fname) {
        return (fname.endsWith(".mht"));
    }
	
    private boolean isCompress(String fname) {
        return (fname.endsWith(".zip") || fname.endsWith(".rar") || fname.endsWith(".gz") || fname.endsWith(".tar"));
    }
	   
	private boolean isOtherFile(String fname) {
	    return !( isTxt(fname) || isHtml(fname) || isDoc(fname) || isMht(fname) || isCompress(fname));
	}
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;


public class CmdUtil {
    private static String OS = System.getProperty("os.name").toLowerCase();
    private static Runtime run = Runtime.getRuntime();


    public static boolean showCmdDetail = false; 
    
    public static String getOS() {
        return OS;
    }
    
    public static boolean isLinux(){  
        return OS.indexOf("linux")>=0;  
    }
    
    public static boolean isWindows(){  
        return OS.indexOf("windows")>=0;
    }  
    
public static void exec(String cmd) {
System.out.println("exec: " + cmd);

try {
Process p = run.exec(cmd);
try {
   if (showCmdDetail) {
       BufferedReader br = new BufferedReader(new InputStreamReader(p.getInputStream()));
                    String inline;
                    while ((inline = br.readLine()) != null) {
                        System.out.println(inline);                    
                    }
   }
p.waitFor();
} catch (InterruptedException e) {
e.printStackTrace();
}
} catch (IOException e) {
e.printStackTrace();
}
}
 

}

public class IDManager {
    private int start = 10000000;
    
    private static IDManager instance = new IDManager();
    
    public static IDManager getInstance() {
        return instance;
    }
    
    private IDManager() {
    }

    public int getStart() {
        return start;
    }

    public void setStart(int start) {
        this.start = start;
    }
    
    public int genID() {
        return ++start;
    }
}

public class Main 
{
    public static final int CPDIR_FILE_NUM = 5;
    public static final int CPDIR_DIR_NUM = 10;
    
    public static void usage()
    {
        System.out.println("Usage:");
        System.out.println("    tree {rootDir} [level>0]");
        System.out.println("    count {rootDir}");
        System.out.println("    decomp {rootDir} [displayDir:0/1]");
        System.out.println("    classify {srcDir} {destDir} [nameid:10000000]");
        System.out.println("    cpdir {srcDir} {destDir} [fileNum=5] [dirNum=10]");
    }
    
    public static void process(String[] args) 
    {
        System.out.println(CmdUtil.getOS());
        
        if (args.length < 2) {
            System.out.println("Error -- too few parametes");
            usage();
            return;
        }
        
        String option = args[0];
        String srcDir = args[1];
        
        DirProcessor dirProc = new DirProcessor();
        if (args[args.length-1].equals("v")) {
            CmdUtil.showCmdDetail = true;
            String [] args2 = new String[args.length-1];
            System.arraycopy(args, 0, args2, 0, args.length-1);
            args = args2;
        }
        
        if (option.equals("count")) {
            dirProc.count(srcDir);
        }
        else if (option.equals("tree")) {
            int level = 0;
            if (args.length >= 3) {
                level = Integer.parseInt(args[2]);
            }
            dirProc.tree(srcDir, level);
        }
        else if (option.equalsIgnoreCase("decomp")) {
            boolean display = false;
            if (args.length >= 3) {
                int displayPath = Integer.parseInt(args[2]);
                display = (displayPath==1)?true:false;
            }
            dirProc.decompressDir(srcDir, display);
        }
        else if (option.equalsIgnoreCase("cpdir")) {
            if (args.length < 3) {
                System.out.println("Error -- cpdir {destDir} missing.");
                usage();
                return;
            }
            String destDir = args[2];
            int fileNum = CPDIR_FILE_NUM;
            if (args.length >= 4) {
                fileNum = Integer.parseInt(args[3]);
            }
            int dirNum = CPDIR_DIR_NUM;
            if(args.length >= 5) {
                dirNum = Integer.parseInt(args[4]);
            }
            dirProc.copy(srcDir, destDir, fileNum, dirNum);
        }
        else if (option.equalsIgnoreCase("classify")) {
            if (args.length < 3) {
                System.out.println("Error -- classify {destDir} missing.");
                usage();
                return;
            }
            
            boolean rename = false;
            int nameidStart = -1;
            if (args.length >= 4) {
                if (args[3].startsWith("nameid")) {
                    nameidStart = Integer.parseInt(args[3].substring(args[3].indexOf(":")+1));
                    IDManager.getInstance().setStart(nameidStart);
                    rename = true;
                    System.out.println("# file nameid start: " + nameidStart);
                }
            }
            String destDir = args[2];
            dirProc.classify(srcDir, destDir, rename);
            
            System.out.println("### nameid: " + nameidStart + " -> " + IDManager.getInstance().getStart());
        }
        else {
            System.out.println("Error -- unkown option: " + option);
            usage();
        }
    }
    
    public static void main( String[] args )
    {
        process(args);
    }
}