分享一个文件的工具类

package com.cn.shupu.util;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.RandomAccessFile;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;
import java.text.DecimalFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Random;

import org.springframework.web.multipart.MultipartFile;
import org.springframework.web.multipart.MultipartHttpServletRequest;
import org.springframework.web.multipart.commons.CommonsMultipartFile;

import net.sf.json.JSONObject;

/**
 * 文件工具类 涵盖绝大多数的文件操作
 *  38  * @version 创建时间：2016年11月14日 下午3:03:21
 */
public class FileTools {
    public FileTools() {

    }

    /**
     * formatPath 转义文件目录
     *
     * @param path
     * @return
     */
    public static String formatPath(String path) {
        return path.replaceAll("\\", "/");
    }

    /**
     * combainPath文件路径合并
     *
     * @param eins
     * @param zwei
     * @return
     */
    private static String combainPath(String eins, String zwei) {
        String dori = "";
        eins = null == eins ? "" : formatPath(eins);
        zwei = null == zwei ? "" : formatPath(zwei);
        if (!eins.endsWith("/") && zwei.indexOf("/") != 0) {
            dori = eins + "/" + zwei;
        } else {
            dori = (eins + zwei).replaceAll("//", "/");
        }
        return dori;
    }

    /**
     * list2Array 列表转换数组
     *
     * @param list
     * @return
     */
    private static String[] list2Array(List list) {
        String array[] = (String[]) list.toArray(new String[list.size()]);
        return array;
    }

    /**
     * cp 复制文件
     *
     * @param source
     * @param destination
     * @param loop
     * @return
     */
    public static List<File> cp(String source, String destination, boolean loop) {
        List<File> list = new ArrayList();
        try {
            File srcFile = new File(source);
            File desFile = new File(destination);
            list.addAll(cp(srcFile, desFile, loop));
        } catch (Exception ex) {
            ex.printStackTrace();
        }
        return list;
    }

    /**
     * cp 复制文件
     *
     * @param source
     * @param destination
     * @param loop
     * @return
     */
    public static List<File> cp(File source, File destination, boolean loop) {
        List<File> list = new ArrayList();
        try {
            if (!source.exists() || source.isDirectory()) {
                throw new FileNotFoundException();
            }
            list.add(cp(source, destination));
            if (loop) {
                String[] subFile = source.list();
                for (String subPath : subFile) {
                    String src = combainPath(source.getPath(), subPath);// 子文件原文件路径
                    String des = combainPath(destination.getPath(), subPath);// 子文件目标路径
                    File subfile = new File(src);
                    if (subfile.isFile()) {
                        list.add(cp(src, des));
                    } else if (subfile.isDirectory() && loop) {
                        list.addAll(cp(src, des, loop));
                    }
                }
            }
        } catch (Exception ex) {
            ex.printStackTrace();
        }
        return list;
    }

    /**
     * cp 单文件复制文件
     *
     * @param source
     * @param destination
     * @return
     */
    public static File cp(String source, String destination) {
        File desFile = null;
        try {
            File srcFile = new File(source);
            desFile = new File(destination);
            desFile = cp(srcFile, desFile);
        } catch (Exception ex) {
            ex.printStackTrace();
        }
        return desFile;
    }

    /**
     * cp 单文件复制文件
     *
     * @param source
     * @param destination
     * @return
     */
    public static File cp(File source, File destination) {
        FileInputStream in = null;
        FileOutputStream out = null;
        FileChannel inc = null;
        FileChannel outc = null;
        try {
            if (!source.exists() || source.isDirectory()) {
                throw new FileNotFoundException();
            }
            if (source.getPath().equals(destination.getPath())) {
                return source;
            }
            long allbytes = du(source, false);
            if (!destination.exists()) {
                destination.createNewFile();
            }
            in = new FileInputStream(source.getPath());
            out = new FileOutputStream(destination);
            inc = in.getChannel();
            outc = out.getChannel();
            ByteBuffer byteBuffer = null;
            long length = 2097152;// 基本大小，默认2M
            long _2M = 2097152;
            while (inc.position() < inc.size()) {
                if (allbytes > (64 * length)) {// 如果文件大小大于128M 缓存改为64M
                    length = 32 * _2M;
                } else if (allbytes > (32 * length)) {// 如果文件大小大于64M 缓存改为32M
                    length = 16 * _2M;
                } else if (allbytes > (16 * length)) {// 如果文件大小大于32M 缓存改为16M
                    length = 8 * _2M;
                } else if (allbytes > (8 * length)) {// 如果文件大小大于16M 缓存改为8M
                    length = 4 * _2M;
                } else if (allbytes > (4 * length)) {// 如果文件大小大于8M 缓存改为4M
                    length = 2 * _2M;
                } else if (allbytes > (2 * length)) {// 如果文件大小大于4M 缓存改为2M
                    length = _2M;
                } else if (allbytes > (length)) {// 如果文件大小大于2M 缓存改为1M
                    length = _2M / 2;
                } else if (allbytes < length) {// 如果文件小于基本大小，直接输出
                    length = allbytes;
                }
                allbytes = inc.size() - inc.position();
                byteBuffer = ByteBuffer.allocateDirect((int) length);
                inc.read(byteBuffer);
                byteBuffer.flip();
                outc.write(byteBuffer);
                outc.force(false);
            }
        } catch (Exception ex) {
            ex.printStackTrace();
        } finally {
            try {
                if (null != inc) {
                    inc.close();
                }
                if (null != outc) {
                    outc.close();
                }
                if (null != in) {
                    in.close();
                }
                if (null != out) {
                    out.close();
                }
            } catch (Exception ex) {
                ex.printStackTrace();
            }
        }
        return destination;
    }

    /**
     * rename 文件重命名
     *
     * @param filePath
     * @param from
     * @param to
     * @return
     */
    public static File rename(String filePath, String from, String to) {
        File newFile = null;
        try {
            File oldFile = new File(combainPath(filePath, from));
            newFile = new File(combainPath(filePath, to));
            rename(newFile, oldFile);
        } catch (Exception ex) {
            ex.printStackTrace();
        }
        return newFile;
    }

    /**
     * rename 文件重命名
     *
     * @param to
     * @param from
     * @return
     */
    public static File rename(File from, File to) {
        try {
            String newPath = to.getPath();
            String oldPath = from.getPath();
            if (!oldPath.equals(newPath)) {
                if (!to.exists()) {
                    from.renameTo(to);
                }
            }
        } catch (Exception ex) {
            ex.printStackTrace();
        }
        return to;
    }

    /**
     * mv 移动文件
     *
     * @param fileName
     * @param source
     * @param destination
     * @param cover
     */
    public static void mv(String fileName, String source, String destination, boolean cover) {
        try {
            if (!source.equals(destination)) {
                File oldFile = new File(combainPath(source, fileName));
                File newFile = new File(combainPath(destination, fileName));
                mv(oldFile, newFile, cover);
            }
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }

    /**
     * mv 移动文件
     *
     * @param source
     * @param destination
     * @param cover
     */
    public static void mv(String source, String destination, boolean cover) {
        try {

            if (!new File(destination).exists())
                new File(destination).mkdirs();

            if (!source.equals(destination)) {
                File oldFile = new File(source);
                File newFile = new File(destination);
                mv(oldFile, newFile, cover);
            }
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }

    /**
     * mv 移动文件
     *
     * @param source
     * @param destination
     * @param cover
     */
    public static void mv(File source, File destination, boolean cover) {
        try {
            if (!source.exists()) {
                throw new FileNotFoundException();
            }
            StringBuilder fileName = new StringBuilder(source.getName());
            if (!cover && source.getPath().equals(destination.getPath())) {

                if (fileName.indexOf(".") > 0) {

                    fileName.insert(fileName.lastIndexOf("."), "_副本");

                } else {
                    fileName.append("_副本");
                }
                cp(source, new File(combainPath(source.getParent(), fileName.toString())));
            } else {
                source.renameTo(destination);
            }
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }

    /**
     * extensions 获取文件扩展名信息
     *
     * @param filePath
     * @param fileName
     * @return
     */
    private static String[] extensions(String filePath, String fileName) {
        String[] extension = {};
        try {
            String fullPath = combainPath(filePath, fileName);
            File file = new File(fullPath);
            extensions(file);
        } catch (Exception ex) {
            ex.printStackTrace();
        }
        return extension;
    }

    /**
     * extensions 获取文件扩展名信息
     *
     * @param fullPath
     * @return
     */
    private static String[] extensions(String fullPath) {
        String[] extension = {};
        try {
            File file = new File(fullPath);
            extensions(file);
        } catch (Exception ex) {
            ex.printStackTrace();
        }
        return extension;
    }

    /**
     * extensions 获取文件扩展名信息
     *
     * @param file
     * @return
     */
    private static String[] extensions(File file) {
        String[] extension = {};
        try {
            if (file.isFile()) {
                String fileName = file.getName();
                if (fileName.lastIndexOf(".") >= 0) {
                    int lastIndex = fileName.lastIndexOf(".");
                    extension[0] = String.valueOf(lastIndex);// 扩展名的“.”的索引
                    extension[1] = fileName.substring(lastIndex + 1);// 扩展名
                    extension[2] = fileName.substring(0, lastIndex);// 文件名
                }
            }
        } catch (Exception ex) {
            ex.printStackTrace();
        }
        return extension;
    }

    /**
     * ls 遍历文件
     *
     * @param filePath
     * @param loop
     * @return
     */
    public static List<File> ls(String filePath, boolean loop) {
        List<File> list = new ArrayList();
        try {
            File file = new File(filePath);
            list.addAll(ls(file, loop));
        } catch (Exception ex) {
            ex.printStackTrace();
        }
        return list;
    }

    /**
     * ls 遍历文件
     *
     * @param file
     * @param loop
     * @return
     */
    public static List<File> ls(File file, boolean loop) {
        List<File> list = new ArrayList();
        try {
            list.add(file);
            if (!file.isDirectory()) {
                list.add(file);
            } else if (file.isDirectory()) {
                File[] subList = file.listFiles();
                subList = filesSort(subList, true);
                for (File subFile : subList) {
                    if (subFile.isDirectory() && loop) {
                        list.addAll(ls(subFile.getPath(), loop));
                    } else {
                        list.add(subFile);
                    }
                }
            }
        } catch (Exception ex) {
            ex.printStackTrace();
        }
        return list;
    }

    /**
     * ls 遍历文件
     *
     * @param filePath
     * @param loop
     * @return
     */
    public static List<File> getFiles(String filePath, boolean loop) {
        List<File> list = new ArrayList();

        try {
            File file = new File(filePath);

            list.addAll(getFiles(file, loop));

        } catch (Exception ex) {
            ex.printStackTrace();
        }
        return list;
    }

    /**
     * ls 遍历文件
     *
     * @param file
     * @param loop
     * @return
     */
    public static List<File> getFiles(File file, boolean loop) {
        List<File> list = new ArrayList();
        try {
            // list.add(file);
            if (!file.isDirectory()) {
                list.add(file);
            } else if (file.isDirectory()) {

                File[] subList = file.listFiles();
                subList = filesSort(subList, true);

                for (File subFile : subList) {

                    if (subFile.isDirectory() && loop) {

                        list.addAll(getFiles(subFile.getPath(), loop));

                    } else {

                        list.add(subFile);

                    }

                }

            }
        } catch (Exception ex) {
            ex.printStackTrace();
        }
        return list;
    }

    /**
     * filesSort 文件排序（默认升序）
     *
     * @param parentPath
     * @param subList
     * @return
     */
    private static File[] filesSort(File[] inFiles, boolean asc) {

        List<String> files = new ArrayList();

        List<String> dirs = new ArrayList();

        for (File subFile : inFiles) {
            if (subFile.isDirectory()) {
                dirs.add(subFile.getPath());
            } else if (subFile.isFile()) {
                files.add(subFile.getPath());
            }
        }

        String[] fileArray = {};

        if (files.size() > 0) {

            fileArray = list2Array(files);

            Arrays.sort(fileArray);

            if (!asc) {
                Arrays.sort(fileArray, Collections.reverseOrder());
            }

        }
        String[] dirArray = {};
        if (dirs.size() > 0) {
            dirArray = list2Array(dirs);
            Arrays.sort(dirArray);
            if (!asc) {
                Arrays.sort(dirArray, Collections.reverseOrder());
            }
        }
        return concat2FileArray(fileArray, dirArray);
    }

    /**
     * concat2FileArray 合并文件数组
     *
     * @param old1
     * @param old2
     * @return
     */
    private static File[] concat2FileArray(String[] old1, String[] old2) {
        File[] newArray = new File[old1.length + old2.length];
        for (int i = 0, n = old1.length; i < n; i++) {
            newArray[i] = new File(old1[i]);
        }
        for (int i = 0, j = old1.length, n = (old1.length + old2.length); j < n; i++, j++) {
            newArray[j] = new File(old2[i]);
        }
        return newArray;
    }

    /**
     * read 读取文本文件
     *
     * @param filePath
     * @param fileName
     * @param charset
     * @return
     */
    public static StringBuilder read(String filePath, String fileName, String charset) {
        StringBuilder sb = new StringBuilder();
        try {
            String fullPath = combainPath(filePath, fileName);
            File file = new File(fullPath);
            sb.append(FileTools.tail(file, false, 0, charset));
        } catch (Exception ex) {
            ex.printStackTrace();
        }
        return sb;
    }

    /**
     * read 读取文本文件
     *
     * @param fullPath
     * @param charset
     * @return
     */
    public static StringBuilder read(String fullPath, String charset) {
        StringBuilder sb = new StringBuilder();
        try {
            File file = new File(fullPath);
            sb.append(FileTools.tail(file, false, 0, charset));
        } catch (Exception ex) {
            ex.printStackTrace();
        }
        return sb;
    }

    /**
     * read 读取文本文件
     *
     * @param file
     * @param charset
     * @return
     */
    public static StringBuilder read(File file, String charset) {
        StringBuilder sb = new StringBuilder();
        try {
            sb.append(FileTools.tail(file, false, 0, charset));
        } catch (Exception ex) {
            ex.printStackTrace();
        }
        return sb;
    }

    /**
     * find 读取文本文件指定行
     *
     * @param filePath
     * @param fileName
     * @param line
     * @param charset
     * @return
     */
    public static StringBuilder find(String filePath, String fileName, int line, String charset) {
        StringBuilder sb = new StringBuilder();
        try {
            String fullPath = combainPath(filePath, fileName);
            File file = new File(fullPath);
            sb.append(FileTools.tail(file, true, line, charset));
        } catch (Exception ex) {
            ex.printStackTrace();
        }
        return sb;
    }

    /**
     * find 读取文本文件指定行
     *
     * @param fullPath
     * @param line
     * @param charset
     * @return
     */
    public static StringBuilder find(String fullPath, int line, String charset) {
        StringBuilder sb = new StringBuilder();
        try {
            File file = new File(fullPath);
            sb.append(FileTools.tail(file, true, line, charset));
        } catch (Exception ex) {
            ex.printStackTrace();
        }
        return sb;
    }

    /**
     * find 读取文本文件指定行
     *
     * @param file
     * @param line
     * @param charset
     * @return
     */
    public static StringBuilder find(File file, int line, String charset) {
        StringBuilder sb = new StringBuilder();
        try {
            sb.append(FileTools.tail(file, true, line, charset));
        } catch (Exception ex) {
            ex.printStackTrace();
        }
        return sb;
    }

    /**
     * tail 读取文本文件
     *
     * @param filePath
     * @param fileName
     * @param charset
     * @param find
     * @param line
     * @return
     */
    public static StringBuilder tail(String filePath, String fileName, boolean find, int line, String charset) {
        StringBuilder sb = new StringBuilder();
        try {
            String fullPath = combainPath(filePath, fileName);
            File file = new File(fullPath);
            sb.append(FileTools.tail(file, find, line, charset));
        } catch (Exception ex) {
            ex.printStackTrace();
        }
        return sb;
    }

    /**
     * tail 读取文本文件
     *
     * @param fullPath
     * @param charset
     * @param find
     * @param line
     * @return
     */
    public static StringBuilder tail(String fullPath, boolean find, int line, String charset) {
        StringBuilder sb = new StringBuilder();
        try {
            File file = new File(fullPath);
            sb.append(FileTools.tail(file, find, line, charset));
        } catch (Exception ex) {
            ex.printStackTrace();
        }
        return sb;
    }

    /**
     * tail 读取文本文件
     *
     * @param file
     * @param charset
     * @param find
     * @param line
     * @return
     */
    public static StringBuilder tail(File file, boolean find, int line, String charset) {
        StringBuilder sb = new StringBuilder();
        BufferedReader bufferReader = null;
        if (null == charset || "".equals(charset)) {
            charset = "UTF-8";
        }
        try {
            if (!file.exists() || file.isDirectory()) {
                throw new FileNotFoundException();
            }
            String fullPath = file.getPath();
            bufferReader = new BufferedReader(new InputStreamReader(new FileInputStream(fullPath), charset));
            String temp;
            for (int i = 0; (temp = bufferReader.readLine()) != null; i++) {
                if (!find || line == i) {
                    sb.append(temp);
                }
            }
        } catch (Exception ex) {
            ex.printStackTrace();
        } finally {
            if (null != bufferReader) {
                try {
                    bufferReader.close();
                } catch (IOException ex) {
                    ex.printStackTrace();
                }
            }
        }
        return sb;
    }

    /**
     * sed 读取文本文件
     *
     * @param filePath
     * @param fileName
     * @param charset
     * @return
     */
    public static List<String> sed(String filePath, String fileName, String charset) {
        List<String> list = new ArrayList();
        try {
            String fullPath = combainPath(filePath, fileName);
            File file = new File(fullPath);
            list.addAll(FileTools.sed(file, charset));
        } catch (Exception ex) {
            ex.printStackTrace();
        }
        return list;
    }

    /**
     * sed 读取文本文件
     *
     * @param fullPath
     * @param charset
     * @return
     */
    public static List<String> sed(String fullPath, String charset) {
        List<String> list = new ArrayList();
        try {
            File file = new File(fullPath);
            list.addAll(FileTools.sed(file, charset));
        } catch (Exception ex) {
            ex.printStackTrace();
        }
        return list;
    }

    /**
     * sed 读取文本文件
     *
     * @param file
     * @param charset
     * @return
     */
    public static List<String> sed(File file, String charset) {
        List<String> list = new ArrayList();
        BufferedReader bufferReader = null;
        if (null == charset || "".equals(charset)) {
            charset = "UTF-8";
        }
        try {
            if (!file.exists() || file.isDirectory()) {
                throw new FileNotFoundException();
            }
            String fullPath = file.getPath();
            bufferReader = new BufferedReader(new InputStreamReader(new FileInputStream(fullPath), charset));
            String temp;
            for (int i = 0; (temp = bufferReader.readLine()) != null; i++) {
                list.add(temp);
            }
        } catch (Exception ex) {
            ex.printStackTrace();
        } finally {
            if (null != bufferReader) {
                try {
                    bufferReader.close();
                } catch (IOException ex) {
                    ex.printStackTrace();
                }
            }
        }
        return list;
    }

    /**
     * cat 读取文本文件
     *
     * @param filePath
     * @param fileName
     * @return
     */
    public static byte[] cat(String filePath, String fileName) {
        byte[] output = {};
        try {
            String fullPath = combainPath(filePath, fileName);
            File file = new File(fullPath);
            output = FileTools.cat(file);
        } catch (Exception ex) {
            ex.printStackTrace();
        }
        return output;
    }

    /**
     * cat 读取文本文件
     *
     * @param fullPath
     * @return
     */
    public static byte[] cat(String fullPath) {
        byte[] output = {};
        try {
            File file = new File(fullPath);
            output = FileTools.cat(file);
        } catch (Exception ex) {
            ex.printStackTrace();
        }
        return output;
    }

    /**
     * cat 读取文本文件
     *
     * @param file
     * @return
     */
    public static byte[] cat(File file) {
        InputStream in = null;
        byte[] output = {};
        try {
            if (!file.exists() || file.isDirectory()) {
                throw new FileNotFoundException();
            }
            String fullPath = file.getPath();
            long length = du(file, false);
            long _2M = 2097152;
            byte[] bytes = new byte[(int) length];
            in = new FileInputStream(fullPath);
            for (int count = 0; count != -1;) {
                if (length > 16 * _2M) {
                    length = 4 * _2M;
                } else if (length > 8 * _2M) {
                    length = 2 * _2M;
                } else if (length > 4 * _2M) {
                    length = _2M;
                } else if (length > 2 * _2M) {
                    length = _2M / 2;
                } else if (length > _2M) {
                    length = _2M / 4;
                } else {
                    length = 4096;
                }
                bytes = new byte[(int) length];
                count = in.read(bytes);
                output = concatArray(bytes, output);
                length = in.available();
            }
        } catch (Exception ex) {
            ex.printStackTrace();
        } finally {
            if (null != in) {
                try {
                    in.close();
                } catch (Exception ex) {
                    ex.printStackTrace();
                }
            }
        }
        return output;
    }

    /**
     * 合并数组
     *
     * @param old1
     * @param old2
     * @return
     */
    private static byte[] concatArray(byte[] old1, byte[] old2) {
        byte[] newArray = new byte[old1.length + old2.length];
        System.arraycopy(old1, 0, newArray, 0, old1.length);
        System.arraycopy(old2, 0, newArray, old1.length, old2.length);
        return newArray;
    }

    /**
     * dd 写入文件fullPath内容content
     *
     * @param filePath
     * @param fileName
     * @param content
     * @param isAppend
     */
    public static void dd(String filePath, String fileName, byte[] content, boolean isAppend) {
        try {
            String fullPath = combainPath(filePath, fileName);
            File file = new File(fullPath);
            FileTools.dd(file, content, isAppend);
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }

    /**
     * dd 写入文件fullPath内容content
     *
     * @param fullPath
     * @param content
     * @param isAppend
     */
    public static void dd(String fullPath, byte[] content, boolean isAppend) {
        try {
            File file = new File(fullPath);
            FileTools.dd(file, content, isAppend);
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }

    /**
     * dd 写入文件fullPath内容content
     *
     * @param file
     * @param content
     * @param isAppend
     */
    public static void dd(File file, byte[] content, boolean isAppend) {
        FileOutputStream fileOutputStream = null;
        try {
            if (!file.exists()) {
                file.createNewFile();
            }
            fileOutputStream = new FileOutputStream(file, isAppend);
            fileOutputStream.write(content);
        } catch (Exception ex) {
            ex.printStackTrace();
        } finally {
            try {
                if (null != fileOutputStream) {
                    fileOutputStream.close();
                }
            } catch (IOException ex) {
                ex.printStackTrace();
            }
        }
    }

    /**
     * write 写文件内容content到文件fullPath
     *
     * @param filePath
     * @param fileName
     * @param content
     */
    public static void write(String filePath, String fileName, String content) {
        try {
            String fullPath = combainPath(filePath, fileName);
            File file = new File(fullPath);
            FileTools.write(file, content, true);
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }

    /**
     * write 写文件内容content到文件fullPath
     *
     * @param fullPath
     * @param content
     */
    public static void write(String fullPath, String content) {
        try {
            File file = new File(fullPath);
            FileTools.write(file, content, true);
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }

    /**
     * write 写文件内容content到文件fullPath
     *
     * @param file
     * @param content
     */
    public static void write(File file, String content) {
        try {
            FileTools.write(file, content, true);
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }

    /**
     * write 写（追加）文件内容content到文件fullPath
     *
     * @param filePath
     * @param fileName
     * @param content
     * @param isAppend
     */
    public static void write(String filePath, String fileName, String content, boolean isAppend) {
        try {
            String fullPath = combainPath(filePath, fileName);
            File file = new File(fullPath);
            FileTools.write(file, content, isAppend);
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }

    /**
     * write 写（追加）文件内容content到文件fullPath
     *
     * @param fullPath
     * @param content
     * @param isAppend
     */
    public static void write(String fullPath, String content, boolean isAppend) {
        try {
            File file = new File(fullPath);
            FileTools.write(file, content, isAppend);
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }

    /**
     * write 写（追加）文件内容content到文件fullPath
     *
     * @param file
     * @param content
     * @param isAppend
     */
    public static void write(File file, String content, boolean isAppend) {
        FileWriter fileWriter = null;
        try {
            if (!file.exists()) {
                file.createNewFile();
            }
            fileWriter = new FileWriter(file.getPath(), isAppend);
            fileWriter.write(content);
        } catch (Exception ex) {
            ex.printStackTrace();
        } finally {
            if (null != fileWriter) {
                try {
                    fileWriter.close();
                } catch (IOException ex) {
                    ex.printStackTrace();
                }
            }
        }
    }

    /**
     * tail 添加文件内容content到文件的index位置
     *
     * @param filePath
     * @param fileName
     * @param content
     * @param index
     */
    public static void tail(String filePath, String fileName, String content, long index) {
        try {
            String fullPath = combainPath(filePath, fileName);
            File file = new File(fullPath);
            FileTools.tail(file, content, index);
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }

    /**
     * tail 添加文件内容content到文件的index位置
     *
     * @param fullPath
     * @param content
     * @param index
     */
    public static void tail(String fullPath, String content, long index) {
        try {
            File file = new File(fullPath);
            FileTools.tail(file, content, index);
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }

    /**
     * tail 添加文件内容content到文件的index位置
     *
     * @param file
     * @param content
     * @param index
     */
    public static void tail(File file, String content, long index) {
        RandomAccessFile randomAccessFile = null;
        try {
            if (!file.exists()) {
                file.createNewFile();
            }
            randomAccessFile = new RandomAccessFile(file.getPath(), "rw");
            randomAccessFile.seek(index);
            randomAccessFile.writeBytes(content);
        } catch (Exception ex) {
            ex.printStackTrace();
        } finally {
            if (null != randomAccessFile) {
                try {
                    randomAccessFile.close();
                } catch (Exception ex) {
                    ex.printStackTrace();
                }
            }
        }
    }

    /**
     * mkdir 创建目录
     *
     * @param filePath
     * @param fileName
     * @return
     */
    public static File mkdir(String filePath, String fileName) {
        File file = null;
        try {
            String fullPath = combainPath(filePath, fileName);
            file = new File(fullPath);
            file = mkdir(file);
        } catch (Exception ex) {
            ex.printStackTrace();
        }
        return file;
    }

    /**
     * mkdir 创建目录
     *
     * @param fullPath
     * @return
     */
    public static File mkdir(String fullPath) {
        File file = null;
        try {
            file = new File(fullPath);
            file = mkdir(file);
        } catch (Exception ex) {
            ex.printStackTrace();
        }
        return file;
    }

    /**
     * mkdir 创建目录
     *
     * @param file
     * @return
     */
    public static File mkdir(File file) {
        try {
            if (!file.exists()) {
                file.mkdir();// 如果文件夹不存在则创建
            }
        } catch (Exception ex) {
            ex.printStackTrace();
        }
        return file;
    }

    /**
     * touch 创建文件
     *
     * @param filePath
     * @param fileName
     */
    public static void touch(String filePath, String fileName) {
        try {
            String fullPath = combainPath(filePath, fileName);
            File file = new File(fullPath);
            touch(file);
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }

    /**
     * touch 创建文件
     *
     * @param fullPath
     */
    public static void touch(String fullPath) {
        try {
            File file = new File(fullPath);
            touch(file);
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }

    /**
     * touch 创建文件
     *
     * @param file
     */
    public static void touch(File file) {
        try {
            if (!file.exists()) {
                file.createNewFile();// 如果文件不存在则创建
            }
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }

    /**
     * rm 删除文件
     *
     * @param filePath
     * @param fileName
     */
    public static void rm(String filePath, String fileName) {
        try {
            String fullPath = combainPath(filePath, fileName);
            File file = new File(fullPath);
            rm(file);
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }

    /**
     * rm 删除文件
     *
     * @param fullPath
     */
    public static void rm(String fullPath) {
        try {
            File file = new File(fullPath);
            rm(file);
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }

    /**
     * rm 删除文件
     *
     * @param file
     */
    public static void rm(File file) {
        try {
            if (!file.exists()) {
                throw new FileNotFoundException();
            }
            if (file.isFile()) {
                file.delete();
            }
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }

    /**
     * rmdir 删除目录
     *
     * @param filePath
     * @param fileName
     * @param loop
     */
    public static void rmdir(String filePath, String fileName, boolean loop) {
        try {
            String fullPath = combainPath(filePath, fileName);
            File dir = new File(fullPath);
            rmdir(dir, loop);
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }

    /**
     * rmdir 删除目录
     *
     * @param fullPath
     * @param loop
     */
    public static void rmdir(String fullPath, boolean loop) {
        try {
            File dir = new File(fullPath);
            rmdir(dir, loop);
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }

    /**
     * rmdir 删除目录
     *
     * @param dir
     * @param loop
     */
    public static void rmdir(File dir, boolean loop) {
        try {
            if (!dir.exists()) {
                throw new FileNotFoundException();
            }
            if (dir.isDirectory()) {
                File[] files = dir.listFiles();
                int length = files.length;
                for (int i = 0; i < length && loop; i++) {
                    if (files[i].isDirectory()) {
                        rmdir(files[i], loop);
                    } else {
                        rm(files[i]);
                    }
                }
                if (loop || length == 0) {
                    dir.delete();
                }
            }
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }

    /**
     * du 获取文件实际大小
     *
     * @param filePath
     * @param fileName
     * @param loop
     * @return
     */
    public static long du(String filePath, String fileName, boolean loop) {
        long size = 0;
        try {
            String fullPath = combainPath(filePath, fileName);
            File file = new File(fullPath);
            size = du(file, loop);
        } catch (Exception ex) {
            ex.printStackTrace();
        }
        return size;
    }

    /**
     * du 获取文件实际大小
     *
     * @param filePath
     * @param fileName
     * @return
     */
    public static long du(String filePath, String fileName) {
        long size = 0;
        try {
            String fullPath = combainPath(filePath, fileName);
            File file = new File(fullPath);
            size = du(file, false);
        } catch (Exception ex) {
            ex.printStackTrace();
        }
        return size;
    }

    /**
     * du 获取文件实际大小
     *
     * @param fullPath
     * @return
     */
    public static long du(String fullPath) {
        long size = 0;
        try {
            File file = new File(fullPath);
            size = du(file, false);
        } catch (Exception ex) {
            ex.printStackTrace();
        }
        return size;
    }

    /**
     * du 获取文件实际大小
     *
     * @param file
     * @return
     */
    public static long du(File file) {
        long size = 0;
        try {
            size = du(file, false);
        } catch (Exception ex) {
            ex.printStackTrace();
        }
        return size;
    }

    /**
     * du 获取文件实际大小
     *
     * @param fullPath
     * @param loop
     * @return
     */
    public static long du(String fullPath, boolean loop) {
        long size = 0;
        try {
            File file = new File(fullPath);
            size = du(file, loop);
        } catch (Exception ex) {
            ex.printStackTrace();
        }
        return size;
    }

    /**
     * du 获取文件实际大小
     *
     * @param file
     * @param loop
     * @return
     */
    public static long du(File file, boolean loop) {
        FileChannel fileChannel = null;
        long size = 0;
        try {
            if (!file.exists()) {
                throw new FileNotFoundException();
            }
            if (file.isFile()) {
                FileInputStream fis = new FileInputStream(file);
                fileChannel = fis.getChannel();
                size = fileChannel.size();
            } else if (file.isDirectory()) {
                File[] files = file.listFiles();
                int length = files.length;
                for (int i = 0; i < length && loop; i++) {
                    if (files[i].isDirectory()) {
                        du(files[i], loop);
                    } else {
                        size += du(files[i], false);
                    }
                }
            }
        } catch (Exception ex) {
            ex.printStackTrace();
        } finally {
            if (null != fileChannel) {
                try {
                    fileChannel.close();
                } catch (Exception ex) {
                    ex.printStackTrace();
                }
            }
        }
        return size;
    }

    /**
     * 根据传入的文件夹目录返回目录下文件信息
     * 
     * @param path
     * @return fileCount：文件夹下压缩文件的个数，前台显示； files：压缩文件的list；
     *         fileNames：压缩文件夹的文件名，前台显示；
     *         fileInfoJson:包含fileCount、fileNames的json信息。
     */
    public static Map<String, Object> checkFolder(String path) {
        Map<String, Object> folderInfo = new HashMap<>();
        try {
            File file = new File(path);
            int fileCount = 0;
            List<File> files = new ArrayList<File>();
            List<String> fileNames = new ArrayList<>();
            if (!file.isDirectory()) {
                return null;
            } else {
                String[] fileList = file.list();
                for (int i = 0; i < fileList.length; i++) {
                    if (fileList[i].lastIndexOf(".zip") > 0 || fileList[i].lastIndexOf(".rar") > 0) {
                        fileCount++;
                        File eleFile = new File(path + File.separator + fileList[i]);
                        files.add(eleFile);
                        fileNames.add(fileList[i]);
                    }
                }
            }
            folderInfo.put("fileCount", fileCount);
            folderInfo.put("fileNames", fileNames);
            JSONObject jsonObject = JSONObject.fromObject(folderInfo);
            folderInfo.put("fileInfoJson", jsonObject.toString());
            folderInfo.put("files", files);

        } catch (Exception e) {
            // TODO: handle exception
        }

        return folderInfo;
    }

    /**
     * 文件上传
     * 
     * @param multipartRequest
     * @return
     */
    public static String uploadifyFiles(MultipartHttpServletRequest multipartRequest, String targetPath) {
        String responseStr = "";
        Map<String, MultipartFile> fileMap = multipartRequest.getFileMap();
        String configPath = File.separator;
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy");
        String year = sdf.format(new Date());
        configPath += year + File.separator;
        sdf = new SimpleDateFormat("MM");
        String month = sdf.format(new Date());
        configPath += month + File.separator;
        ContentID contentID = new ContentID(2L);
        long cid = contentID.nextId();
        configPath += cid + File.separator;
        targetPath += configPath;
        // 创建文件夹
        File file = new File(targetPath);
        if (!file.exists()) {
            file.mkdirs();
        }
        // 预留多文件上传，但流程需要另外改动
        for (Map.Entry<String, MultipartFile> entity : fileMap.entrySet()) {
            // 上传文件名
            MultipartFile mf = entity.getValue();
            String fileName = mf.getOriginalFilename();
            // String fileExt = fileName.substring(fileName.lastIndexOf(".") +
            // 1).toLowerCase();
            // SimpleDateFormat df = new SimpleDateFormat("yyyyMMddHHmmss");
            // String newFileName = df.format(new Date()) + "_" + new
            // Random().nextInt(1000) + "." + fileExt;
            responseStr = targetPath + fileName;
            File uploadFile = new File(targetPath + fileName);
            try {
                mf.transferTo(uploadFile);
                // FileCopyUtils.copy(mf.getBytes(), uploadFile);
            } catch (IOException e) {
                responseStr = "error";
                e.printStackTrace();
            }
        }
        return responseStr;
    }

    /**
     * 上传xsd文件，用户基础库建立时使用
     * 
     * @param multipartRequest
     * @param targetPath
     * @return
     */
    public static String uploadifyXsd(MultipartHttpServletRequest multipartRequest, String targetPath) {
        String responseStr = "";
        Map<String, MultipartFile> fileMap = multipartRequest.getFileMap();
        String configPath = File.separator;
        SimpleDateFormat df = new SimpleDateFormat("yyyyMMddHHmmss");
        String docName = df.format(new Date()) + "_" + new Random().nextInt(1000);
        configPath += docName + File.separator;
        targetPath += configPath;
        // 创建文件夹
        File file = new File(targetPath);
        if (!file.exists()) {
            file.mkdirs();
        }
        // 预留多文件上传，但流程需要另外改动
        for (Map.Entry<String, MultipartFile> entity : fileMap.entrySet()) {
            // 上传文件名
            MultipartFile mf = entity.getValue();
            String fileName = mf.getOriginalFilename();
            responseStr = targetPath + fileName;
            File uploadFile = new File(targetPath + fileName);
            try {
                mf.transferTo(uploadFile);
                // FileCopyUtils.copy(mf.getBytes(), uploadFile);
            } catch (IOException e) {
                responseStr = "error";
                e.printStackTrace();
            }
        }
        return responseStr;
    }

    /**
     * 上传企业资质
     * 
     * @param multipartRequest
     * @param targetPath
     * @return
     */
    public static String uploadifyCA(MultipartHttpServletRequest multipartRequest, String targetPath) {
        String responseStr = "";
        Map<String, MultipartFile> fileMap = multipartRequest.getFileMap();
        String configPath = File.separator;
        ContentID contentID = new ContentID(2L);
        long contentId = contentID.nextId();
        configPath += contentId + File.separator;
        targetPath += configPath;
        // 创建文件夹
        File file = new File(targetPath);
        if (!file.exists()) {
            file.mkdirs();
        }
        // 预留多文件上传，但流程需要另外改动
        for (Map.Entry<String, MultipartFile> entity : fileMap.entrySet()) {
            // 上传文件名
            MultipartFile mf = entity.getValue();
            String fileName = mf.getOriginalFilename();
            responseStr = targetPath + fileName;
            File uploadFile = new File(targetPath + fileName);
            try {
                mf.transferTo(uploadFile);
                // FileCopyUtils.copy(mf.getBytes(), uploadFile);
            } catch (IOException e) {
                responseStr = "error";
                e.printStackTrace();
            }
        }
        return responseStr;
    }

    public static void uploadSimpleFile(CommonsMultipartFile file, String targetPath) {
        File targetFile = new File(targetPath).getParentFile();
        if (!targetFile.exists())
            targetFile.mkdirs();
        if (!file.isEmpty()) {
            try {
                FileOutputStream fos = new FileOutputStream(targetPath);
                InputStream in = file.getInputStream();
                int b = 0;
                while ((b = in.read()) != -1) {
                    fos.write(b);
                }
                fos.close();
                in.close();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

    public static void inputstreamtofile(InputStream ins, File file) {
        OutputStream os;
        try {
            os = new FileOutputStream(file);
            int bytesRead = 0;
            byte[] buffer = new byte[8192];
            while ((bytesRead = ins.read(buffer, 0, 8192)) != -1) {
                os.write(buffer, 0, bytesRead);
            }
            os.close();
            ins.close();

        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

    /**
     * 删除过期的文件
     * 
     * @param file
     * @param save_days
     */
    public static void deleteOutOfDaysFiles(File file, int save_days) {
        if (file.exists()) {
            if (file.isDirectory()) {
                // 2016 , 年
                File[] files = file.listFiles();
                if (files != null && files.length > 0) {
                    for (int i = 0; i < files.length; i++) {
                        try {
                            int days = DateUtil.daysBetween(new Date(file.lastModified()), new Date());
                            if (days > save_days) {
                                if (files[i].isDirectory()) {
                                    FileTools.rmdir(files[i], true);
                                } else {
                                    FileTools.rm(file);
                                }
                            } else {
                                // 11，月
                                deleteOutOfDaysFiles(files[i], save_days);
                            }
                        } catch (ParseException e) {
                            // TODO Auto-generated catch block
                            e.printStackTrace();
                        }
                    }
                }
            } else {
                int days;
                try {
                    days = DateUtil.daysBetween(new Date(file.lastModified()), new Date());
                    if (days > save_days) {
                        FileTools.rm(file);
                    }
                } catch (ParseException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }

            }

        }
    }

    public static List<File> getFileList(String strPath) {

        File dir = new File(strPath);

        File[] files = dir.listFiles();
        // 该文件目录下文件全部放入数组
        List<File> filelist = new ArrayList<>();

        if (files != null) {
            for (int i = 0; i < files.length; i++) {
                String fileName = files[i].getName();
                if (files[i].isDirectory()) { // 判断是文件还是文件夹
                    getFileList(files[i].getAbsolutePath()); // 获取文件绝对路径
                } else if (fileName.endsWith("avi")) { // 判断文件名是否以.avi结尾

                    filelist.add(files[i]);
                } else {
                    continue;
                }
            }

        }
        return filelist;
    }

    public static String shareFile(String sourcePath, String tarPath, String cid) {

        String toURL = tarPath;

        SimpleDateFormat sdf = new SimpleDateFormat("yyyy");
        String year = sdf.format(new Date());
        toURL +=File.separator+ year + File.separator;
        sdf = new SimpleDateFormat("MM");
        String month = sdf.format(new Date());
        toURL += month + File.separator;
        String toRealUrl = toURL;
        File souceFile = new File(sourcePath);
        String str = "";
        if (souceFile.exists() && souceFile.isDirectory()) {

            str = sourcePath.substring(sourcePath.lastIndexOf(File.separator));
            toRealUrl = toRealUrl + File.separator + cid + File.separator;

        } else {

            String parentPath = souceFile.getParent();
            str = parentPath.substring(parentPath.lastIndexOf(File.separator));
            toRealUrl = toRealUrl + File.separator + cid + File.separator + str;

        }

        // 创建文件夹
        File file = new File(toRealUrl);

        if (!file.exists()) {

            file.mkdirs();
        }

        String newUrl = "";

        if (souceFile.exists() && souceFile.isDirectory()) {

            cutGeneralFile(sourcePath, file.getAbsolutePath());
            newUrl = file.getAbsolutePath() + File.separator + str;

        } else {
            
            if(souceFile.getName().toLowerCase().endsWith(".xml")){
                
                sourcePath=souceFile.getParent();
                cutGeneralFile(sourcePath, file.getParent());
            }else{
            copyFile(sourcePath, file.getAbsolutePath());            
            }
            newUrl = file.getAbsolutePath() + File.separator + souceFile.getName();
        }

        return newUrl;

    }

    public static boolean shareFile2(String sourcePath, String tarPath) {

        String toURL = tarPath;

        File souceFile = new File(sourcePath);

        if (!new File(toURL).exists())

            new File(toURL).mkdirs();

        if (souceFile.exists() && souceFile.isDirectory()) {

            return cutGeneralFile(sourcePath, toURL);

        } else {

            File parentFile = souceFile.getParentFile();
            toURL = toURL + File.separator;
            copyFile(sourcePath, toURL);
            return true;

        }

    }

    /**
     * 获取不带扩展名的文件名
     * 
     * @param filename
     * @return
     */
    public static String getFileNameNoEx(String filename) {

        if ((filename != null) && (filename.length() > 0)) {
            int dot = filename.lastIndexOf('.');
            if ((dot > -1) && (dot < (filename.length()))) {
                return filename.substring(0, dot);
            }
        }
        return filename;
    }

    // 获取文件的上上级目录
    public static String hPPPath(String file) {

        File fil = new File(file);
        String str = fil.getParent();

        File pfile = new File(str);
        String str2 = pfile.getParent();
        return str2;
    }

    // 获取文件的上级目录
    public static String hPPath(String file) {

        File fil = new File(file);

        return fil.getParent();
    }

    /**
     * 
     * @param file
     * @return
     */
    public static List<File> sortFileType(List<File> subList) {

        List<File> txtFile = new ArrayList<File>();
        List<File> docFile = new ArrayList<File>();
        List<File> pdfFile = new ArrayList<File>();
        List<File> xmlFile = new ArrayList<File>();
        List<File> htmlFile = new ArrayList<File>();

        List<File> filesAll = new ArrayList<File>();

        for (int i = 0; i < subList.size(); i++) {

            File file = subList.get(i);

            if (file.getAbsolutePath().contains(".txt")) {

                txtFile.add(file);

            } else if (file.getAbsolutePath().contains(".doc") || file.getAbsolutePath().contains(".docx")) {

                docFile.add(file);

            } else if (file.getAbsolutePath().contains(".pdf")) {

                pdfFile.add(file);

            } else if (file.getName().contains(".xml")) {

                xmlFile.add(file);

            } else if (file.getName().contains(".html")) {

                htmlFile.add(file);

            }

        }

        if (txtFile.size() > 0) {
            filesAll.addAll(txtFile);
        }
        if (docFile.size() > 0) {
            filesAll.addAll(docFile);
        }
        if (pdfFile.size() > 0) {
            filesAll.addAll(pdfFile);
        }
        if (xmlFile.size() > 0) {
            filesAll.addAll(xmlFile);
        }
        if (htmlFile.size() > 0) {
            filesAll.addAll(htmlFile);
        }

        return filesAll;
    }

    /**
     * 复制文件或文件夹
     * 
     * @param srcPath
     * @param destDir
     *            目标文件所在的目录
     * @return
     */
    public static boolean copyGeneralFile(String srcPath, String destDir) {

        boolean flag = false;
        File file = new File(srcPath);

        if (!file.exists()) {
            return false;
        }

        if (file.isFile()) { // 源文件
            flag = copyFile(srcPath, destDir);
        } else if (file.isDirectory()) {
            flag = copyDirectory(srcPath, destDir);
        }

        return flag;
    }

    /**
     * 复制文件
     * 
     * @param srcPath
     *            源文件绝对路径
     * @param destDir
     *            目标文件所在目录
     * @return boolean
     */
    private static boolean copyFile(String srcPath, String destDir) {
        boolean flag = false;

        File srcFile = new File(srcPath);

        if (!srcFile.exists()) { // 源文件不存在
            return false;
        }
        // 获取待复制文件的文件名
        String fileName = srcPath.substring(srcPath.lastIndexOf(File.separator));
        String destPath = destDir + fileName;
        if (destPath.equals(srcPath)) { // 源文件路径和目标文件路径重复
            return false;
        }

        File destFile = new File(destPath);

        if (destFile.exists() && destFile.isFile()) { // 该路径下已经有一个同名文件

            //// 获取导入文件的文件名
            String srcStr = destPath.substring(0, destPath.indexOf("."));

            int i = 0;

            String destFileParent = destFile.getParent();

            // 获取目标的的所有文件

            List<File> files = getFiles(destFileParent, true);

            for (File file : files) {

                // 获取每个文件的文件名
                String destStr = file.getAbsolutePath().substring(0, file.getAbsolutePath().indexOf("."));

                if (destStr.contains(srcStr)) {

                    i++;
                }
            }

            // 获取要导入路径下的所有包含该文件名称的内容
            String str = srcPath.substring(srcPath.lastIndexOf(File.separator));

            StringBuilder fn = new StringBuilder(str);

            if (fileName.indexOf(".") > 0) {

                fn.insert(fn.lastIndexOf("."), "_副本(" + i + ")");

            } else {

                fn.append("_副本(" + i + ")");
            }

            destFile = new File(destDir + fn.toString());

            if (!destFile.exists()) {

                try {
                    destFile.createNewFile();
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }

        }

        File destFileDir = new File(destDir);

        destFileDir.mkdirs();

        try {
            FileInputStream fis = new FileInputStream(srcPath);
            FileOutputStream fos = new FileOutputStream(destFile);
            byte[] buf = new byte[1024];
            int c;
            while ((c = fis.read(buf)) != -1) {
                fos.write(buf, 0, c);
            }

            fis.close();
            fos.close();

            flag = true;
        } catch (IOException e) {
            //
        }

        if (flag) {
        }

        return flag;
    }

    /**
     * 
     * @param srcPath
     *            源文件夹路径
     * @param destPath
     *            目标文件夹所在目录
     * @return
     */
    private static boolean copyDirectory(String srcPath, String destDir) {
        boolean flag = false;

        File srcFile = new File(srcPath);
        if (!srcFile.exists()) { // 源文件夹不存在
            return false;
        }
        // 获得待复制的文件夹的名字，比如待复制的文件夹为"E:\dir"则获取的名字为"dir"
        String dirName = new File(srcPath).getName();
        // String dirName = getDirName(srcPath);
        // 目标文件夹的完整路径
        String destPath = destDir + File.separator + dirName;
        // System.out.println("目标文件夹的完整路径为：" + destPath);

        if (destPath.equals(srcPath)) {
            return false;
        }
        File destDirFile = new File(destPath);

        if (!destDirFile.exists()) {

            destDirFile.mkdirs(); // 生成目录

        }

        File[] fileList = srcFile.listFiles(); // 获取源文件夹下的子文件和子文件夹
        if (fileList.length == 0) { // 如果源文件夹为空目录则直接设置flag为true，这一步非常隐蔽，debug了很久
            flag = true;
        } else {
            for (File temp : fileList) {
                if (temp.isFile()) { // 文件
                    flag = copyFile(temp.getAbsolutePath(), destPath);
                } else if (temp.isDirectory()) { // 文件夹
                    flag = copyDirectory(temp.getAbsolutePath(), destPath);
                }
                if (!flag) {
                    break;
                }
            }
        }

        if (flag) {
        }

        return flag;
    }

    /**
     * 获取待复制文件夹的文件夹名
     * 
     * @param dir
     * @return String
     */
    private static String getDirName(String dir) {
        if (dir.endsWith(File.separator)) { // 如果文件夹路径以"\"结尾，则先去除末尾的"\"
            dir = dir.substring(0, dir.lastIndexOf(File.separator));
        }
        return dir.substring(dir.lastIndexOf(File.separator) + 1);
    }

    /**
     * 删除文件或文件夹
     * 
     * @param path
     *            待删除的文件的绝对路径
     * @return boolean
     */
    public static boolean deleteGeneralFile(String path) {
        boolean flag = false;

        File file = new File(path);

        if (!file.exists()) {
        }

        if (file.isDirectory()) { // 如果是目录，则单独处理
            flag = deleteDirectory(file.getAbsolutePath());
        } else if (file.isFile()) {
            flag = deleteFile(file);
        }

        if (flag) {
        }

        return flag;
    }

    /**
     * 删除文件
     * 
     * @param file
     * @return boolean
     */
    private static boolean deleteFile(File file) {

        return file.delete();

    }

    /**
     * 删除目录及其下面的所有子文件和子文件夹，注意一个目录下如果还有其他文件或文件夹
     * 则直接调用delete方法是不行的，必须待其子文件和子文件夹完全删除了才能够调用delete
     * 
     * @param path
     *            path为该目录的路径
     */
    private static boolean deleteDirectory(String path) {
        boolean flag = true;
        File dirFile = new File(path);
        if (!dirFile.isDirectory()) {
            return flag;
        }
        File[] files = dirFile.listFiles();
        for (File file : files) { // 删除该文件夹下的文件和文件夹
            // Delete file.
            if (file.isFile()) {
                flag = deleteFile(file);
            } else if (file.isDirectory()) {// Delete folder
                flag = deleteDirectory(file.getAbsolutePath());
            }
            if (!flag) { // 只要有一个失败就立刻不再继续
                break;
            }
        }
        flag = dirFile.delete(); // 删除空目录
        return flag;
    }

    /**
     * 由上面方法延伸出剪切方法：复制+删除
     * 
     * @param destDir
     *            同上
     */
    public static boolean cutGeneralFile(String srcPath, String destDir) {

        if (!copyGeneralFile(srcPath, destDir)) {
            return false;
        }

        if (!deleteGeneralFile(srcPath)) {
            return false;
        }

        return true;
    }

    public static String[] getFileNameFromUrl(String url) {
        if (url != null && !url.equals("") && !url.equals("null")) {
            File file = new File(url);
            if (file.exists()) {
                if (file.isDirectory()) {
                    return file.list();
                } else if (file.isFile()) {
                    return new String[] { file.getName() };
                }
            }
        }
        return null;
    }

    public static void deleteFileOrDirectory(String filePath) {

        File file = new File(filePath);

        if (file.exists()) {
            if (file.isDirectory()) {

                rmdir(file, true);

            } else if (file.isFile()) {

                if (filePath.equals(".xml") || filePath.equals(".html") || filePath.equals("htm")) {

                    rmdir(file.getParent(), true);

                } else {
                    rm(file);

                }
            }
        }
    }

    public static String getEnclosure(String filePath) {

        File sourceFile = new File(filePath);

        String tarPath = null;
        if (sourceFile.exists()) {

            if (sourceFile.isFile()) {

                tarPath = getEnclosure(sourceFile.getParent());

            } else if (sourceFile.isDirectory()) {

                tarPath = sourceFile.getParent();

            }

        }
        return tarPath;

    }

    public static int getFileCount(String filePath) {

        int count=0;
        File file = new File(filePath);
        File parentFile = null;
        if (file.isDirectory()) {
            parentFile = file;
        } else if (file.isFile()) {
            parentFile = file.getParentFile();

        }

        if (parentFile != null) {

            List<File> files=getFiles(parentFile, true);

            count=files.size();
        }

        return count;
    }

    // 获取文件夹的大小
    public static Long fileSize(String filePath) {

        long fileSize = 0l;
        File file = new File(filePath);
        File parentFile = null;
        if (file.isDirectory()) {
            parentFile = file;
        } else if (file.isFile()) {
            parentFile = file.getParentFile();

        }

        if (parentFile != null) {

            List<File> files=getFiles(parentFile, true);

            for (File f : files) {

                if (f.exists() && f.isFile()) {

                    fileSize += f.length();
                }
            }
        }

        return fileSize;

    }

    // 文件大小转化为 tb/mb/gb/tb
    public static String fileSizeToMB(long fileS) {
        String size = "";
        DecimalFormat df = new DecimalFormat("#.00");
        if (fileS < 1024) {
            size = df.format((double) fileS) + "BT";
        } else if (fileS < 1048576) {
            size = df.format((double) fileS / 1024) + "KB";
        } else if (fileS < 1073741824) {
            size = df.format((double) fileS / 1048576) + "MB";
        } else {
            size = df.format((double) fileS / 1073741824) + "GB";
        }
        return size;

    }

    public static void main(String[] args) {

    }

}