Java基础：字符输入流Reader与字符输出流Writer，续写换行，jdk7、9的新特性

字符输入流Reader

java.io.Reader 字符输入流：是字符输入流的最顶层的父类，定义了一些共性的成员方法，是一个抽象类
共性的成员方法：

• int read()读取单个字符并返回
• int read(char[] chars)一次读取多个字符，将字符读入数组
• void close()关闭该流并释放与之关联的所有资源

java.io.FileReader extends InputStreamReader extends Reader
FileReader:文件字符输入流
作用：把硬盘文件中的数据以字符的方式读取到内存中
构造方法：
FileReader(String fileName)
FileReader(File file)
参数：读取文件的数据源

• String fileName：文件的路径
• File file：一个文件

FileReader的作用：
1.创建一个FileReader对象
2.会把FileReader对象指向要读取的文件

字符输入流的使用步骤(重点)：
1.创建FileReader对象，构造方法中绑定要读取的数据源
2.使用FileReader对象的read方法读取文件
3.释放资源

public class Demo01Reader {
    public static void main(String[] args) throws IOException {
        //1.创建FileReader对象，构造方法中绑定要读取的数据源
        FileReader fr = new FileReader("src\\c.txt");
        //    int read()读取单个字符并返回
//        int len = 0;
//        while ((len = fr.read())!= -1){
//            System.out.print((char) len);
//        }
        //    int read(char[] chars)一次读取多个字符，将字符读入数组
        char[] cs = new char[1024];
        int len = 0;//记录的是每次读取的有效字符个数
        while ((len = fr.read(cs))!= -1){
            /*
            String类的构造方法：
                String(char[] value):把字符数组转化为字符串
                String(char[] value,int offset,int count)把字符数组的一部分转化为字符串，offset为数组开始的索引，count为转化的个数
            * */
            System.out.println(new String(cs,0,len));
        }
       fr.close();
    }
}

字符输出流Writer

java.io.Writer：字符输出流，是所有字符输出流的最顶层的父类，是一个抽象类

• void close() 关闭此流，但要先刷新它。
• void flush() 刷新此流。
• void write(char[] cbuf) 写入字符数组。
• void write(char[] cbuf, int off, int len) 写入字符数组的某一部分。
• void write(int c) 写入单个字符。
• void write(String str) 写入字符串。
• void write(String str, int off, int len) 写入字符串的某一部分。

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中的方法writer，把数据写入到内存缓冲区中(字符转化为字节的过程)、
    3.使用FileWriter中的方法flush，把内存缓冲区中的数据，刷新到文件中
    4.释放资源(会把内存缓冲区中的数据刷新到文件中)

public class Demo01Writer {
    public static void main(String[] args) throws IOException {
        //        1.创建FileWriter对象，构造方法中绑定要写入数据的目的地
        FileWriter fwo = new FileWriter("src\\d.txt");
        //        2.使用FileWriter中的方法writer，把数据写入到内存缓冲区中(字符转化为字节的过程)
        fwo.write(97);
        //        3.使用FileWriter中的方法flush，把内存缓冲区中的数据，刷新到文件中
        fwo.flush();//刷新后可以继续写入
        fwo.write(66);
        //        4.释放资源(会把内存缓冲区中的数据刷新到文件中)
        fwo.close();
    }
}

字符输出流写数据的其他方法
void write(char[] cbuf) 写入字符数组。
void write(char[] cbuf, int off, int len) 写入字符数组的某一部分。
void write(int c) 写入单个字符。
void write(String str) 写入字符串。
void write(String str, int off, int len) 写入字符串的某一部分。

public class Demo02Writer {
    public static void main(String[] args) throws IOException {
        FileWriter fw = new FileWriter("src\\e.txt");
        char[] chars = {'h','l','l','e','o'};
        //void write(String str) 写入字符串。
        fw.write("哈哈哈后哦吼吼");
        //void write(String str, int off, int len) 写入字符串的某一部分。
        fw.write("哈佛氨挥发发哦我会发哦",2,5);
        //void write(char[] cbuf) 写入字符数组。
        fw.write(chars);
        //void write(char[] cbuf, int off, int len) 写入字符数组的某一部分。
        fw.write(chars,0,2);
        //3.使用FileWriter中的方法flush，把内存缓冲区中的数据，刷新到文件中
        fw.flush();
        //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("src\\f.txt",true);
        for (int i = 0; i < 10; i++) {
            fw.write("hello"+i+"\r\n");
        }
        fw.close();
    }
}

运行结果(开始没换行)

TryCatch处理流中的异常

在jdk1.7之前使用try catch finally 处理流中的异常
格式：
try{
可能产生异常的代码
}catch(异常类变量 变量名){
异常的处理逻辑
}finally{
一定会执行的代码
资源释放
}

public class Demo03TryCatch {
    public static void main(String[] args)  {
        //提高变量fw的作用域，让finally可以使用
        //变量在定义的时候，可以没有值，但是使用的时候必须有值
        FileWriter fw = null;
        try{
            //可能会产生异常的代码
             fw = new FileWriter("src\\f.txt",true);
            for (int i = 0; i < 10; i++) {
                fw.write("hello"+i+"\r\n");
            }
        }catch (IOException e){
            //异常处理逻辑
            System.out.println(e);
        }finally {//一定会执行的代码
            try {
                //fw.close方法声明抛出了IOException异常对象，所以我们就得处理这个异常对象
                fw.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

jdk7、9的新特性

JDK7新特性
在try的后边可以增加一个（），在括号中可以定义流对象
那么这个流对象的作用域就在try中有效
try中的代码执行完毕，会自动把流对象释放，不用写finally
格式：
try(定义流的新建对象){
可能会产生异常的代码
}catch(异常类变量 变量名){
异常的处理逻辑
}
JDK9新特性
try的前边可以定义流对象
try的后边()中可以直接引入流对象的名称(变量名)
在try代码执行完毕后，流对象也可以释放掉，不用写finally
格式：
A a = new A();
B b = new B();
try(a,b){
可能会产生异常的代码
}catch(异常类变量 变量名){
异常的处理逻辑
}

public class JDK7JDK9 {
    public static void main(String[] args) {
        try (FileInputStream fis = new FileInputStream("D:\\aa.txt");
             FileOutputStream fos = new FileOutputStream("F:\\aa.txt");){

              int len = 0;
              while ((len = fis.read())!= -1){
                //    4.使用字节输出流对象中的方法write，把读取到的字节写入到目的地的文件中
                fos.write(len);
              }
        }catch (IOException e){
            System.out.println(e);
        }finally {

        }


    }
}