IO流 -字符输入输出流，以及异常处理方法

字符输入流

---

• java.io.Reader: 字符输入流的顶层抽象父类

• 共性的成员方法：

  1. int read()
     读取单个字符，并返回。
  2. int read(char[] cbuf)
     将字符读入数组。
  3. abstract int read(char[] cbuf, int off, int len)
     将字符读入数组的某一部分。
  4. abstract void close()
     关闭该流并释放与之关联的所有资源。

FileReader:字符文件输入流

---

• java.lang.Object
  继承者 java.io.Reader
  继承者 java.io.InputStreamReader
  继承者 java.io.FileReader

• 作用：把文件以字符的方式读取到内存中

• 构造方法：

  1. FileReader(String fileName)
     在给定从中读取数据的文件名的情况下创建一个新 FileReader。
  2. FileReader(File file)
     在给定从中读取数据的 File 的情况下创建一个新 FileReader。
  3. 构造方法作用：创建一个FileReader对象，根据构造方法中传递的文件/文件路径，创建文件，会把FileReader对象指向读取的文件

import java.io.FileReader;
import java.io.IOException;
import java.util.Arrays;

public class IOApi {
    public static void main(String[] args) throws IOException {

        //1.创建FileReader对象，构造方法中绑定要读取的数据源
        FileReader reader= new FileReader("b.txt");
/*        //2.使用FileReader对象中的方法read读取文件
        //int len 接受返回的字符整型值
        int len = 0;
        while ((len=reader.read()) != -1)
            System.out.print((char) len);*/

        //优化，数组读取多个字符，len1表示读取的有效字符个数
        char[] chars= new char[2];
        int len1 = 0;
        //reader.read(chars)会把读取的两个字符放入chars中，并返回读取的有效位数
        while((len1 = reader.read(chars)) != -1)
            //再优化，读取有效位，防止多读
            System.out.print(new String(chars,0,len1));

        //3.释放资源
        reader.close();
    }
}

字符输出流

---

• java.io.Writer: 字符输出流，是所有字符输出的顶层抽象父类

• 共性的方法：

  1. Writer append(char c)
     将指定字符添加到此 writer。
  2. Writer append(CharSequence csq)
     将指定字符序列添加到此 writer。
  3. Writer append(CharSequence csq, int start, int end)
     将指定字符序列的子序列添加到此 writer.Appendable。
  4. bstract void close()
     关闭此流，但要先刷新它。
  5. bstract void flush()
     刷新该流的缓冲。
  6. void write(char[] cbuf)
     写入字符数组。
  7. abstract void write(char[] cbuf, int off, int len)
     写入字符数组的某一部分。
  8. void write(int c)
     写入单个字符。
  9. void write(String str)
     写入字符串。
  10. void write(String str, int off, int len)
      写入字符串的某一部分。

FileWriter -字符文件输出流

---

• java.lang.Object
  继承者 java.io.Writer
  继承者 java.io.OutputStreamWriter
  继承者 java.io.FileWriter

• 作用：把内存的字符写入文件中

• 构造方法：

  1. FileWriter(String fileName)
     根据给定的文件名构造一个 FileWriter 对象。

  2. FileWriter(File file)
     根据给定的文件对象构造一个 FileWriter 对象。

     String fileName:文件路径 File file:一个文件

  3. 构造方法作用：创建一个FileWriter对象，根据构造方法中传递的文件/文件路径，创建文件，并将FileWriter对象指向该文件

• 字符输出流使用步骤

  1. 创建FileWriter对象，构造方法中绑定要写入数据的目的地
  2. 使用FileWriter中的write方法，把数据写入内存缓冲区中(字符转换为字节的过程)
  3. 使用FileWriter中的flush方法，将内存缓存区的数据刷新到文件中
  4. 释放资源（会做第三步的行为，第三步可以省略）

import java.io.FileWriter;
import java.io.IOException;

public class IOApi {
    public static void main(String[] args) throws IOException {

        FileWriter writer = new FileWriter("d.txt");
        //void write(int c) 写单个字符
        //与写入字节流相比，自动创建了文件并写入了内存缓冲区，但并未写入文件
        writer.write(97);

        //刷新至文件，写入文件
        writer.flush();  //a
        
        //释放资源,可以省略刷新步骤
        writer.close();

    }
}

• 字符输出类的关闭与刷新的区别

  1. flush: 刷新缓冲区，流可以继续使用
  2. close: 先刷新到缓冲区，再关闭流，流不能继续使用

• FileWriter字符输出流的其他方法：

import java.io.FileWriter;
import java.io.IOException;

public class IOApi {
    public static void main(String[] args) throws IOException {

        FileWriter writer = new FileWriter("f.txt");

        //void write(char[] cbuf)写入字符数组
        char[] chars=new char[]{'a','b','c'};

        writer.write(chars);
        writer.flush();

        //void write(char[] cbuf,int off,int len)写字符数组的一部分
        writer.write(chars,1,2);
        writer.flush();

        //void write(String str)//直接写入字符串
        writer.write("李大爷");

        writer.close();

    }
}

• 如续写，FileWriter writer = new FileWriter("f.txt",true);

处理流的异常

---

• 使用try catch

  1. 格式：
     try{
     可能出现异常的代码
     }catch(异常变量 异常变量名){
     异常处理逻辑
     }finally{
     一定会指定的代码
     资源释放
     }

• JDK1.7之前特别麻烦，代码如下

import java.io.FileWriter;
import java.io.IOException;

public class IOApi {
    public static void main(String[] args) {

        //因为使用try catch，finally的变量，用不了，拿到碗面
        FileWriter writer = null;

        //void write(char[] cbuf)写入字符数组
        char[] chars = new char[]{'a', 'b', 'c'};

        try {
            writer = new FileWriter("f.txt");
            writer.write(chars);
            writer.flush();
        } catch (IOException e) {

            System.out.println("没有该文件，我自动生成");
        } finally {
            //一定要执行的代码
            /*
            如果writer对象创建文件失败，writer.close();抛出异常
            因为失败的话，null是不能调用close的，所以可以进行if判断
             */

            //close方法声明抛出了异常，处理它
            if (writer != null) {
                try {
                    writer.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }


    }
}

• JDK9新特性 - 还是需要throws

  1. try前边可以定义 流对象
  2. try后边的（）可以直接引入流对象的名称（变量名）
  3. try代码执行完毕之后，流对象也可以释放掉，不用写finally

import java.io.FileWriter;
import java.io.IOException;

public class IOApi {
    public static void main(String[] args) throws IOException {

        //void write(char[] cbuf)写入字符数组
        char[] chars=new char[]{'a','b','c'};

        FileWriter writer = new FileWriter("f.txt");
        FileWriter writer01 = new FileWriter("b.txt");
        
        //自动关闭流
        try(writer01;writer) {
            writer.write("李大爷");
            writer.write(chars);
            writer.flush();
        } catch (IOException e) {

            System.out.println("没有该文件，我自动生成");
        }
    }
}