07.FileUtils工具类

package utils;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.text.DecimalFormat;
import java.util.ArrayList;
import java.util.List;

public class FileUtils {
    private boolean flag;

    private File file = null;

    /**
     * 根据路径删除指定的目录或文件，无论存在与否
     *
     * @param sPath
     *            要删除的目录或文件
     * @return 删除成功返回 true，否则返回 false。
     */
    public boolean deleteFolder(String sPath) {
        flag = false;
        file = new File(sPath);
        // 判断目录或文件是否存在
        if (!file.exists()) { // 不存在返回 false
            return flag;
        } else {
            // 判断是否为文件
            if (file.isFile()) { // 为文件时调用删除文件方法
                return deleteFile(sPath);
            } else { // 为目录时调用删除目录方法
                return deleteDirectory(sPath);
            }
        }
    }

    /**
     * 删除单个文件
     *
     * @param sPath
     *            被删除文件的文件名
     * @return 单个文件删除成功返回true，否则返回false
     */
    public boolean deleteFile(String sPath) {
        flag = false;
        file = new File(sPath);
        // 路径为文件且不为空则进行删除
        if (file.isFile() && file.exists()) {
            file.delete();
            flag = true;
        }
        return flag;
    }

    /**
     * 删除目录（文件夹）以及目录下的文件
     *
     * @param sPath
     *            被删除目录的文件路径
     * @return 目录删除成功返回true，否则返回false
     */
    public boolean deleteDirectory(String sPath) {
        // 如果sPath不以文件分隔符结尾，自动添加文件分隔符
        if (!sPath.endsWith(File.separator)) {
            sPath = sPath + File.separator;
        }
        File dirFile = new File(sPath);
        // 如果dir对应的文件不存在，或者不是一个目录，则退出
        if (!dirFile.exists() || !dirFile.isDirectory()) {
            return false;
        }
        flag = true;
        // 删除文件夹下的所有文件(包括子目录)
        File[] files = dirFile.listFiles();
        if (files != null && files.length > 0) {

            for (int i = 0; i < files.length; i++) {
                // 删除子文件
                if (files[i].isFile()) {
                    flag = deleteFile(files[i].getAbsolutePath());
                    if (!flag)
                        break;
                } // 删除子目录
                else {
                    flag = deleteDirectory(files[i].getAbsolutePath());
                    if (!flag)
                        break;
                }
            }
        }
        if (!flag)
            return false;
        // 删除当前目录
        if (dirFile.delete()) {
            return true;
        } else {
            return false;
        }
    }

    /**
     * 方法追加文件：使用FileWriter
     *
     * @param fileName
     *            文件名称
     * @param content
     *            追加的文件内容
     */
    public static void appendMethod(String fileName, String content) {
        try {
            // 打开一个写文件器，构造函数中的第二个参数true表示以追加形式写文件
            FileWriter writer = new FileWriter(fileName, true);
            writer.write(content);
            writer.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /**
     * 创建文件
     *
     * @return
     */
    public boolean createFile(String spath) {
        File newFile = new File(spath);
        boolean result = false;
        if (!newFile.exists()) {
            try {
                result = newFile.createNewFile();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        return result;
    }

    /**
     * 创建文件目录
     *
     * @param spath
     * @return
     */
    public boolean createDir(String spath) {
        File newFile = new File(spath);
        boolean result = false;
        if (!newFile.exists()) {
            try {
                result = newFile.mkdirs();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        return result;
    }

    /**
     * 生成UTF-8文件. 如果文件内容中没有中文内容，则生成的文件为ANSI编码格式； 如果文件内容中有中文内容，则生成的文件为UTF-8编码格式。
     *
     * @param fileName
     *            待生成的文件名（含完整路径）
     * @param fileBody
     *            文件内容
     * @return
     */
    public static boolean writeUTFFile(String fileName, String fileBody) {
        FileOutputStream fos = null;
        OutputStreamWriter osw = null;
        try {
            fos = new FileOutputStream(fileName);
            osw = new OutputStreamWriter(fos, "UTF-8");
            osw.write(fileBody);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        } finally {
            if (osw != null) {
                try {
                    osw.close();
                } catch (IOException e1) {
                    e1.printStackTrace();
                }
            }
            if (fos != null) {
                try {
                    fos.close();
                } catch (IOException e1) {
                    e1.printStackTrace();
                }
            }
        }
    }

    public String FormetFileSize(long fileS) {// 转换文件大小
        DecimalFormat df = new DecimalFormat("#.00");
        String fileSizeString = "";
        if (fileS < 1024) {
            fileSizeString = df.format((double) fileS) + "B";
        } else if (fileS < 1048576) {
            fileSizeString = df.format((double) fileS / 1024) + "K";
        } else if (fileS < 1073741824) {
            fileSizeString = df.format((double) fileS / 1048576) + "M";
        } else {
            fileSizeString = df.format((double) fileS / 1073741824) + "G";
        }
        return fileSizeString;
    }

    /**
     * 查看指定的文件夹下，文件列表的集合;
     *
     * @param path
     * @return
     */
    public static List<String> getFileList(String path) {
        File file = new File(path);
        List<String> list=new ArrayList<String>();
        if (file.isDirectory()) {
            File[] dirFile = file.listFiles();
            if (dirFile != null && dirFile.length > 0) {
                for (File f : dirFile) {
                    if (f.isDirectory())
                        list.addAll(getFileList(f.getAbsolutePath()));
                    else {
                        list.add(f.getName());
                    }
                }
            }
        }
        return list;
    }
    
    /***
     * 指定文件夹下的所有文件
     * @param path
     * @return
     */
    public static List<File> getFiles(String path){
        File root = new File(path);
        List<File> files = new ArrayList<File>();
        if(!root.isDirectory()){
            files.add(root);
        }else{
            File[] subFiles = root.listFiles();
            for(File f : subFiles){
                files.addAll(getFiles(f.getAbsolutePath()));
            }    
        }
        return files;
    }
    /**
     * 复制单个文件
     *
     * @param oldPath
     *            String 原文件路径 如：c:/fqf.txt
     * @param newPath
     *            String 复制后路径 如：f:/fqf.txt
     * @return boolean
     */
    @SuppressWarnings("resource")
    public void copyFile(String oldPath, String newPath) {
        try {
            int byteread = 0;
            File oldfile = new File(oldPath);
            if (oldfile.exists()) { // 文件存在时
                InputStream inStream = new FileInputStream(oldPath); // 读入原文件
                FileOutputStream fs = new FileOutputStream(newPath);
                byte[] buffer = new byte[1444];
                while ((byteread = inStream.read(buffer)) != -1) {
                    fs.write(buffer, 0, byteread);
                }
                inStream.close();
            }
        } catch (Exception e) {
            // System.out.println("复制单个文件操作出错");
            e.printStackTrace();

        }
    }
    
    /**
     * 通过输入流写入文件
     *
     * @param is
     * @param fileName
     * @throws IOException
     */
    public static void copyInputStreamToFile(InputStream is, String fileName) throws IOException {
        File newFile = new File(fileName);
        if (!newFile.exists()) {
            newFile.createNewFile();

        }
        OutputStream outputStream = new FileOutputStream(newFile);
        int byteCount =0;
        byte[] bytes = new byte[1024];
        while ((byteCount=is.read(bytes))!=-1) {
            outputStream.write(bytes, 0,byteCount );
            outputStream.flush();
        }
        outputStream.close();
        is.close();
    }
    
    public static void main(String[] args) {
        List<String> fileList=getFileList("E:\\lfy\\markdown_file");
        for (String file : fileList) {
            System.out.println(file);
        }
//        List<File> fileList=getFiles("E:\\lfy\\markdown_file");
//        for (File file : fileList) {
//            System.out.println(file.getName());
//        }
    }

}