Java文件相关操作的封装

package com.lpr.fileutils;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.util.Scanner;

/**
 * 文件操作相关的封装方法
 * 
 * @author ToDream
 * @Date 2017-3-7 11:51:39
 */

public class FileUtils {

    /**
     * 显示文件或目录的详细信息
     * 
     * @param file
     */
    public static void showDescription(File file) {
        // 判断 文件是否存在
        if (file.exists()) {

            System.out.print("文件名为：");
            System.out.println(file.getName());

            System.out.print("绝对路径为：");
            System.out.println(file.getAbsolutePath());

            System.out.print("相对路径为：");
            System.out.println(file.getPath());

            System.out.print("是否是文件");
            System.out.println(file.isFile());

            System.out.print("是否是目录");
            System.out.println(file.isDirectory());

            System.out.print("是否是隐藏文件：");
            System.out.println(file.isHidden());

            System.out.print("文件大小：");
            long len = file.length();
            if (len < 1024) {
                System.out.println(file.length() + "b");
            } else {
                System.out.println(file.length() / 1024 + "kb");
            }

        } else {
            System.out.println("文件不存在...");
        }
    }

    /**
     * 显示目录中的文件信息
     */
    public static void showDir(File file) {
        if (file.isDirectory()) {
            File[] files = file.listFiles();
            for (File strFile : files) {
                System.out.println(strFile.getName()
                        + ((strFile.isDirectory()) ? "*" : ""));
            }
        } else {
            System.out.println("当前File对象，不是目录，不可操作...");
        }
    }

    /**
     * 重命名文件
     */
    public static void reName(File file) {
        if (file.exists()) {
            Scanner scanner = new Scanner(System.in);
            System.out.print("请输入新文件名：");
            String newFileName = scanner.next();
            // 实际上相当于保存路径
            String dirName = file.getPath().substring(0,
                    file.getPath().lastIndexOf(File.separator));
            File destFile = new File(dirName + File.separator + newFileName);
            boolean result = file.renameTo(destFile);
            if (result) {
                System.out.println("重命名成功...");
            } else {
                System.out.println("重命名失败...");
            }
        } else {
            System.out.println("请检查文件是否存在...");
        }
    }

    /**
     * 按字节方式读取文件
     * 
     * @param file
     * @throws IOException
     */
    public static void readByte(File file) throws IOException {
        FileInputStream inputStream = new FileInputStream(file);
        // 读取一字节的数据，如果到末尾，返回-1
        int data = inputStream.read();
        while (data != -1) {
            System.out.print((char) data);
            data = inputStream.read();
        }
        // 关闭流
        inputStream.close();
    }

    /**
     * 按字节方式读取文本文件，兼容中文（字符流）
     * 
     * @param file
     * @param isLatin
     * @throws IOException
     */
    public static void readByte(File file, boolean isLatin, String codeingRule)
            throws IOException {
        // 如果是英文，则调用本类的按字节方式读取文件的方法
        if (isLatin) {
            readByte(file);
            return;
        } else {
            FileInputStream inputStream = new FileInputStream(file);
            // 指定以字符集编码方式，来读取文件
            InputStreamReader inputStreamReader = new InputStreamReader(
                    inputStream, codeingRule);

            // 读取一字节的数据，如果到末尾，返回-1
            int data = inputStreamReader.read();
            while (data != -1) {
                System.out.println((char) data);
                data = inputStreamReader.read();
            }
            // 关闭流
            inputStreamReader.close();
            inputStream.close();
        }
    }

    /**
     * 批量读取文件
     * 
     * @throws IOException
     */
    public static void readBatch(File file, String codeingRule)
            throws IOException {
        // 以缓冲区方式，读取文本文件
        FileInputStream inputStream = new FileInputStream(file);
        // 指定以字符集编码方式，来读取文件
        InputStreamReader inputStreamReader = new InputStreamReader(
                inputStream, codeingRule);
        // 读取数组长度的数据到数组中，如果到末尾，返回-1
        char[] buffer = new char[1024];
        int isEOF = inputStreamReader.read(buffer);
        while (isEOF != -1) {
            for (char c : buffer) {
                if (c != '\0') {
                    System.out.print(c);
                }
            }
            isEOF = inputStreamReader.read(buffer);
        }
        // 关闭流
        inputStreamReader.close();
        inputStream.close();
    }

    /**
     * 写文件方式一，以字节流方式输出
     * 
     * @param content
     *            写入文件中的内容
     * @throws IOException
     */
    public static void writeByte(File file, String content) throws IOException {
        // 声明输出流
        FileOutputStream outputStream = new FileOutputStream(file);
        char[] chars = content.toCharArray();
        for (char c : chars) {
            // 写出一个字节
            outputStream.write(c);
        }
        // 关闭流
        outputStream.close();
    }

    /**
     * 写文件方式二，以字符流方式输出
     * 
     * @param content
     *            写入文件的内容
     * @param codingRule
     *            编码规则
     * @throws IOException
     */
    public static void writeByte(File file, String content, String codingRule)
            throws IOException {
        FileOutputStream outputStream = new FileOutputStream(file);
        OutputStreamWriter outputStreamWriter = new OutputStreamWriter(
                outputStream, codingRule);
        char[] chars = content.toCharArray();
        for (char c : chars) {
            // 写出一个字节
            outputStreamWriter.write(c);
        }
        // 关闭流
        outputStreamWriter.close();
        outputStream.close();
    }

    /**
     * 写文件方式三，批量输出
     * 
     * @param content
     *            写入文件的内容
     * @param codingRule
     *            编码规则
     * @throws IOException
     */
    public static void writeBatch(File file, String content, String codingRule)
            throws IOException {
        FileOutputStream outputStream = new FileOutputStream(file);
        OutputStreamWriter outputStreamWriter = new OutputStreamWriter(
                outputStream, codingRule);
        char[] chars = content.toCharArray();
        outputStreamWriter.write(chars);
        // 关闭流
        outputStreamWriter.close();
        outputStream.close();
    }

    /**
     * 复制文件
     * 
     * @param srcfile
     *            原文件路径
     * @param destfile
     *            复制后文件路径
     * @throws IOException
     */
    public static void copyFile(File srcfile, File destfile) throws IOException {
        // 读取文件内容
        if (srcfile.exists()) {
            byte[] buffer = new byte[1024];
            // 输入流
            FileInputStream inputStream = new FileInputStream(srcfile);
            // 输出流
            FileOutputStream outputStream = new FileOutputStream(destfile);

            // 第一次读取内容
            int isEOF = inputStream.read(buffer);
            while (isEOF != -1) {
                // 写出内容
                outputStream.write(buffer);
                // 读取内容
                isEOF = inputStream.read(buffer);
            }
            inputStream.close();
            outputStream.close();
        } else {
            System.out.println("文件不存在，不能复制...");
        }
    }

    /**
     * 修改文件编码方式
     * @param srcfile
     *            原文件路径
     * @param destfile
     *            复制后文件路径
     * @param srcCodingRule
     *            原文件的编码格式
     * @param destCodingRule
     *            修改编码后文件的编码格式
     * @throws IOException
     */
    public static void changCodingRule(File srcfile, File destfile,
            String srcCodingRule, String destCodingRule) throws IOException {

        // 输入流
        FileInputStream inputStream = new FileInputStream(srcfile);
        // 指定以字符集编码方式，来读取文件
        InputStreamReader inputStreamReader = new InputStreamReader(
                inputStream, srcCodingRule);

        // 输出流
        FileOutputStream outputStream = new FileOutputStream(destfile);
        OutputStreamWriter outputStreamWriter = new OutputStreamWriter(
                outputStream, destCodingRule);

        // 读取数组长度的数据到数组中，如果到末尾，返回-1
        char[] buffer = new char[1024];
        int isEOF = inputStreamReader.read(buffer);
        while (isEOF != -1) {
            // 将读取到的内容写入另一个文件
            outputStreamWriter.write(buffer);
            isEOF = inputStreamReader.read(buffer);
        }
        // 关闭流
        inputStreamReader.close();
        inputStream.close();
        outputStreamWriter.close();
        outputStream.close();
    }
}