JavaSE笔记15.2-IO流-字符流

一. Writer

Writer类是所有字符输出流的父类，是一个抽象类，不能直接通过new进行实例化，可通过实例化子类创建对象。

1. Writer的常见子类

• BufferedWriter：缓冲字符输出流，为其他字符输出流提供写缓冲区
• CharArrayWriter：字符数组输出流，向内存缓冲区的字符数组写数据，缓冲区会随着数据的不断写入而自动增长
• StringWriter：字符串输出流，向内存缓冲区的字符串写数据
• PipedWriter：管道字符输出流，连接到一个 PipedReader，向与其它线程共用的管道中写入数据
• PrintWriter：字符打印流，向文本输出流打印对象的格式化表示形式
• OutputStreamWriter：转换输出流，将字节输出流转换为字符输出流，可以指定字符编码
• FileWriter：文件字符输出流，用于将字符写入到指定的打开的文件中，是OutputStreamWriter的子类

2. Writer的常用方法

//写入一个字符
void write(int c)throws IOException
//写入一个字符串
void write(String str)throws IOException
//写入一个字符串中的部分字符，off 指定字符串中的起始偏移量，len 表示字符个数
void write(String str,int off,int len)throws IOException
///写入一个字符数组
void write(char[] cbuf)throws IOException
//写入一个字符数组的若干字符，off 指定字符数组中的起始下标，len 表示元素个数
abstract void write(char[] cbuf,int off,int len)throws IOException

//为了提高效率，在写数据时，数据一般会先保存到内存缓冲区中，只有当缓冲区中的数据达到一定程度时，缓冲区中的数据才会被写入预期目的地
//使用 flush() 方法则可以强制将缓冲区中的数据写入预期目的地
abstract void flush()throws IOException
//关闭输出流，并且在关闭之前会先将缓冲区中的数据刷新到预期目的地
abstract void close()throws IOException

3. FileWriter

（1）概述

• FileWriter是文件字符输出流，用于将字符写入到指定的打开的文件中 ，FileWriter的创建不依赖于文件存在与否
• FileWriter是OutputStreamWriter的子类，其本质是通过传入的文件名、文件、或者文件描述符来创建FileOutputStream，然后使用OutputStreamWriter使用默认编码将FileOutputStream转换成FileWriter
• FileWriter内部维护了一个长度为1024的字符数组，写数据的时候会先写入到它内部维护的字符数组中，如果需要把数据真正写到硬盘上，需要调用flush或者是close方法或者是填满了内部的字符数组（flush刷新后，流还可以继续使用；close刷新后，流将被关闭，关闭一个流后，再对其进行任何操作都会产生错误）

（2）构造方法

//在指定 File 对象的情况下构造一个 FileWriter 对象，file 表示要写入数据的 File 对象
FileWriter(File file) throws IOException
//在指定 File 对象的情况下构造一个 FileWriter 对象，如果 append 的值为 true，则将字符写入文件末尾，而不是写入文件开始处
FileWriter(File file,boolean append) throws IOException
//在指定文件名的情况下构造一个 FileWriter 对象，fileName 表示要写入字符的文件名，表示的是完整路径
FileWriter(String fileName) throws IOException
//在指定文件名的情况下构造一个 FileWriter 对象，如果 append 的值为 true，则将字符写入文件末尾，而不是写入文件开始处
FileWriter(String fileName,boolean append) throws IOException

FileWriter的创建不依赖于文件存在与否：

• 如果目标文件不存在，则会自动创建目标文件
• 如果目标文件已存在，默认情况会先清空文件中的数据，然后再写入数据；如果需要在原来的基础上追加数据，需要使用构造方法FileWriter(File, boolean)并将第2个参数设为true

（3）使用FileWriter的步骤

创建输出流对象–进行写操作–将数据从内存刷新到硬盘上–关闭输出流通道

（4）使用FileWriter的例子

import java.io.*;
public class FileWriterDemo {
    public static void main(String[] args) {
        FileWriter fw=null;
        try{
            //1.创建一个FileWriter对象
            fw=new FileWriter("demo.txt",true);
            //2. 调用write方法，将字符串写入到流中
            fw.write("nihao\r\nxiexie");
            //3. 刷新流，强制将数据从缓冲中刷到硬盘上
            fw.flush();
        } catch (IOException e) {
            e.printStackTrace();
        }
        finally {
            try{
                //4. 关闭资源
                //因为关闭资源是一定要有的动作，因此把close放在finally块中
                if(fw!=null)
                    fw.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

4. BufferedWriter

（1）概述

• BufferedWriter是缓冲字符输出流，它的作用是为其他字符输出流添加缓冲功能。可以先将一批数据写入缓冲区，当缓冲区满了以后，再将缓冲区的数据一次性写到字符输出流，可提高对数据的写效率
• BufferedWriter要结合流才可以使用
• BufferedWriter还提供了一个新的方法 newLine()用于写入一个行分隔符

（2）构造方法

//创建一个BufferedWriter对象来修饰参数out指定的字符输出流，缓冲区的大小是默认的8192字符
BufferedWriter(Writer out)
//创建一个BufferedWriter对象来修饰参数out指定的字符输出流，参数sz用于指定缓冲区的大小，单位为字符
BufferedWriter(Writer out,int sz)

（3）特有方法

//写入一个行分隔符
void newLine()

（4）使用BufferedWriter的步骤

创建底层字符输出流对象–创建缓冲字符输出流对象–写数据到缓冲区中–将数据从缓冲区刷新到硬盘上–关闭资源

（5）使用BufferedWriter的例子

import java.io.*;
public class BufferedWriterDemo {
    public static void main(String[] args) {
        BufferedWriter bufw=null;
        try{
            //1. 创建一个底层的字符输出流对象
            FileWriter fw=new FileWriter("buf.txt");
            //2. 创建一个缓冲字符输出流对象，来提高fw的写入效率
            bufw=new BufferedWriter(fw);
            //3. 向缓冲区中写入数据
            for(int x=0;x<5;x++){
                bufw.write("abcd"+x);
                bufw.newLine();
                //4. 数据长度不满足缓冲区的默认大小8192字符时，使用flush可强制刷出缓冲区中的数据
                bufw.flush();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        finally {
            try{
                //5. 关闭流通道
                if(bufw!=null)
                    bufw.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

二. Reader

Reader类是所有字符输入流的父类，是一个抽象类，不能直接通过new进行实例化，可通过实例化子类创建对象。

1. Reader的常见子类

• BufferedReader：缓冲字符输入流，为其他字符输入流提供读缓冲区
• CharArrayReader：字符数组输入流，将内存缓冲区中的字符数组转换为字符输入流，从中读取字符
• StringReader：字符串输入流，将内存缓冲区中的字符串转换为字符输入流，从中读取字符
• PipedReader：管道字符输入流，连接到一个 PipedWriter，从与其它线程共用的管道中读数据
• InputStreamReader：转换输入流，将字节输入流转换为字符输入流，可以指定字符编码
• FileReader：文件字符输入流，以字符流的形式读取文件内容，是InputStreamReader的子类

2. Reader的常用方法

//从输入流中读取一个字符，并把它转换为0~65535的整数，如果返回-1则表示已经到了输入流的末尾
int read()throws IOException
//从输入流中读取若干个字符，把它们保存到参数cbuf指定的字符数组中，并返回读取的字符个数
//如果返回-1则表示已经到了输入流的末尾
int read(char[] cbuf)throws IOException
//从输入流中读取若干个字符，把它们保存到参数cbuf指定的字符数组中，off指定在字符数组中开始保存数据的起始下标，len指定读取的字符个数
//该方法返回实际读取的字符个数
//如果返回-1则表示已经到了输入流的末尾
abstract int read(char[] cbuf,int off,int len)throws IOException

//关闭该流并释放与之关联的所有资源
abstract void close()throws IOException

3. FileReader

（1）概述

• FileReader是OutputInputStreamReader的子类，以字符为单位读取文本文件
• FileReader对象关联的文件要保证存在，否则会发生FileNotFoundException异常

（2）构造方法

//在给定要读取数据的文件的情况下创建一个新的FileReader对象，file表示要从中读取数据的文件
FileReader(File file) throws FileNotFoundException
//在给定要读取数据的文件名的情况下创建一个新的FileReader对象，fileName表示要从中读取数据的文件的名称，表示的是一个文件的完整路径
FileReader(String fileName) throws FileNotFoundException

（3）使用FileReader的步骤

创建输入流对象–进行读操作–关闭输入流通道

（4）使用FileReader的例子

import java.io.*;
public class FileReaderDemo {
    public static void main(String[] args) {
        FileReader fr=null;
        try{
            //1. 创建一个文件读取流FileReader对象
            fr=new FileReader("demo.txt");
            char[] buf=new char[1024];
            int num=0;
            //2. 进行读操作，将读取到的字符存到数组中
            while ((num=fr.read(buf))!=-1){
                System.out.println(new String(buf,0,num));
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        finally {
            try{
                //3. 关闭流
                //因为关闭资源是一定要有的动作，因此把close放在finally块中
                if(fr!=null)
                    fr.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }


    }
}

4. BufferedReader

（1）概述

• BufferedReader是缓冲字符输入流，它的作用是为其他字符输入流添加缓冲功能。可以先将一批数据读到内存缓冲区，接下来的读操作就可以直接从缓冲区中获取数据，而不需要每次都从数据源读取数据并进行字符编码转换，可提高对数据的读效率
• BufferedReader要结合流才可以使用
• BufferedReader还提供了一个新的方法readLine()用于读取一行文本内容

（2）构造方法

//创建一个 BufferedReader对象来修饰参数in指定的字符输入流，缓冲区的大小是默认的8192字符
BufferedReader(Reader in)
//创建一个 BufferedReader对象来修饰参数in指定的字符输入流，参数sz则用于指定缓冲区的大小，单位为字符
BufferedReader(Reader in,int sz)

（3）特有方法

//该方法表示每次读取一行文本内容，当遇到换行(\n)、回车(\r)或回车后直接跟着换行标记符即可认为某行已终止
//该方法返回包含该行内容的字符串，但该字符串不包含任何终止符
//如果返回null则表示已经到了输入流的末尾
String readLine() throws IOException

（4）使用BufferedReader的步骤

创建底层字符输入流对象–创建缓冲字符输入流对象–读数据到缓冲区中–关闭资源

（5）使用BufferedReader的例子

import java.io.*;
public class BufferedReaderDemo {
    public static void main(String[] args) {
        BufferedReader bufr=null;
        try{
            //1. 创建一个底层的字符输入流对象，和文件相关联
            FileReader fr=new FileReader("buf.txt");
            //2. 创建一个缓冲字符输入流对象，来提高fr的读效率
            bufr=new BufferedReader(fr);
            //3. 向缓冲区中读数据
            String line=null;
            while ((line=bufr.readLine())!=null){
                System.out.println(line);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        finally {
            try{
                //4. 关闭流通道
                if(bufr!=null)
                    bufr.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}