網上的版本太多，整合了一下適合自己用的工具類，包括讀取、保存、拷貝文件等。

public class FileUtil {
    /**
     * 私有構造方法，防止類的實例化，因為工具類不需要實例化。
     */
    private FileUtil() {

    }

    /**
     * 修改文件的最後訪問時間。
     * 如果文件不存在則創建該文件。
     * <b>目前這個方法的行為方式還不穩定，主要是方法有些信息輸出，這些信息輸出是否保留還在考慮中。</b>
     *
     * @param file 需要修改最後訪問時間的文件。
     * @since 1.0
     */
    public static void touch(File file) {
        long currentTime = System.currentTimeMillis();
        if (!file.exists()) {
            System.err.println("file not found:" + file.getName());
            System.err.println("Create a new file:" + file.getName());
            try {
                if (file.createNewFile()) {
                    System.out.println("Succeeded!");
                } else {
                    System.err.println("Create file failed!");
                }
            } catch (IOException e) {
                System.err.println("Create file failed!");
                e.printStackTrace();
            }
        }
        boolean result = file.setLastModified(currentTime);
        if (!result) {
            System.err.println("touch failed: " + file.getName());
        }
    }

    /**
     * 修改文件的最後訪問時間。
     * 如果文件不存在則創建該文件。
     * <b>目前這個方法的行為方式還不穩定，主要是方法有些信息輸出，這些信息輸出是否保留還在考慮中。</b>
     *
     * @param fileName 需要修改最後訪問時間的文件的文件名。
     * @since 1.0
     */
    public static void touch(String fileName) {
        File file = new File(fileName);
        touch(file);
    }

    /**
     * 修改文件的最後訪問時間。
     * 如果文件不存在則創建該文件。
     * <b>目前這個方法的行為方式還不穩定，主要是方法有些信息輸出，這些信息輸出是否保留還在考慮中。</b>
     *
     * @param files 需要修改最後訪問時間的文件數組。
     * @since 1.0
     */
    public static void touch(File[] files) {
        for (int i = 0; i < files.length; i++) {
            touch(files[i]);
        }
    }

    /**
     * 修改文件的最後訪問時間。
     * 如果文件不存在則創建該文件。
     * <b>目前這個方法的行為方式還不穩定，主要是方法有些信息輸出，這些信息輸出是否保留還在考慮中。</b>
     *
     * @param fileNames 需要修改最後訪問時間的文件名數組。
     * @since 1.0
     */
    public static void touch(String[] fileNames) {
        File[] files = new File[fileNames.length];
        for (int i = 0; i < fileNames.length; i++) {
            files[i] = new File(fileNames[i]);
        }
        touch(files);
    }

    /**
     * 判斷指定的文件是否存在。
     *
     * @param fileName 要判斷的文件的文件名
     * @return 存在時返回true，否則返回false。
     * @since 1.0
     */
    public static boolean isFileExist(String fileName) {
        return new File(fileName).isFile();
    }

    /**
     * 創建指定的目錄。
     * 如果指定的目錄的父目錄不存在則創建其目錄書上所有需要的父目錄。
     * <b>註意：可能會在返回false的時候創建部分父目錄。</b>
     *
     * @param file 要創建的目錄
     * @return 完全創建成功時返回true，否則返回false。
     * @since 1.0
     */
    public static boolean makeDirectory(File file) {
        File parent = file.getParentFile();
        if (parent != null) {
            return parent.mkdirs();
        }
        return false;
    }

    /**
     * 創建指定的目錄。
     * 如果指定的目錄的父目錄不存在則創建其目錄書上所有需要的父目錄。
     * <b>註意：可能會在返回false的時候創建部分父目錄。</b>
     *
     * @param fileName 要創建的目錄的目錄名
     * @return 完全創建成功時返回true，否則返回false。
     * @since 1.0
     */
    public static boolean makeDirectory(String fileName) {
        File file = new File(fileName);
        return makeDirectory(file);
    }

    /**
     * 清空指定目錄中的文件。
     * 這個方法將盡可能刪除所有的文件，但是只要有一個文件沒有被刪除都會返回false。
     * 另外這個方法不會叠代刪除，即不會刪除子目錄及其內容。
     *
     * @param directory 要清空的目錄
     * @return 目錄下的所有文件都被成功刪除時返回true，否則返回false.
     * @since 1.0
     */
    public static boolean emptyDirectory(File directory) {
        boolean result = true;
        File[] entries = directory.listFiles();
        for (int i = 0; i < entries.length; i++) {
            if (!entries[i].delete()) {
                result = false;
            }
        }
        return result;
    }

    /**
     * 清空指定目錄中的文件。
     * 這個方法將盡可能刪除所有的文件，但是只要有一個文件沒有被刪除都會返回false。
     * 另外這個方法不會叠代刪除，即不會刪除子目錄及其內容。
     *
     * @param directoryName 要清空的目錄的目錄名
     * @return 目錄下的所有文件都被成功刪除時返回true，否則返回false。
     * @since 1.0
     */
    public static boolean emptyDirectory(String directoryName) {
        File dir = new File(directoryName);
        return emptyDirectory(dir);
    }

    /**
     * 刪除指定目錄及其中的所有內容。
     *
     * @param dirName 要刪除的目錄的目錄名
     * @return 刪除成功時返回true，否則返回false。
     * @since 1.0
     */
    public static boolean deleteDirectory(String dirName) {
        return deleteDirectory(new File(dirName));
    }

    /**
     * 刪除指定目錄及其中的所有內容。
     *
     * @param dir 要刪除的目錄
     * @return 刪除成功時返回true，否則返回false。
     * @since 1.0
     */
    public static boolean deleteDirectory(File dir) {
        if ((dir == null) || !dir.isDirectory()) {
            throw new IllegalArgumentException("Argument " + dir +
                    " is not a directory. ");
        }

        File[] entries = dir.listFiles();
        int sz = entries.length;

        for (int i = 0; i < sz; i++) {
            if (entries[i].isDirectory()) {
                if (!deleteDirectory(entries[i])) {
                    return false;
                }
            } else {
                if (!entries[i].delete()) {
                    return false;
                }
            }
        }

        if (!dir.delete()) {
            return false;
        }
        return true;
    }

    /**
     * 列出目錄中的所有內容，包括其子目錄中的內容。
     *
     * @param file   要列出的目錄
     * @param filter 過濾器
     * @return 目錄內容的文件數組。
     * @since 1.0
     */
    public static File[] listAll(File file,
                                 javax.swing.filechooser.FileFilter filter) {
        ArrayList list = new ArrayList();
        File[] files;
        if (!file.exists() || file.isFile()) {
            return null;
        }
        list(list, file, filter);
        files = new File[list.size()];
        list.toArray(files);
        return files;
    }

    /**
     * 將目錄中的內容添加到列表。
     *
     * @param list   文件列表
     * @param filter 過濾器
     * @param file   目錄
     */
    private static void list(ArrayList list, File file,
                             javax.swing.filechooser.FileFilter filter) {
        if (filter.accept(file)) {
            list.add(file);
            if (file.isFile()) {
                return;
            }
        }
        if (file.isDirectory()) {
            File files[] = file.listFiles();
            for (int i = 0; i < files.length; i++) {
                list(list, files[i], filter);
            }
        }

    }

    /**
     * 返回文件的URL地址。
     *
     * @param file 文件
     * @return 文件對應的的URL地址
     * @throws MalformedURLException
     * @since 1.0
     * @deprecated 在實現的時候沒有註意到File類本身帶一個toURL方法將文件路徑轉換為URL。
     * 請使用File.toURL方法。
     */
    public static URL getURL(File file) throws MalformedURLException {
        String fileURL = "file:/" + file.getAbsolutePath();
        URL url = new URL(fileURL);
        return url;
    }

    /**
     * 從文件路徑得到文件名。
     *
     * @param filePath 文件的路徑，可以是相對路徑也可以是絕對路徑
     * @return 對應的文件名
     * @since 1.0
     */
    public static String getFileName(String filePath) {
        File file = new File(filePath);
        return file.getName();
    }

    /**
     * 從文件名得到文件絕對路徑。
     *
     * @param fileName 文件名
     * @return 對應的文件路徑
     * @since 1.0
     */
    public static String getFilePath(String fileName) {
        File file = new File(fileName);
        return file.getAbsolutePath();
    }

    /**
     * 將DOS/Windows格式的路徑轉換為UNIX/Linux格式的路徑。
     * 其實就是將路徑中的"\"全部換為"/"，因為在某些情況下我們轉換為這種方式比較方便，
     * 某中程度上說"/"比"\"更適合作為路徑分隔符，而且DOS/Windows也將它當作路徑分隔符。
     *
     * @param filePath 轉換前的路徑
     * @return 轉換後的路徑
     * @since 1.0
     */
    public static String toUNIXpath(String filePath) {
        return filePath.replace(‘\\‘, ‘/‘);
    }

    /**
     * 從文件名得到UNIX風格的文件絕對路徑。
     *
     * @param fileName 文件名
     * @return 對應的UNIX風格的文件路徑
     * @see #toUNIXpath(String filePath) toUNIXpath
     * @since 1.0
     */
    public static String getUNIXfilePath(String fileName) {
        File file = new File(fileName);
        return toUNIXpath(file.getAbsolutePath());
    }

    /**
     * 得到文件的類型。
     * 實際上就是得到文件名中最後一個“.”後面的部分。
     *
     * @param fileName 文件名
     * @return 文件名中的類型部分
     * @since 1.0
     */
    public static String getTypePart(String fileName) {
        int point = fileName.lastIndexOf(‘.‘);
        int length = fileName.length();
        if (point == -1 || point == length - 1) {
            return "";
        } else {
            return fileName.substring(point + 1, length);
        }
    }

    /**
     * 得到文件的類型。
     * 實際上就是得到文件名中最後一個“.”後面的部分。
     *
     * @param file 文件
     * @return 文件名中的類型部分
     * @since 1.0
     */
    public static String getFileType(File file) {
        return getTypePart(file.getName());
    }

    /**
     * 得到文件的名字部分。
     * 實際上就是路徑中的最後一個路徑分隔符後的部分。
     *
     * @param fileName 文件名
     * @return 文件名中的名字部分
     * @since 1.0
     */
    public static String getNamePart(String fileName) {
        int point = getPathLsatIndex(fileName);
        int length = fileName.length();
        if (point == -1) {
            return fileName;
        } else if (point == length - 1) {
            int secondPoint = getPathLsatIndex(fileName, point - 1);
            if (secondPoint == -1) {
                if (length == 1) {
                    return fileName;
                } else {
                    return fileName.substring(0, point);
                }
            } else {
                return fileName.substring(secondPoint + 1, point);
            }
        } else {
            return fileName.substring(point + 1);
        }
    }

    /**
     * 得到文件名中的父路徑部分。
     * 對兩種路徑分隔符都有效。
     * 不存在時返回""。
     * 如果文件名是以路徑分隔符結尾的則不考慮該分隔符，例如"/path/"返回""。
     *
     * @param fileName 文件名
     * @return 父路徑，不存在或者已經是父目錄時返回""
     * @since 1.0
     */
    public static String getPathPart(String fileName) {
        int point = getPathLsatIndex(fileName);
        int length = fileName.length();
        if (point == -1) {
            return "";
        } else if (point == length - 1) {
            int secondPoint = getPathLsatIndex(fileName, point - 1);
            if (secondPoint == -1) {
                return "";
            } else {
                return fileName.substring(0, secondPoint);
            }
        } else {
            return fileName.substring(0, point);
        }
    }

    /**
     * 得到路徑分隔符在文件路徑中首次出現的位置。
     * 對於DOS或者UNIX風格的分隔符都可以。
     *
     * @param fileName 文件路徑
     * @return 路徑分隔符在路徑中首次出現的位置，沒有出現時返回-1。
     * @since 1.0
     */
    public static int getPathIndex(String fileName) {
        int point = fileName.indexOf(‘/‘);
        if (point == -1) {
            point = fileName.indexOf(‘\\‘);
        }
        return point;
    }

    /**
     * 得到路徑分隔符在文件路徑中指定位置後首次出現的位置。
     * 對於DOS或者UNIX風格的分隔符都可以。
     *
     * @param fileName  文件路徑
     * @param fromIndex 開始查找的位置
     * @return 路徑分隔符在路徑中指定位置後首次出現的位置，沒有出現時返回-1。
     * @since 1.0
     */
    public static int getPathIndex(String fileName, int fromIndex) {
        int point = fileName.indexOf(‘/‘, fromIndex);
        if (point == -1) {
            point = fileName.indexOf(‘\\‘, fromIndex);
        }
        return point;
    }

    /**
     * 得到路徑分隔符在文件路徑中最後出現的位置。
     * 對於DOS或者UNIX風格的分隔符都可以。
     *
     * @param fileName 文件路徑
     * @return 路徑分隔符在路徑中最後出現的位置，沒有出現時返回-1。
     * @since 1.0
     */
    public static int getPathLsatIndex(String fileName) {
        int point = fileName.lastIndexOf(‘/‘);
        if (point == -1) {
            point = fileName.lastIndexOf(‘\\‘);
        }
        return point;
    }

    /**
     * 得到路徑分隔符在文件路徑中指定位置前最後出現的位置。
     * 對於DOS或者UNIX風格的分隔符都可以。
     *
     * @param fileName  文件路徑
     * @param fromIndex 開始查找的位置
     * @return 路徑分隔符在路徑中指定位置前最後出現的位置，沒有出現時返回-1。
     * @since 1.0
     */
    public static int getPathLsatIndex(String fileName, int fromIndex) {
        int point = fileName.lastIndexOf(‘/‘, fromIndex);
        if (point == -1) {
            point = fileName.lastIndexOf(‘\\‘, fromIndex);
        }
        return point;
    }

    /**
     * 將文件名中的類型部分去掉。
     *
     * @param filename 文件名
     * @return 去掉類型部分的結果
     * @since 1.0
     */
    public static String trimType(String filename) {
        int index = filename.lastIndexOf(".");
        if (index != -1) {
            return filename.substring(0, index);
        } else {
            return filename;
        }
    }

    /**
     * 得到相對路徑。
     * 文件名不是目錄名的子節點時返回文件名。
     *
     * @param pathName 目錄名
     * @param fileName 文件名
     * @return 得到文件名相對於目錄名的相對路徑，目錄下不存在該文件時返回文件名
     * @since 1.0
     */
    public static String getSubpath(String pathName, String fileName) {
        int index = fileName.indexOf(pathName);
        if (index != -1) {
            return fileName.substring(index + pathName.length() + 1);
        } else {
            return fileName;
        }
    }

    /**
     * 檢查給定目錄的存在性
     * 保證指定的路徑可用，如果指定的路徑不存在，那麽建立該路徑，可以為多級路徑
     *
     * @param path
     * @return 真假值
     * @since 1.0
     */
    public static final boolean pathValidate(String path) {
        //String path="d:/web/www/sub";
        //System.out.println(path);
        //path = getUNIXfilePath(path);

        //path = ereg_replace("^\\/+", "", path);
        //path = ereg_replace("\\/+$", "", path);
        String[] arraypath = path.split("/");
        String tmppath = "";
        for (int i = 0; i < arraypath.length; i++) {
            tmppath += "/" + arraypath[i];
            File d = new File(tmppath.substring(1));
            if (!d.exists()) { //檢查Sub目錄是否存在
                System.out.println(tmppath.substring(1));
                if (!d.mkdir()) {
                    return false;
                }
            }
        }
        return true;
    }

    /**
     * 讀取文件的內容
     * 讀取指定文件的內容
     *
     * @param path 為要讀取文件的絕對路徑
     * @return 以行讀取文件後的內容。
     * @since 1.0
     */
    public static final String getFileContent(String path) throws IOException {
        String filecontent = "";
        try {
            File f = new File(path);
            if (f.exists()) {
                FileReader fr = new FileReader(path);
                BufferedReader br = new BufferedReader(fr); //建立BufferedReader對象，並實例化為br
                String line = br.readLine(); //從文件讀取一行字符串
                //判斷讀取到的字符串是否不為空
                while (line != null) {
                    filecontent += line + "\n";
                    line = br.readLine(); //從文件中繼續讀取一行數據
                }
                br.close(); //關閉BufferedReader對象
                fr.close(); //關閉文件
            }

        } catch (IOException e) {
            throw e;
        }
        return filecontent;
    }

    /**
     * 根據內容生成文件
     *
     * @param path          要生成文件的絕對路徑，
     * @param modulecontent 文件的內容。
     * @return 真假值
     * @since 1.0
     */
    public static final boolean genModuleTpl(String path, String modulecontent) throws IOException {

        path = getUNIXfilePath(path);
        String[] patharray = path.split("\\/");
        String modulepath = "";
        for (int i = 0; i < patharray.length - 1; i++) {
            modulepath += "/" + patharray[i];
        }
        File d = new File(modulepath.substring(1));
        if (!d.exists()) {
            if (!pathValidate(modulepath.substring(1))) {
                return false;
            }
        }
        try {
            FileWriter fw = new FileWriter(path); //建立FileWriter對象，並實例化fw
            //將字符串寫入文件
            fw.write(modulecontent);
            fw.close();
        } catch (IOException e) {
            throw e;
        }
        return true;
    }

    /**
     * 獲取圖片文件的擴展名（發布系統專用）
     *
     * @param pic_path 為圖片名稱加上前面的路徑不包括擴展名
     * @return 圖片的擴展名
     * @since 1.0
     */
    public static final String getPicExtendName(String pic_path) {
        pic_path = getUNIXfilePath(pic_path);
        String pic_extend = "";
        if (isFileExist(pic_path + ".gif")) {
            pic_extend = ".gif";
        }
        if (isFileExist(pic_path + ".jpeg")) {
            pic_extend = ".jpeg";
        }
        if (isFileExist(pic_path + ".jpg")) {
            pic_extend = ".jpg";
        }
        if (isFileExist(pic_path + ".png")) {
            pic_extend = ".png";
        }
        return pic_extend; //返回圖片擴展名
    }

    /**
     * 拷貝文件
     *
     * @param in  輸入文件
     * @param out 輸出文件
     * @return
     * @throws Exception
     */
    public static final boolean CopyFile(File in, File out) throws Exception {
        try {
            FileInputStream fis = new FileInputStream(in);
            FileOutputStream fos = new FileOutputStream(out);
            byte[] buf = new byte[1024];
            int i = 0;
            while ((i = fis.read(buf)) != -1) {
                fos.write(buf, 0, i);
            }
            fis.close();
            fos.close();
            return true;
        } catch (IOException ie) {
            ie.printStackTrace();
            return false;
        }
    }

    /**
     * 拷貝文件
     *
     * @param infile  輸入字符串
     * @param outfile 輸出字符串
     * @return
     * @throws Exception
     */
    public static final boolean CopyFile(String infile, String outfile) throws Exception {
        try {
            File in = new File(infile);
            File out = new File(outfile);
            return CopyFile(in, out);
        } catch (IOException ie) {
            ie.printStackTrace();
            return false;
        }

    }

    /**
     * 把內容content寫的path文件中
     *
     * @param content 輸入內容
     * @param path 文件路徑
     * @return
     */
    public static boolean SaveFileAs(String content, String path) {
        FileWriter fw = null;
        try {
            fw = new FileWriter(new File(path), false);
            if (content != null) {
                fw.write(content);
            }
        } catch (IOException e) {
            e.printStackTrace();
            return false;
        } finally {
            if (fw != null) {
                try {
                    fw.flush();
                    fw.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        return true;
    }

    /**
     * 以字節為單位讀取文件，常用於讀二進制文件，如圖片、聲音、影像等文件。
     */
    public static byte[] readFileByBytes(String fileName) throws IOException {
        FileInputStream in = new FileInputStream(fileName);
        byte[] bytes = null;
        try {

            ByteArrayOutputStream out = new ByteArrayOutputStream(1024);

            byte[] temp = new byte[1024];

            int size = 0;

            while ((size = in.read(temp)) != -1) {
                out.write(temp, 0, size);
            }

            in.close();

            bytes = out.toByteArray();

        } catch (Exception e1) {
            e1.printStackTrace();
        } finally {
            if (in != null) {
                in.close();
            }
        }
        return bytes;
    }

    /**
     * 以字符為單位讀取文件，常用於讀文本，數字等類型的文件
     */
    public static void readFileByChars(String fileName) {
        File file = new File(fileName);
        Reader reader = null;
        try {
            System.out.println("以字符為單位讀取文件內容，一次讀一個字節：");
            // 一次讀一個字符
            reader = new InputStreamReader(new FileInputStream(file));
            int tempchar;
            while ((tempchar = reader.read()) != -1) {
                // 對於windows下，\r\n這兩個字符在一起時，表示一個換行。
                // 但如果這兩個字符分開顯示時，會換兩次行。
                // 因此，屏蔽掉\r，或者屏蔽\n。否則，將會多出很多空行。
                if (((char) tempchar) != ‘\r‘) {
                    System.out.print((char) tempchar);
                }
            }
            reader.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
        try {
            System.out.println("以字符為單位讀取文件內容，一次讀多個字節：");
            // 一次讀多個字符
            char[] tempchars = new char[30];
            int charread = 0;
            reader = new InputStreamReader(new FileInputStream(fileName));
            // 讀入多個字符到字符數組中，charread為一次讀取字符數
            while ((charread = reader.read(tempchars)) != -1) {
                // 同樣屏蔽掉\r不顯示
                if ((charread == tempchars.length)
                        && (tempchars[tempchars.length - 1] != ‘\r‘)) {
                    System.out.print(tempchars);
                } else {
                    for (int i = 0; i < charread; i++) {
                        if (tempchars[i] == ‘\r‘) {
                            continue;
                        } else {
                            System.out.print(tempchars[i]);
                        }
                    }
                }
            }

        } catch (Exception e1) {
            e1.printStackTrace();
        } finally {
            if (reader != null) {
                try {
                    reader.close();
                } catch (IOException e1) {
                }
            }
        }
    }

    /**
     * 以行為單位讀取文件，常用於讀面向行的格式化文件
     */
    public static List<String> readFileByLines(String fileName) {
        List<String> returnString = new ArrayList<String>();
        File file = new File(fileName);
        BufferedReader reader = null;
        try {
            reader = new BufferedReader(new FileReader(file));
            String tempString = null;
            int line = 1;
            // 一次讀入一行，直到讀入null為文件結束
            while ((tempString = reader.readLine()) != null) {
                // 顯示行號
                returnString.add(tempString);
                line++;
            }
            reader.close();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (reader != null) {
                try {
                    reader.close();
                } catch (IOException e1) {
                }
            }
        }
        return returnString;
    }

    /**
     * 隨機讀取文件內容
     */
    public static void readFileByRandomAccess(String fileName) {
        RandomAccessFile randomFile = null;
        try {
            System.out.println("隨機讀取一段文件內容：");
            // 打開一個隨機訪問文件流，按只讀方式
            randomFile = new RandomAccessFile(fileName, "r");
            // 文件長度，字節數
            long fileLength = randomFile.length();
            // 讀文件的起始位置
            int beginIndex = (fileLength > 4) ? 4 : 0;
            // 將讀文件的開始位置移到beginIndex位置。
            randomFile.seek(beginIndex);
            byte[] bytes = new byte[10];
            int byteread = 0;
            // 一次讀10個字節，如果文件內容不足10個字節，則讀剩下的字節。
            // 將一次讀取的字節數賦給byteread
            while ((byteread = randomFile.read(bytes)) != -1) {
                System.out.write(bytes, 0, byteread);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (randomFile != null) {
                try {
                    randomFile.close();
                } catch (IOException e1) {
                }
            }
        }
    }

    /**
     * 讀取文件內容
     *
     * @param fileName
     * @return
     */
    public static String readFileAll(String fileName) {
        String encoding = "UTF-8";
        File file = new File(fileName);
        Long filelength = file.length();
        byte[] filecontent = new byte[filelength.intValue()];
        try {
            FileInputStream in = new FileInputStream(file);
            in.read(filecontent);
            in.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
        try {
            return new String(filecontent, encoding);
        } catch (UnsupportedEncodingException e) {
            System.err.println("The OS does not support " + encoding);
            e.printStackTrace();
            return "";
        }
    }

    /**
     * 顯示輸入流中還剩的字節數
     */
    private static void showAvailableBytes(InputStream in) {
        try {
            System.out.println("當前字節輸入流中的字節數為:" + in.available());
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

java FileUtil工具類