自己設計一個 SimpleFileUtil 處理文字檔案

這裡將會介紹一個我自己寫的，而且是經常使用到的一個處理文字檔案的工具集合。該工具主要是封裝檔案的讀取，以及提供一些方便的方法進行對讀取的檔案進行特殊處理，同時也提供方法將一些物件資料輸出到文字檔案中。

主要的功能類

package cn.donespeak.tools.util.file;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileInputStream;
import
 
 java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.nio.file.Files;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;

public class SimpleFileUtil {
    /**
     * 移除本地非目錄檔案
     * @param
 
 filePath
     * @return  <code>true</code> 移除成功,
     *          <code>false</code> 移除失敗
     */
    public static boolean removeLocalFile(String filePath){
        File f = new File(filePath);
        if(f.exists()){
            if(f.isDirectory()){
                return false
 
;
            }
            f.delete();
        }
        return !f.exists();
    }

    /**
     * 移除一個目錄內所有檔案，同時可以指定是否移除目錄自身
     * @param dirPath
     * @param removeItself　是否移除目錄自身
     * @return　如果removeItself為true, 結果為指定目錄是否已被存在，否則表示指定目錄內的所有檔案是否已經被成功刪除
     */
    public static boolean removeDirectory(String dirPath, boolean removeItself){
        File dir = new File(dirPath);
        if(!dir.exists()){
            return true;
        }
        if(!dir.isDirectory()){
            return false;
        }
        File[] files = dir.listFiles();
        for(File f: files){
            if(f.isDirectory()){
                removeDirectory(f.getAbsolutePath(), true);
            } else {
                f.delete();
            }           
        }
        if(removeItself){
            dir.delete();
            return !dir.exists();
        } else {
            files = dir.listFiles();
            return files.length == 0;
        }
    }

    /**
     * 清空目錄內的所有檔案
     * @param dirPath
     * @return
     */
    public static boolean emptyDirectory(String dirPath){
        return removeDirectory(dirPath, false);

    }

    /**
     * 將檔案路徑分隔符替換成系統對應的檔案路徑分隔符
     * @param filePath
     * @return
     */
    public static String normalizeFileSeparator(String filePath){
        if(filePath == null){
            return null;
        }
        char targetSeparor = File.separator.charAt(0);
        char oldSeparator = '\\';
        System.out.println();
        System.out.println(targetSeparor == oldSeparator);
        if(targetSeparor == oldSeparator){
            oldSeparator = '/';
        }
        return filePath.trim().replace(oldSeparator, targetSeparor);
    }

    /**
     *　將檔案的內容提取為一個字串
     * @param filePath
     * @return
     */
    public static String extractAsOneString(String filePath){
        BufferedReader reader = null;
        StringBuilder sb = new StringBuilder();
        try {
            reader = new BufferedReader(new InputStreamReader(new FileInputStream(filePath)));
            String line = null;
            while((line = reader.readLine()) != null){
                sb.append(line);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if(reader != null){
                try {
                    reader.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        return sb.toString();
    }

    /**
     * 將檔案中的內容按照提取每行一個字元的方式到一個字串列表
     * @param filePath
     * @return
     * @throws IOException 
     */
    public static List<String> extractAsOneList(String filePath) throws IOException{
        return extractAsOneList(filePath, new StringObjectifier<String>(){
            @Override
            public String objectify(int index, String line) {
                return line;
            }
        });
    }

    /**
     * 提取檔案內容中的每一個行文字，並利用formater格式化為一個特殊物件
     * @param filePath
     * @param formater
     * @return
     * @throws IOException
     */
    public static <T> List<T> extractAsOneList(String filePath, StringObjectifier<T> formater) throws IOException{
        BufferedReader reader = null;
        List<T> list = new ArrayList<T>();
        try {
            reader = new BufferedReader(new InputStreamReader(new FileInputStream(filePath)));
            String line = null;
            int index = 0;
            while((line = reader.readLine()) != null){
                T t = formater.objectify(index ++, line);
                if(t != null){
                    list.add(t);
                }
            }
        } finally {
            if(reader != null) {
                try {
                    reader.close();
                    reader = null;
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        return list;
    }

    /**
     * 將字串集合按照每個元素一行的方式輸出到一個檔案中
     * @param collection
     * @param destFilePath
     * @param append　是否在原來的檔案中拓展
     * @throws IOException
     */
    public static void toFile(Collection<String> collection, String destFilePath, boolean append) throws IOException {
        toFile(collection, destFilePath, append, new ObjectStringifier<String>(){
            @Override
            public String stringify(String t) {
                return t;
            }
        });
    }

    /**
     * 將物件集合按照每個元素一行的方式輸出到一個檔案中，
     *  可以通過objectStringifier格式化每個物件為一個字串
     * @param collection
     * @param destFilePath
     * @param append　是否在原來的檔案中拓展
     * @param objectStringifier　定義物件格式化為字串的方式
     * @throws IOException
     */
    public static <T> void toFile(Collection<T> collection, String destFilePath, boolean append,
            ObjectStringifier<T> objectStringifier) throws IOException{

        BufferedWriter writer = null;
        try {
            writer = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(destFilePath, append)));

            for(T t: collection){
                String line = objectStringifier.stringify(t);
                writer.write(line);
                writer.newLine();
            }
            writer.flush();
        } finally {
            if(writer != null){
                try {
                    writer.close();
                    writer = null;
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    /**
     * 拷貝檔案
     * @param srcFile
     * @param destFile
     * @return
     */
    public static boolean copyFileTo(File srcFile, File destFile){
        if(srcFile == null || !srcFile.exists() || destFile == null){
            return false;
        }
        if(srcFile.getAbsolutePath().equals(destFile.getAbsolutePath())){
            return true;
        }
        try {
            if(destFile.exists()){
                destFile.delete();
            }
            Files.copy(srcFile.toPath(), destFile.toPath());
        } catch (IOException e) {
            return false;
        }
        return true;
    }

    public static String getExtension(File file) {
        return getExtension(file.getName());
    }

    public static String getExtension(String filePath) {
        int lastPoint = filePath.lastIndexOf(".");
        return lastPoint < 0? "": filePath.substring(lastPoint + 1);
    }
}

將字串格式化為物件的介面

package cn.donespeak.tools.util.file;

public interface StringObjectifier <T>{
    T objectify(int index, String line);
}

將物件格式化為字串的介面

package cn.donespeak.tools.util.file;

public interface ObjectStringifier<T> {
    String stringify(T t);
}

org.apache.commons.io.FileUtils