【Java工具】之文件工具类(四)

在开发中关于文件的操作是很常见的，为了以后方便先总结起来，方便自己也方便大家。同时也欢迎大家指正和补充。

1.得到文件的输入流

 /**
     * 得到文件的输入流，如无法定位文件返回null。
     * 
     * @param relativePath
     *            文件相对当前应用程序的类加载器的路径。
     * @return 文件的输入流。
     */
    public static InputStream getResourceStream(String relativePath) {
        return Thread.currentThread().getContextClassLoader().getResourceAsStream(relativePath);
    }

2.关闭输入流

    /**
     * 关闭输入流。
     * 
     * @param is 输入流，可以是null。
     */
    public static void closeInputStream(InputStream is) {
        if (is != null) {
            try {
                is.close();
            } catch (IOException e) {
            }
        }
    }

    public static void closeFileOutputStream(FileOutputStream fos) {
        if (fos != null) {
            try {
                fos.close();
            } catch (IOException e) {
            }
        }
    }

3.从文件路径中提取目录路径

 /**
     * 从文件路径中提取目录路径，如果文件路径不含目录返回null。
     * 
     * @param filePath 文件路径。
     * @return 目录路径，不以'/'或操作系统的文件分隔符结尾。
     */
    public static String extractDirPath(String filePath) {
        int separatePos = Math.max(filePath.lastIndexOf('/'), filePath.lastIndexOf('\\')); // 分隔目录和文件名的位置
        return separatePos == -1 ? null : filePath.substring(0, separatePos);
    }

4.从文件路径中提取文件名

  /**
     * 从文件路径中提取文件名, 如果不含分隔符返回null
     * 
     * @param filePath
     * @return 文件名, 如果不含分隔符返回null
     */
    public static String extractFileName(String filePath) {
        int separatePos = Math.max(filePath.lastIndexOf('/'), filePath.lastIndexOf('\\')); // 分隔目录和文件名的位置
        return separatePos == -1 ? null : filePath.substring(separatePos + 1, filePath.length());
    }

5.按路径建立文件

  /**
     * 按路径建立文件，如已有相同路径的文件则不建立。
     * 
     * @param filePath 要建立文件的路径。
     * @return 表示此文件的File对象。
     * @throws IOException 如路径是目录或建文件时出错抛异常。
     */
    public static File makeFile(String filePath) {
        File file = new File(filePath);
        if (file.isFile())
            return file;
        if (filePath.endsWith("/") || filePath.endsWith("\\"))
            try {
                throw new IOException(filePath + " is a directory");
            } catch (IOException e) {
                e.printStackTrace();
            }

        String dirPath = extractDirPath(filePath); // 文件所在目录的路径

        if (dirPath != null) { // 如文件所在目录不存在则先建目录
            makeFolder(dirPath);
        }

        try {
            file.createNewFile();
        } catch (IOException e) {
            e.printStackTrace();
        }
        // log4j.info("Folder has been created: " + filePath);
        // System.out.println("文件已创建: " + filePath);
        return file;
    }

6.新建目录,支持建立多级目录

/**
     * 新建目录,支持建立多级目录
     * 
     * @param folderPath 新建目录的路径字符串
     * @return boolean,如果目录创建成功返回true,否则返回false
     */
    public static boolean makeFolder(String folderPath) {
        try {
            File myFilePath = new File(folderPath);
            if (!myFilePath.exists()) {
                myFilePath.mkdirs();
                // System.out.println("新建目录为：" + folderPath);
                // log4j.info("Create new folder：" + folderPath);
            } else {
                // System.out.println("目录已经存在: " + folderPath);
                // log4j.info("Folder is existed：" + folderPath);
            }
        } catch (Exception e) {
            // System.out.println("新建目录操作出错");
            e.printStackTrace();
            // log4j.error("Create new folder error: " + folderPath);
            return false;
        }
        return true;
    }

7.删除文件

  /**
     * 删除文件
     * 
     * @param filePathAndName 要删除文件名及路径
     * @return boolean 删除成功返回true,删除失败返回false
     */
    public static boolean deleteFile(String filePathAndName) {
        try {
            File myDelFile = new File(filePathAndName);
            if (myDelFile.exists()) {
                myDelFile.delete();
                // log4j.info("File：" + filePathAndName +
                // " has been deleted!!!");
            }
        } catch (Exception e) {
            e.printStackTrace();
            // log4j.error("Error delete file：" + filePathAndName);
            return false;
        }
        return true;
    }

8.递归删除指定目录中所有文件和子文件夹

/**
     * 递归删除指定目录中所有文件和子文件夹
     * 
     * @param path
     *            某一目录的路径,如"c:\cs"
     * @param ifDeleteFolder
     *            boolean值,如果传true,则删除目录下所有文件和文件夹;如果传false,则只删除目录下所有文件,子文件夹将保留
     */
    public static void deleteAllFile(String path, boolean ifDeleteFolder) {
        File file = new File(path);
        if (!file.exists()) {
            return;
        }
        if (!file.isDirectory()) {
            return;
        }
        String[] tempList = file.list();
        String temp = null;
        for (int i = 0; i < tempList.length; i++) {
            if (path.endsWith("\\") || path.endsWith("/"))
                temp = path + tempList[i];
            else
                temp = path + File.separator + tempList[i];
            if ((new File(temp)).isFile()) {
                deleteFile(temp);
            } else if ((new File(temp)).isDirectory() && ifDeleteFolder) {
                deleteAllFile(path + File.separator + tempList[i], ifDeleteFolder);// 先删除文件夹里面的文件
                deleteFolder(path + File.separator + tempList[i]);// 再删除空文件夹
            }
        }
    }

9.删除文件夹,包括里面的文件

 /**
     * 删除文件夹,包括里面的文件
     * 
     * @param folderPath 文件夹路径字符串
     */
    public static void deleteFolder(String folderPath) {
        try {
            File myFilePath = new File(folderPath);
            if (myFilePath.exists()) {
                deleteAllFile(folderPath, true); // 删除完里面所有内容
                myFilePath.delete(); // 删除空文件夹
            }
            // log4j.info("ok!Delete folder success: " + folderPath);
        } catch (Exception e) {
            e.printStackTrace();
            // log4j.error("Delete folder fail: " + folderPath);
        }
    }

10.复制文件

 /**
     * 复制文件,如果目标文件的路径不存在,会自动新建路径
     * 
     * @param sourcePath
     *            源文件路径, e.g. "c:/cs.txt"
     * @param targetPath
     *            目标文件路径 e.g. "f:/bb/cs.txt"
     */
    public static void copyFile(String sourcePath, String targetPath) {
        InputStream inStream = null;
        FileOutputStream fos = null;
        try {
            int byteSum = 0;
            int byteRead = 0;
            File sourcefile = new File(sourcePath);
            if (sourcefile.exists()) { // 文件存在时
                inStream = new FileInputStream(sourcePath); // 读入原文件
                String dirPath = extractDirPath(targetPath); // 文件所在目录的路径
                if (dirPath != null) { // 如文件所在目录不存在则先建目录
                    makeFolder(dirPath);
                }
                fos = new FileOutputStream(targetPath);
                byte[] buffer = new byte[1444];
                while ((byteRead = inStream.read(buffer)) != -1) {
                    byteSum += byteRead; // 字节数 文件大小
                    fos.write(buffer, 0, byteRead);
                }
                System.out.println("File size is: " + byteSum);

                // log4j.info("Source path is -->" + sourcePath);
                // log4j.info("Target path is-->" + targetPath);
                // log4j.info("File size is-->" + byteSum);

            }
        } catch (Exception e) {
            e.printStackTrace();
            // log4j.debug("Copy single file fail: " + sourcePath);
        } finally {
            closeInputStream(inStream);
            closeFileOutputStream(fos);
        }
    }

11.将路径和文件名拼接起来

/**
     * 将路径和文件名拼接起来
     * 
     * @param folderPath
     *            某一文件夹路径字符串，e.g. "c:\cs\" 或 "c:\cs"
     * @param fileName
     *            某一文件名字符串, e.g. "cs.txt"
     * @return 文件全路径的字符串
     */
    public static String makeFilePath(String folderPath, String fileName) {
        return folderPath.endsWith("\\") || folderPath.endsWith("/") ? folderPath + fileName : folderPath + File.separatorChar + fileName;
    }

12.将某一文件夹下的所有文件和子文件夹拷贝到目标文件夹

 /**
     * 将某一文件夹下的所有文件和子文件夹拷贝到目标文件夹，若目标文件夹不存在将自动创建
     * 
     * @param sourcePath
     *            源文件夹字符串，e.g. "c:\cs"
     * @param targetPath
     *            目标文件夹字符串，e.g. "d:\tt\qq"
     */
    @SuppressWarnings("unused")
    public static void copyFolder(String sourcePath, String targetPath) {
        FileInputStream input = null;
        FileOutputStream output = null;
        try {
            makeFolder(targetPath); // 如果文件夹不存在 则建立新文件夹
            String[] file = new File(sourcePath).list();
            File temp = null;
            for (int i = 0; i < file.length; i++) {
                String tempPath = makeFilePath(sourcePath, file[i]);
                temp = new File(tempPath);
                String target = "";
                if (temp.isFile()) {
                    input = new FileInputStream(temp);
                    output = new FileOutputStream(target = makeFilePath(targetPath, file[i]));
                    byte[] b = new byte[1024 * 5];
                    int len = 0;
                    int sum = 0;
                    while ((len = input.read(b)) != -1) {
                        output.write(b, 0, len);
                        sum += len;
                    }
                    target = target + "";
                    output.flush();
                    closeInputStream(input);
                    closeFileOutputStream(output);

                    // log4j.info("Source path-->" + tempPath);
                    // log4j.info("Target path-->" + target);
                    // log4j.info("File size-->" + sum);

                } else if (temp.isDirectory()) {// 如果是子文件夹
                    copyFolder(sourcePath + '/' + file[i], targetPath + '/' + file[i]);
                }
            }
        } catch (Exception e) {
            // log4j.info("Copy all the folder fail!");
            e.printStackTrace();
        } finally {
            closeInputStream(input);
            closeFileOutputStream(output);
        }
    }

13.移动文件

 /**
     * 移动文件
     * 
     * @param oldFilePath
     *            旧文件路径字符串, e.g. "c:\tt\cs.txt"
     * @param newFilePath
     *            新文件路径字符串, e.g. "d:\kk\cs.txt"
     */
    public static void moveFile(String oldFilePath, String newFilePath) {
        copyFile(oldFilePath, newFilePath);
        deleteFile(oldFilePath);
    }

14.移动文件夹

/**
     * 移动文件夹
     * 
     * @param oldFolderPath
     *            旧文件夹路径字符串，e.g. "c:\cs"
     * @param newFolderPath
     *            新文件夹路径字符串，e.g. "d:\cs"
     */
    public static void moveFolder(String oldFolderPath, String newFolderPath) {
        copyFolder(oldFolderPath, newFolderPath);
        deleteFolder(oldFolderPath);

    }

---

转载地址请移步这里。如有问题，劳烦通知删除！