0511-FileWrite字符输出流和JDK7中try..finally新的特性

package A10_IOStream;

import java.io.*;

/*
java.io.Writer:字符输出流，是所有字符数出流的最顶层抽象父类
共性方法
    void write(int c)
    void write(char[] cbuf)
    abstract void write(char[] cbuf,int off,int len)
    void write(String str)
    void flush()刷新该流的缓冲
    void close()关闭流，但是要先刷新它
java.io.FileWriter文件字符输出流，继承自OutputStreamWriter继承自Writer
作用：把内存中字符数据写入到文件中
构造方法：
    FileWriter(File file)根据给定的 File 对象构造一个 FileWriter 对象。
    FileWriter(File file, boolean append)根据给定的 File 对象构造一个 FileWriter 对象。
    FileWriter(FileDescriptor fd)构造与某个文件描述符相关联的 FileWriter 对象。
    FileWriter(String fileName)根据给定的文件名构造一个 FileWriter 对象。
    FileWriter(String fileName, boolean append)根据给定的文件名以及指示是否附加写入数据的 boolean 值来构造 FileWriter 对象。
字符输出流的使用步骤(重点)：
    1.创建FileWrite对象，构造方法中绑定要写入数据的目的地
    2.使用FileWrite中的write方法，把数据写入到内存缓冲区中(字符转换为字节的过程)
    3.使用FileWrite中的flush方法，把内存缓冲区中的数据，刷新到文件中
    4.调用close方法释放资源（会先把缓冲区中的数据写入到文件当中）
*/
public class D05_FileWriter {
    //  定义一个常量方便全部函数使用
    private static final String FILENAME = "Upload\\test.txt";

    public static void main(String[] args) throws IOException {
        File file = new File(FILENAME);
        String fullPath = file.getAbsolutePath();  //文件绝对路径返回 D:\JAVA学习\demo\Upload\test.txt
        String path = new File(fullPath).getParent();  //父路径返回 D:\JAVA学习\demo\Upload
        File dir = new File(path);
        if (!dir.exists() && !dir.isDirectory()) {
            dir.mkdirs();
        }
//      创建 写入内存 通过flush写出到内存 关闭资源
        FileWriter fw = new FileWriter(file);
        fw.write(97);  //写单个字符
        fw.write("我爱北京天安门！");  //写字符串
        fw.flush();
        fw.close();
//      续写与换行
        FileWriter fwa = new FileWriter(FILENAME, true);
        for (int i = 1; i < 6; i++) {
            fwa.write("\r\n" + "HelloWorld" + i);
        }
        fwa.close();
        exceptionMethod(FILENAME);
        myCopy_jkd7(FILENAME, FILENAME + "7");
        myCopy_jkd9(FILENAME, FILENAME + "9");
    }

    //  使用try catch finally处理流中的异常
    public static void exceptionMethod(String fileName) {
        FileWriter fw = null; //先初始化变量
        try {
            //可能会触发异常的语句
            fw = new FileWriter(fileName, true);
            fw.write("这是处理异常的函数写入的信息");
        } catch (IOException e) {
            System.out.println(e);
        } finally {
            //如果资源不为空则释放资源
            if (fw != null) {
                try {
                    fw.close();
                } catch (IOException e) {
                    System.out.println(e);
                }
            }
        }
    }

    /*
          使用JDK7中try的新语法实现复制文件
          在try后面增加一个括弧，括弧中定义流对象，多个对象用分号隔开
          流对象的作用域是try语句块
          try中的语句执行完毕，会自动释放流对象，不用写finally处理
          格式：
            try(定义流对象;定义流对象...){
              可能产生异常的语句
            } catch(异常类名 变量名){
              异常的处理逻辑
            }
    */
    public static void myCopy_jkd7(String sou, String tar) {
        //创建一个输入流、一个输出流
        try (FileInputStream fis = new FileInputStream(sou);
             FileOutputStream fos = new FileOutputStream(tar);) {
            byte[] buff = new byte[1024 * 1024]; //读写缓冲区1024kb
            int len;
            //分别使用输入流的read方法，输出流的write方法读写文件
            while ((len = fis.read(buff)) != -1) {
                fos.write(buff, 0, len);
            }
        } catch (IOException e) {
            System.out.println(e);
        }
    }

    /*
          使用JDK9中try的新语法实现复制文件
          在try前定义流对象
          在try后面增加一个括弧，引入需要自动释放的对象，多个对象用分号隔开
          流对象的作用域是try..catch整个语句块，执行完毕自动释放对象，不用写finally处理
          格式：
            FileInputStream fis=new FileInputStream(str);
            FileOutputStream fos=new FileOutputStream(str);
            try(fis,fos){
              可能产生异常的语句
            } catch(ExceptClass e){
              异常的处理逻辑
            }
     */
    public static void myCopy_jkd9(String sou, String tar) throws IOException {
        //创建文件输入流、输出流
        FileInputStream fis = new FileInputStream(sou);
        FileOutputStream fos = new FileOutputStream(tar);
        try (fis; fos) {
            byte[] buff = new byte[1024 * 1024]; //读写缓冲区1024kb
            int len;
            //分别使用输入流的read方法，输出流的write方法读写文件
            while ((len = fis.read(buff)) != -1) {
                fos.write(buff, 0, len);
            }
        } catch (IOException e) {
            System.out.println(e);
        }
    }

}