java创建一个处理目录文件的类

在编写程序的过程中，时常要更改一些包含某个代码的文件，特别是像我这种将code到处copy，而不愿意采用那些精巧的框架的人。要修改某个特定的功能，就要找到调用这段代码的那些文件，这时，我就需要查找某个目录下的java、jsp、js文件。

这个类就是实现对所有子目录下的指定文本文件进行全文检索开发的，虽然没有什么性能可言，但是简单。

对于java文件，我很少写注释，除非怀疑自己以后看不懂。但是通常命名还是比较规范的。

良好的习惯，就是将一些常用的功能打包成一个类，

/**
  创建人：worldrisestar
  说明：用于加载系统资源，可以从系统文件、数据库加载参数。
  使用缓存:IniFile（localeKey，cacheName）
  如不需要缓冲: 1) 不排序使用IniFile（localeKey） 或IniFile（localeKey，false）
                    2) 需要排序IniFile（localeKey，true）
*/
package com.worldrisestar.file;

import java.util.Properties;
import java.util.List;
import java.util.ArrayList;
import java.util.Date;
import java.io.InputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.BufferedReader;
import java.io.FileReader;
import java.text.DecimalFormat;
import java.nio.channels.FileChannel;
import java.io.File;
import com.jgwang.cache.SysCache;
import com.jgwang.ICachable;
import com.jgwang.util.SysDate;

public class FolderFile 
{
    static java.text.DecimalFormat formater = (DecimalFormat)java.text.DecimalFormat.getInstance();
    public String folderName = "";   习惯了不用setter、getter，如果预估该属性要被预处理，那么最好加上set、get
    public String relativePath = "";  使用setter、getter是良好的习惯
    public String absolutePath = "";
    public FolderFile[] subFolders; 

    public FolderFile()
    {
    }

    public static void fileFastCopy(File s, File t) {   
        FileInputStream fi = null;
        FileOutputStream fo = null;
        FileChannel in = null;
        FileChannel out = null;
        try {
            fi = new FileInputStream(s);
            fo = new FileOutputStream(t);
            in = fi.getChannel();                 //得到对应的文件通道
            out = fo.getChannel();              //得到对应的文件通道
            in.transferTo(0, in.size(), out);  //连接两个通道，并且从in通道读取，然后写入out通道
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                fi.close();
                in.close();
                fo.close();
                out.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
    public static void fileFastCopy(String from, String to) {
        File s = new File(from);
        File t = new File(to);
        fileFastCopy( s,  t);
    }

    删除一个目录，写完后发现java本身类库就带了这个功能，搞笑。

    /*public void deleteDir(String dir)
    {
        File df = new File(dir);
        if(df.isDirectory())
        {
            File[] files = df.listFiles();
            if(files.length==0)
                df.delete();
            for(int i=0; i<files.length; i++)
            {
                if(files[i].isDirectory())
                    deleteDir(files[i].getAbsolutePath().replace('/','\\'));  
                else
                    files[i].delete();
            }
        }
        else
            df.delete();
    }*/

    // 删除某个目录及目录下的所有子目录和文件 
    public static boolean deleteFolderFile(String dir) { 
        return deleteFolderFile(new File(dir));
    }

    public static boolean deleteFolderFile(File dir) { 
        if (dir.isDirectory()) {     
            String[] children = dir.list(); 
            for (int i = 0; i < children.length; i++) { 
                boolean isDelete = deleteFolderFile(new File(dir, children[i]));    递归调用总是能简化思想
                if (!isDelete) { 
                  return false; // 如果删完了，没东西删，isDelete==false的时候，则跳出此时递归
                } 
            } 
        } 
        return dir.delete(); // 读到的是一个文件或者是一个空目录，则可以直接删除 
    } 
  
  // 复制某个目录及目录下的所有子目录和文件到新文件夹 
    public static boolean copyFolderFile(String oldPath, String newPath) throws IOException { 
        return copyFolderFile(oldPath, newPath, true);
    }

    public static boolean copyFolderFile(String oldPath, String newPath, boolean override) throws IOException { 
        File oldFile = new File(oldPath);
        if(!oldFile.exists())
            return false;  //throw new IOException("File not exists.");
        if (!newPath.endsWith(File.separator))  newPath += File.separator;
        createDir(newPath); 
        String folderFileName = oldFile.getName();
        if(oldFile.isFile()){
            File file = new File(newPath+folderFileName);
            if(!override && file.exists())
                return false;
            fileFastCopy(oldFile,file);
        }
        else {
            if(((!override) && (new File(newPath + folderFileName)).exists()))
                return false;
            createDir(newPath + folderFileName); 
            if (!oldPath.endsWith(File.separator))  oldPath += File.separator;
            File[] filelist = (oldFile).listFiles(); 
            for (int i = 0; i < filelist.length; i++) { 
                if(!copyFolderFile(oldPath + filelist[i].getName(), newPath + folderFileName) && !override)
                    return false;  
            } 
        }
        return true;
    } 

    public static void moveFolderFile(String oldPath, String newPath)  throws IOException { 
        if(copyFolderFile(oldPath, newPath, false))
           deleteFolderFile(oldPath); 
    } 

    public static void createFileDir(String filePath)  throws IOException {
        filePath = new File(filePath).getCanonicalPath(); //文件路径可能写的不标准，可能结尾为\或/
        createDir(filePath.substring(0,filePath.lastIndexOf(File.separator)));
    }

    public static void createDir(String filePath)  throws IOException {
        (new File(filePath)).mkdirs();
        /*
        String tempPath = (new File(filePath)).getCanonicalPath();  //File对象转换为标准路径并，有两种windows和linux
        if((new File(tempPath)).exists())                                            //处理通常情况，快速返回
            return;
        String[] paths = tempPath.split(File.separator + File.separator);
        String dir = paths[0];                        
        if(tempPath.startsWith(File.separator))                      //linux以/开头，不能在根目录下创建一级目录 。
            dir = File.separator + dir;
        for (int i = 1; i < paths.length; i++) {
            dir = dir + File.separator + paths[i];  
            File dirFile = new File(dir);
            if (!dirFile.exists()) 
                dirFile.mkdir();
        }*/
    }

    public static File[] getFiles(String dir) {
        File df = new File(dir);
        if(!df.exists())
            return new File[0];
        File[] files = df.listFiles();
        File tt= null;
        if(files!=null)
        {
            for(int i=0;i<files.length;i++)
            {
                for(int j = 0;j<files.length-i-1;j++)
                {  
                    String v1 = files[j].getName().toLowerCase();
                    String v2 = files[j+1].getName().toLowerCase();
                    if (v1.compareTo(v2) > 0)
                    {
                        tt = files[j+1];
                        files[j+1] = files[j];
                        files[j] = tt;
                    }
                }
            }
            for(int i=0;i<files.length;i++)
            {
                for(int j = 0;j<files.length-i-1;j++)
                {  
                    if (files[j].isFile()&&(!files[j+1].isFile()))
                    {
                        tt = files[j+1];
                        files[j+1] = files[j];
                        files[j] = tt;
                    }
                }
            }
        }
        else
            files = new File[0];
        return files;
    }

    public static String getFileIco(File file){
        String img = "filenew.gif";
        String fileName = file.getName();
        if(!file.isFile())
            img = "folder.gif";
        else if(fileName.trim().toLowerCase().endsWith(".xls") || fileName.trim().toLowerCase().endsWith(".xlsx")) 
            img = "excel.gif";
        else if(fileName.trim().toLowerCase().endsWith(".jpg") || fileName.trim().toLowerCase().endsWith(".gif") || fileName.trim().toLowerCase().endsWith(".png")) 
            img = "pic.gif";
        else if(fileName.trim().toLowerCase().endsWith(".pdf")) 
            img = "pdf.gif";
        return img;
    }

    public static String getDownFileLink(File file){
        if(file.isFile()) 
            return "<span class='CrtTitle' onclick=\"downLoad('"+file.getName()+"')\" >下载</span>";
        else
            return "";
    }

    public static String getFileSize(File file){
        if(!file.isFile())
            return "";
        else if(file.length()<1000)
            return file.length() + " <font color=green>B</font>";
        else //if(file.length()>=1000)
        {
            formater.setMaximumFractionDigits(0);
            formater.setMinimumFractionDigits(0);
            formater.setDecimalSeparatorAlwaysShown(false);
            return formater.format(file.length()/1000)+" <font color='#aaa'>KB</font>";
        }
    }

    public static String getFileModifyTime(File file){
        return SysDate.format((new java.util.Date(file.lastModified())),"yyyy-MM-dd HH:mm:ss");
    }

    public static String getFileSelLink(File file){
        return "<span class='CrtTitle' onclick=\"selectFile('"+file.getName()+"')\" >"+file.getName()+"</span>";
    }

    public static File[] findFiles(String path, boolean includeSub, String filter){
        List fileList = new ArrayList();
        findFiles(path,includeSub,filter,fileList);
        File[] rv = new File[fileList.size()];
        fileList.toArray(rv);
        return rv;
    }

    public static void findFiles(String path, boolean includeSub, String filter, List fileList) { 
        findFiles(path, includeSub, filter,"","","", fileList);
    }

    public static File[] findFiles(String path, boolean includeSub, String filter, String qtext, String startDate,String endDate){
        List fileList = new ArrayList();
        findFiles(path,includeSub,filter,qtext,startDate,endDate,fileList);
        File[] rv = new File[fileList.size()];
        fileList.toArray(rv);
        return rv;
    }
    public static void findFiles(String path, boolean includeSub, String filter, String qtext, String startDate,String endDate, List fileList) {    
        String tempName = null;  
        File baseDir = new File(path);  
        String[] filterStrs = filter.split("\\|");
        boolean matched = false;
        if (!baseDir.exists() || !baseDir.isDirectory()){  
            ;  
        } else {  
            File[] files = baseDir.listFiles();  
            for (int i = 0; i < files.length; i++) {  
                tempName = files[i].getName();  
                if(files[i].isFile()){
                    if(!matchFilter(tempName,filterStrs))
                        continue;
                    if(startDate.length()>0 || endDate.length()>0){
                        String fileDate = SysDate.format((new Date(files[i].lastModified())),"yyyy/MM/dd");
                        if(startDate.length()>0 && startDate.compareTo(fileDate)>0)
                           continue;
                        if(endDate.length()>0 && fileDate.compareTo(endDate)>0)
                           continue;
                    }
                    qtext = qtext.trim();
                    if(files[i].isFile() && qtext.length()>0 && !queryFileCnt(files[i],qtext))
                        continue;
                    fileList.add(files[i]); 
                }
                else if(includeSub){  
                    findFiles(path + "\\" + tempName,includeSub,filter, qtext, startDate, endDate, fileList);  
                }  
            }  
        }  
    } 

    public static boolean matchFilter(String srcStr, String[] filterStrs ){
         boolean matched = false;
         if(filterStrs.length==0)
             return true;
         for(int m=0; m<filterStrs.length; m++){
           if(filterStrs[m].indexOf("*")<0)
               matched = srcStr.indexOf(filterStrs[m])>=0;
           else if(filterStrs[m].startsWith("*."))
              matched = srcStr.endsWith(filterStrs[m].substring(1));
           else 
              matched = (filterMatchOne(srcStr, filterStrs[m]));  
           if(matched)
               break;
         }
         return matched;
    }

    public static boolean filterMatchOne(String srcStr, String patten) {  
        int patternLength = patten.length();  
        int strLength = srcStr.length();  
        int strIndex = 0;  
        char ch;  
        for (int patternIndex = 0; patternIndex < patternLength; patternIndex++) {  
            ch = patten.charAt(patternIndex);  
            if (ch == '*') {  
                //通配符星号*表示可以匹配任意多个字符  
                while (strIndex < strLength) {  
                    if (filterMatchOne(srcStr.substring(strIndex),patten.substring(patternIndex + 1))) {  
                        return true;  
                    }  
                    strIndex++;  
                }  
            } else if (ch == '?') {  
                //通配符问号?表示匹配任意一个字符  
                strIndex++;  
                if (strIndex > strLength) {  
                    //表示str中已经没有字符匹配?了。  
                    return false;  
                }  
            } else {  
                if ((strIndex >= strLength) || (ch != srcStr.charAt(strIndex))) {  
                    return false;  
                }  
                strIndex++;  
            }  
        }  
        return (strIndex == strLength);  
    }

    public static boolean queryFileCnt(File file, String qtext){
        if(file.length()>1000000) // < 1MB
            return false;
        qtext = qtext.toUpperCase();
        FileReader fr = null;
        try{
            fr = new FileReader(file);  
            BufferedReader bufferedreader = new BufferedReader(fr);  
            String line;  
            while ((line = bufferedreader.readLine().trim()) != null) {  
                if (line.length()!=0) {  
                    if(line.toUpperCase().indexOf(qtext)>=0)
                        return true;
                }  
            }
            bufferedreader.close();
            return false;
        }
        catch(Exception e){
            return false;
        }
        finally{
           if(fr!=null)try{
               fr.close();
           }catch(Exception e){}
        }
    }
    
    public static boolean isBinary(File file)   检查是否非文本文件
    {
        boolean isBinary = false;
        try {
            FileInputStream fin = new FileInputStream(file);
            long len = file.length(); 
            for (int j = 0; j < (int) len; j++) {
            int t = fin.read();
            if (t < 32 && t != 9 && t != 10 && t != 13) {
            isBinary = true;
            break;
        }
        }
        } catch (Exception e) {
        e.printStackTrace();
        }
        return isBinary;
    }

    public void loadFolders(String path, String relativePath, int maxLevel) {    
        String tempName = null;  
        File folder = new File(path);  
        if (folder.exists() && folder.isDirectory()){ 
            this.folderName = folder.getName();
            this.relativePath = relativePath;
            this.absolutePath = folder.getAbsolutePath();

              if(maxLevel>1){
                List subFoldersArr = new ArrayList();
                File[] files = folder.listFiles();  
                for (int i = 0; i < files.length; i++) {  
                    if(!files[i].isFile()){
                        FolderFile folderTmp = new FolderFile();
                        folderTmp.loadFolders(files[i].getAbsolutePath() ,relativePath + "/" + files[i].getName(), maxLevel -1);  
                        subFoldersArr.add(folderTmp);                 
                    }  
                }  
                FolderFile[] rv = new FolderFile[subFoldersArr.size()];
                subFoldersArr.toArray(rv);
                if(rv.length>0)
                   subFolders = rv;
            }
        }  
    } 

    public String toJSONStr(){
       String rv = "{";
       rv += "\"fn\":\"" + folderName + "\",";
       rv += "\"fp\":\"" + relativePath + "\"";
       if(subFolders!=null){
           rv += ",\"sb\":[";
           for(int i=0;i<subFolders.length;i++){
               rv += (i>0)?",":"";
               rv += subFolders[i].toJSONStr();
           }
           rv += "]";
       }
        rv += "}";
       return rv;
    }

    public void setFolderName(String folderNameA){
        this.folderName = folderNameA;
    }
}