Java学习与复习笔记--字符输出流

字符输出流_Writer类&FileWriter类&基本使用：

/*
* java.io.Writer：字符输出流，是所有字符输出流的最顶层的父类，是一个抽象类
* 共性的成员方法：
* void write(int c) 写一个字符
* void write(char[] cbuf) 写入一个字符数组。
* void write(char[] cbuf, int off, int len) 写入字符数组的一部分。
* void write(String str) 写一个字符串
* void write(String str, int off, int len) 写一个字符串的一部分。
* void flush() 刷新流
* void close() 关闭流，先刷新。
* java.io.FileWriter extends OutputStreamWriter extends Writer
* FileWriter：文件字符输出流
* 作用：把内存中的字符数据写入到文件中
* 构造方法：FileWriter(File file) 给一个File对象构造一个FileWriter对象
* FileWriter(String fileName) 构造一个给定文件名的FileWriter对象。
* 参数：写入数据的目的地
* String fileName：文件的路径
* File file：文件
* 构造方法的作用：
* 1.创建一个FileWriter对象
* 2.根据构造方法中传递的文件/文件的路径，创建文件
* 3.会把FileWriter对象指向创建好的文件
* 字符输出流的使用步骤（重点）：
* 1.创建FileWriter对象，构造方法中绑定要写入数据的目的地
* 2.使用FileWriter中的方法write，把数据写入到内存缓冲区中（字符转换为字节的过程）
* 3.使用FileWriter中的方法flush，把内存缓冲区中的数据，刷新到文件中
* 4.释放资源（会先把内存缓冲区中的数据刷新到文件中）
* */
public class Demo01Writer {
    public static void main(String[] args) throws IOException {
        FileWriter fw=new FileWriter("FileAndIO\\d.txt");
        fw.write(97);
        //fw.flush();
        fw.close();
    }
}

flush方法和close方法的区别：

/*
* flush方法和close方法的区别：
* flush方法：刷新缓冲区，流对象可以继续使用
* close方法：先刷新缓冲区，然后通知系统释放资源。流对象不可以再被使用了。
* */
public class Demo02FlushAndClose {
    public static void main(String[] args) throws IOException {
        FileWriter fw=new FileWriter("FileAndIO\\d.txt");
        fw.write(97);
        fw.flush();
        fw.write(98);//刷新之后，流可以继续使用
        fw.close();
        //close方法之后流已经关闭了，已经从内存中消失了，流就不能再使用了
        fw.write(99);//IOException:Stream closed
    }
}

字符输出流写数据的其他方法：

/*
* 字符输出流写数据的其他方法：
* void write(char[] cbuf) 写入一个字符数组。
* void write(char[] cbuf, int off, int len) 写入字符数组的一部分。
* void write(String str) 写一个字符串
* void write(String str, int off, int len) 写一个字符串的一部分。
* */
public class Demo03Writer {
    public static void main(String[] args) throws IOException {
        FileWriter fw=new FileWriter("FileAndIO\\f.txt");
        char[] cs={'a','b','c','d'};
        fw.write(cs);//abcd
        //void write(char[] cbuf, int off, int len) 写入字符数组的一部分。
        fw.write(cs,1,3);
        //void write(String str) 写一个字符串
        fw.write("我是好人");
        //void write(String str, int off, int len) 写一个字符串的一部分。
        fw.write("今天天气不错",2,4);//天气不错
        fw.close();
    }
}

字符输出流的续写和换行：

/*
* 续写和换行：
* 续写,追加写：使用两个参数的构造方法
* FileWriter(String fileName, boolean append)
* FileWriter(File file, boolean append)
* 参数：String fileName，File file写入数据的目的地
*      boolean append：续写开关 true：不会创建新的文件覆盖原文件，可以续写；false：创建新的文件覆盖原文件
 *  换行：换行符号
 *  windows:\r\n
 *  Linux:/n
 *  mac:r
 *  */
public class Demo04Writer {
    public static void main(String[] args) throws IOException {
        FileWriter fw=new FileWriter("FileAndIO\\g.txt",true);
        for (int i = 0; i < 10; i++) {
            fw.write("helloworld"+i+"\r\n");
        }
       fw.close();
    }
}

使用try_catch_finally处理流中的异常：

/*
* 在JDK1.7之前，我们可以使用try catch finally处理流中的异常
* 格式：
*   try{
*       可能会出现异常的代码
*   }catch(异常类的变量 变量名){
*       异常的处理逻辑
*   }finally{
*       一定会执行的代码
*       资源释放
*   }*/
public class Demo05TryCatch {
    public static void main(String[] args) {
        //变量在定义的时候可以没有值，但是使用的时候必须有值
        //fw=new FileWriter("FileAndIO\\g.txt",true);执行失败，fw没有值，fw.close会报错
        FileWriter fw=null;//提高变量fw的作用域，让finally可以使用
        try{
            //可能会出现异常的代码
            fw=new FileWriter("w:\\FileAndIO\\g.txt",true);
            for (int i = 0; i < 10; i++) {
                fw.write("helloworld"+i+"\r\n");
            }
        }catch (IOException e){
            System.out.println(e);
        }finally {
            //创建对象失败了，fw的默认值是null，null是不能调用方法的，会抛出NullPointerException，需要增加一个判断，不是null再把资源释放
            if(fw!=null){
                try {
                    //fw.close方法声明抛出了IOException异常对象，所以我们就得处理这个异常对象，要么throws,要么try catch
                    fw.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

JDK7流中异常的处理：

/*
* JDK7的新特性：
* 在try的后面可以增加一个(),在括号中可以定义流对象
* 那么这个流对象的作用域就再try中有效
* try中的代码执行完毕，会自动把流释放，不用写finally
* 格式：
* try(定义流对象;定义流对象...){
*       可能会出现异常的代码
 *   }catch(异常类的变量 变量名){
 *       异常的处理逻辑
 *   }
* */
public class Demo06JDK7 {
    public static void main(String[] args) {
        try(FileInputStream fis=new FileInputStream("FileAndIO\\b.txt");
            FileOutputStream fos=new FileOutputStream("d:\\c.txt");){
            //可能会出现异常的代码
            int len=0;
            while((len=fis.read())!=-1){
                fos.write(len);
            }
        }catch(IOException e){
                System.out.println(e);
            }
        }
    }

JDK9流中异常的处理：

/*
* JDK9新特性：
* 在try的前边可以定义流对象
* 在try的后边的（）中可以直接引入流对象的名称（变量名）
* 在try代码执行完毕后，流对象也可以释放掉，不用写finally
* 格式：
*   A a=new A();
*   B b=new B();
*   try(a,b){
 *       可能会出现异常的代码
 *   }catch(异常类的变量 变量名){
 *       异常的处理逻辑
 *   }
* */
public class Demo07JDK9 {
    public static void main(String[] args) throws IOException {
        FileInputStream fis=new FileInputStream("FileAndIO\\b.txt");
        FileOutputStream fos=new FileOutputStream("d:\\c.txt");
        try(fis;fos){
            int len=0;
            while((len=fis.read())!=-1){
                fos.write(len);
            }
        }catch(IOException e){
                System.out.println(e);
            }
        fos.write(1);//IOException: Stream Closed
    }
}