Java IO----字符流

类图

Reader常用的类&方法

常用类	含义
Reader	是字符输入流的所有类的超类，它以字符为单位从数据源中读取数据
BufferedReader	带有缓冲区的字符输入流
InputStreamReader	从数据源读取字节并将其解码为使用指定的字符集的字符
FileReader	用于读取字符类文件，如文本文件
StringReader	字符串输入流
PipedReader	管道输入流
FilterReader	抽象类，它的子类可以修饰其它Reader，添加功能
PushbackReader	可以把读取进来的某些数据重新回退到输入流的缓冲区之中

常用方法	含义
public int read(int b) throws IOExecption	该方法用于读取单个字符，返回作为整数读取的字符，如果已经到达流的末尾，返回-1
public int read(char[] cbuf) throws IOExecption	该方法用于将字符读入到cbuf，返回读取的字符数
public abstract int read(char[] cbuf,int off,int len) throws IOExecption	该方法用于读取len个字符的数据，并从数组cbuf的off位置读入到这个数组中
public abstract void close() throws IOExecption	关闭此输入流，并释放与此输出流相关联的所有系统资源

InputStreamReader简介

InputStreamReader类是从字节流到字符流的桥接器：它使用指定的字符集读取字节并将它们解码为字符。 它使用的字符集可以通过名称指定，也可以明确指定，或者可以接受平台的默认字符集。每次调用一个InputStreamReader的read（）方法都可能导致从底层字节输入流中读取一个或多个字节

FileReader简介

FileReader是InputStreamReader的子类，FileReader类仅仅是InputStreamReader的简单衍生并未扩展任何功能。它的使用方法与FileInputStream很相似

public class FileReaderTest {

    public static void main(String[] args) throws Exception{
        //1.创建准备读取的文件
        File file = new File("E:\\ExampleTest\\TestText.txt");
        //2.创建输入流，读取数据
        Reader reader = new FileReader(file);
        char[] chars = new char[100];
        int length = 0;
        while ((length = reader.read(chars)) != -1) {
            System.out.println(new String(chars,0,length));
        }
        reader.close();
    }
}

BufferedReader简介

BufferedReader是带有缓冲区的输入流，可以修饰其它Reader类，提高读取性能

public class BufferedReaderTest {

    public static void main(String[] args) throws Exception {
        //1.创建准备读取的文件
        File file = new File("E:\\ExampleTest\\TestText.txt");
        //2.创建输入流，读取数据
        BufferedReader bufferedReader = new BufferedReader(new FileReader(file));
        char[] chars = new char[100];
        int length = 0;
        while ((length = bufferedReader.read(chars)) != -1) {
            System.out.println(new String(chars, 0, length));
        }
        bufferedReader.close();
    }
}

StringReader简介

StringReader是以String以数据源，从中读取数据

public class StringReaderTest {

    public static void main(String[] args) throws Exception{
        StringReader stringReader = new StringReader("我爱java");
        int length = 0;
        char[] chars = new char[50];
        while ((length = stringReader.read(chars)) != -1) {
            System.out.println(new String(chars, 0, length));
        }
    }
}

PipedReader&PipedWriter简介

PipedReader是字符管道输入流，PipedWriter是字符管道输出流，PipedWriter和PipedReader的作用是可以通过管道进行线程间的通讯。在使用管道通信时，必须将PipedWriter和PipedReader配套使用

public class SendThread extends Thread {

    private PipedWriter pipedWriter = new PipedWriter();

    public PipedWriter getPipedWriter() {
        return pipedWriter;
    }

    @Override
    public void run() {
        try {
            pipedWriter.write("我要发送一条消息");
            pipedWriter.write("开炮");
            pipedWriter.write("完毕");
            pipedWriter.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

public class ReceiveThread extends Thread {

    private PipedReader pipedReader = new PipedReader();

    public PipedReader getPipedReader() {
        return pipedReader;
    }

    @Override
    public void run() {
        char[] chars = new char[50];
        int length = 0;
        try {
            while ((length = pipedReader.read(chars)) != -1) {
                System.out.println(new String(chars, 0, length));
            }
            pipedReader.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

public class PipedReaderTest {

    public static void main(String[] args) {
        //1.得到管道输入流
        ReceiveThread receiveThread = new ReceiveThread();
        PipedReader pipedReader = receiveThread.getPipedReader();
        //2.得到管道输出流
        SendThread sendThread = new SendThread();
        PipedWriter pipedWriter = sendThread.getPipedWriter();
        //3.将两者连接起来
        try {
            pipedReader.connect(pipedWriter);
            //pipedWriter.connect(pipedReader); 与上面一行代码含义相同
        } catch (IOException e) {
            e.printStackTrace();
        }
        //4.启动线程传输数据
        receiveThread.start();
        sendThread.start();
    }
}

结果：

CharArrayReader&CharArrayWriter简介

在内存中创建一个字符数组，然后进行输入输出

public class CharArrayReaderTest {

    public static void main(String[] args) throws Exception{
        CharArrayWriter charArrayWriter = new CharArrayWriter();
        charArrayWriter.write("你好啊");
        charArrayWriter.append("世界");
        CharArrayReader charArrayReader = new CharArrayReader(charArrayWriter.toCharArray());
        char[] chars = new char[10];
        charArrayReader.read(chars);
        System.out.println(new String(chars,0,chars.length));
    }
}

FilterReader简介

FilterReader是一个抽象类，这个类的定位类似于FilterInputStream，可以给其它输入流添加一些额外的功能，主要实现是在它的子类

PushbackReader简介

PushbackReader类似于PushbackInputStream，我们可以在读取过程中插入一些数据进去，重新读取，在某些场景下有奇用。比如有一个场景是每隔几个字加一个字进去，我们便可以使用这个输入流

public class PushbackReaderTest {

    public static void main(String[] args) throws Exception{
        //1.创建准备读取的文件
        File file = new File("E:\\ExampleTest\\TestText.txt");
        //2.创建输入流，读取数据
        PushbackReader pushbackReader = new PushbackReader(new FileReader(file));
        int length = 0;
        char[] chars = new char[3];
        int count = 1;
        while ((length = pushbackReader.read(chars)) != -1) {
            System.out.print(new String(chars, 0, length));
            if(count >= 0) {
                pushbackReader.unread("A".toCharArray());
                count--;
            }
        }
        pushbackReader.close();
    }
}

结果：

Writer常用的类&方法

常用类	含义
Writer	表示字符输出流的所有类的超类，它以字符为单位向数据源写数据
BufferedWriter	为字符写入提供缓冲功能，提高效率
OutputStreamWriter	将输出的字符流变为字节流，即将一个字符流的输出对象变为字节流的输出对象
FileWriter	继承OutputStreamWriter 类。按字符向字符类文件写入数据
PrintWriter	可以修饰其它输出类，使它们能够方便地打印各种数据值表示形式
StringWriter	使用StringWriter可以创建字符串
PipedWriter	管道输出流
CharArrayWriter	字符数组输出流
FilterWriter	装饰其它输出流，并为它们提供额外的功能

常用方法	含义
public void write(int b) throws IOExecption	该方法用于向数据源写入单个字符
public void write (char[] cbuf) throws IOExecption	该方法用于向数据源写入字符数组
public abstract void write (char[] cbuf,int off,int len) throws IOExecption	该该方法用于向数据源写入len个字符数据，并从数组cbuf的off位置开始
public void write (String str) throws IOExecption	该方法用于向数据源写入字符串
public abstract void flush() throws IOExecption	刷新该输出流的缓冲，将缓冲的数据全部写入到数据源
public abstract void close() throws IOExecption	关闭此输出流，关闭之前需先调用flush()

OutputStreamWriter简介

OutputStreamWriter是从字符流到字节流的桥接：使用指定的字符集将写入其中的字符编码为字节。它使用的字符集可以通过名称指定，也可以明确指定，或者可以接受平台的默认字符集。每次调用write（）方法都会导致在给定字符上调用编码转换器。生成的字节在写入底层输出流之前在缓冲区中累积。可以指定此缓冲区的大小，但默认情况下，它足够大，可用于大多数用途

FileWriter简介

FileWriter是OutputStreamWriter的子类，可以按字符向文件中写入数据

public class FileWriterTest {

    public static void main(String[] args) throws Exception {
        //1.准备输出文件
        File file = new File("E:\\ExampleTest\\TestText.txt");
        file.createNewFile();
        //2.创建输出流，写数据
        FileWriter fileWriter = new FileWriter(file);
        fileWriter.write("你好世界");
        fileWriter.close();
    }
}

BufferedWriter简介

BufferedWriter可以用来修饰其它输出流，从而提供缓冲功能，提高效率

public class BufferedWriterTest {

    public static void main(String[] args) throws Exception {
        //1.准备一个输出文件
        File file = new File("E:\\ExampleTest\\TestText.txt");
        file.createNewFile();
        //2.准备输出流，写数据
        BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(file));
        bufferedWriter.write("你好啊世界");
        bufferedWriter.close();
    }
}

PrintWriter简介

PrintWriter可以修饰其它输出流，使输出数据时更加方便便捷

public class FileWriterTest {

    public static void main(String[] args) throws Exception {
        //1.准备输出文件
        File file = new File("E:\\ExampleTest\\TestText.txt");
        file.createNewFile();
        //2.创建输出流，写数据
        FileWriter fileWriter = new FileWriter(file);
        PrintWriter printWriter = new PrintWriter(fileWriter);
        printWriter.println("你好啊");
        printWriter.println("世界");
        printWriter.println("我来了");
        printWriter.close();
        fileWriter.close();
    }
}

StringWriter简介

将字符串作为输出源，可以生成一个字符串

FilterWriter简介

FilterWriter是一个抽象类，是给其它输出流提供额外功能，但是现在还没有子类