22 Java学习之字符流（Reader和Writer)

Posted 2021-01-13 Hermioner

  Java中的流是个抽象的概念，当程序需要从某个数据源读入数据的时候，就会开启一个数据流，数据源可以是文件、内存或网络等等。相反地，需要写出数据到某个数据源目的地的时候，也会开启一个数据流，这个数据源目的地也可以是文件、内存或网络等等

一. 字符流的引入

正如字节流中所看到的，有时候当一个中文字符含有两个字节时，字节流它时一次只能操作一个字节，它不能直接操作Unicode字符（note:比如一个中文unicode字符，它实际上占用了两个字节）。因此引入了字符流。

二. 字符流

字符流分为输入字符流和输出字符流。它们的基类代表分别时Reader和Writer。

Writer: 把要写入文件的字符序列（实际上是unicode码元序列）转为指定编码方式下的字节序列，然后再写入文件中。

Reader:把要读取的字节序列按照指定编码方式转为相应的字符序列（实际上是unicode码元序列），从而写入内存中。

 三. 字符输入流

1. 常见的字符输入流有：

• Reader
• InputStreamReader
• FileReader
• BufferedReader

2. 它们的用途与区别

（1）Reader：是字符流的抽象基类，它包含了重要方法有read和close

（2）InputStreamReader：可以把InputStream中的字节数据流根据字符编码方式转换成字符数据流。

（3）FileReader：可以把FileInputStream中的字节数据转换成根据字符编码方式转成字符数字流。

（4）BufferedReader：可以把字符输入流进行封装，将数据进行缓冲，提高读取效率。它含有read（末尾返回-1）和readLine()（末尾返回Null).

3. InputStreamReader的使用

 1 package com.test.a;
 2 
 3 import java.io.FileInputStream;
 4 import java.io.IOException;
 5 import java.io.InputStreamReader;
 6 
 7 public class Test {
 8     public static void main(String args[]) throws IOException {
 9         FileInputStream fileInputStream=new FileInputStream("C:\\\\Users\\\\hermioner\\\\Desktop\\\\test.txt");
10         InputStreamReader inputStreamReader=new InputStreamReader(fileInputStream);
11         int ch;
12         while((ch=inputStreamReader.read())!=-1)
13         {
14             System.out.println((char)ch);
15         }
16         inputStreamReader.close();
17         fileInputStream.close();
18     }
19 }
20 
21 我
22 爱
23 我
24 家

View Code

note:test.txt中的内容是横着的  我爱我家

note:InputStreamReader需要一个字节输入流对象作为实例化参数。还可以指定第二个参数，第二个参数是字符编码方式，可以是编码方式的字符串形式，也可以是一个字符集对象。

4. FileReader

 1 package com.test.a;
 2 
 3 import java.io.FileReader;
 4 import java.io.IOException;
 5 
 6 public class Test {
 7     public static void main(String args[]) throws IOException {
 8         FileReader reader=new FileReader("C:\\\\Users\\\\hermioner\\\\Desktop\\\\test.txt");
 9         char chars[]=new char[1024];
10         int len;
11         while((len=reader.read(chars))!=-1) {
12             System.out.println(new String(chars,0,len));
13         }
14         reader.close();
15     }
16 }
17 
18 我爱我家

View Code

note:FileReader 需要一个文件对象作为实例化参数，可以是File类对象，也可以是文件的路径字符串。

5. BufferedReader

 1 package com.test.a;
 2 
 3 import java.io.BufferedReader;
 4 import java.io.FileReader;
 5 import java.io.IOException;
 6 
 7 public class Test {
 8     public static void main(String args[]) throws IOException {
 9         FileReader fileReader=new FileReader("C:\\\\Users\\\\hermioner\\\\Desktop\\\\test.txt");
10         BufferedReader bufferedReader=new BufferedReader(fileReader);
11         String line;
12         while((line=bufferedReader.readLine())!=null) {
13             System.out.println(line);
14         }
15         bufferedReader.close();
16         fileReader.close();
17     }
18 }
19 
20 
21 我爱我家

View Code

note: BufferReader需要一个字符输入流对象作为实例化参数。

四. 字符输出流

1. 常见的字符输出流有：

• Writer
• OutputStreamWriter
• FileWriter
• BufferedWriter

它们的区别和用途：

（1）Writer：是字符输出流的抽象基类，它包含的重要方法有wirte、close、flush（刷新输出流，把数据马上写到输出流中）

（2）OutputStreamWriter：可以使我们直接往流中写字符串数据，它里面会帮我们根据字符编码方式来把字符数据转成字节数据再写给输出流，它相当于一个中介\\桥梁。

（3）FileWriter：与OutputStreamWriter功能类似，我们可以直接往流中写字符串数据，FileWriter内部会根据字符编码方式来把字符数据转成字节数据再写给输出流。

（4）BufferedWriter：比FileWriter还高级一点，它利用了缓冲区来提高写的效率。它还多出了一个函数：

• newLine() ：写入一个换行符。

2. OutputStreamWriter使用

 1 public class Test {
 2     public static void main(String args[]) throws IOException {
 3         OutputStream outputStream=new FileOutputStream("C:\\\\Users\\\\hermioner\\\\Desktop\\\\test.txt");
 4         OutputStreamWriter outputStreamWriter=new OutputStreamWriter(outputStream);
 5         outputStreamWriter.write("hello world,你好");
 6         outputStreamWriter.close();
 7     }
 8 }
 9 
10 
11 就可以在test中写入数据。

View Code

说明：OutputStreamWriter是需要传入一个流对象作为实例化参数的

3. FileWriter使用

1 public class Test {
2     public static void main(String args[]) throws IOException {
3         FileWriter fileWriter=new FileWriter("C:\\\\Users\\\\hermioner\\\\Desktop\\\\test.txt");
4         fileWriter.write("加油");
5         fileWriter.close();
6     }
7 }
8 
9 文件中就写入了字符串内容

View Code

说明：FileWriter需要一个文件对象来实例化，可以是File类对象，也可以是文件的路径字符串。

4. BufferedWriter使用

1 public class Test {
2     public static void main(String args[]) throws IOException{
3         FileWriter fileWriter=new FileWriter("C:\\\\Users\\\\hermioner\\\\Desktop\\\\test.txt");
4         BufferedWriter bufferedWriter=new BufferedWriter(fileWriter);
5         bufferedWriter.write("加油");
6         bufferedWriter.close();
7         fileWriter.close();
8     }
9 }

View Code

五.字节流和字符流的区别

java处理文件的类里面，stream结尾都是采用字节流，reader和writer结尾都是采用字符流。两者的区别就是读写的时候一个是按字节读写，一个是按字符。 

字符流的底层就是字节流。而字符流主要是读取文本文件内容的，可以一个字符一个字符的读取，也可以一行一行的读取文本文件内容。而字节流读取单位为byte.byte作为计算机存储最基本单位，可以用字节流来读取很多其他格式的文件，比如图片视频等等。基于B/S和C/S的文件传输都可以采用字节流的形式。在读写文件需要对内容按行处理，比如比较特定字符，处理某一行数据的时候一般会选择字符流。只是读写文件，和文件内容无关的，一般选择字节流。 (注：除了字符和字节流之外，java还有一种叫对象流。)

字节流就是按照字节来进行传输,字符流是按照字符来传输.最基本的是字节流,字符流可以说是对字节流的一个包装流.比如你知道了一个字符是2个字节,那么你让字节流一次传输2个字节,那不就相当于一次传输一个字符,也就是字符流了。

字节流与和字符流的使用非常相似，两者除了操作代码上的不同之外，是否还有其他的不同呢？
实际上字节流在操作时本身不会用到缓冲区（内存），是文件本身直接操作的，而字符流在操作时使用了缓冲区，通过缓冲区再操作文件，如图

下面以两个写文件的操作为主进行比较，但是在操作时字节流和字符流的操作完成之后都不关闭输出流。
范例：使用字节流不关闭执行

// 通过字节流 写文件
    public static void ByteWrite() {
        File file = new File("d:\\\\test\\\\test.txt");
        try {
            OutputStream outputStream = new FileOutputStream(file);
            String textString = "Hello World!!!";
            byte[] data = textString.getBytes();
            outputStream.write(data);
            //outputStream.close();
        } catch (IOException e) {
            System.out.println("字节流写入文件出错。");
            e.printStackTrace();
        }
    }

程序运行结果：

 此时没有关闭字节流操作，但是文件中也依然存在了输出的内容，证明字节流是直接操作文件本身的。而下面继续使用字符流完成，再观察效果。
范例：使用字符流不关闭执行

 

// 通过字符流 写文件
    public static void StringWrite() {
        File file = new File("d:\\\\test\\\\test.txt");
        try {
            FileWriter writer = new FileWriter(file);
            String textString = "Hello World!!!";
            writer.write(textString);
            // writer.flush();
            // writer.close();
        } catch (IOException e) {
            System.out.println("字符流写入文件出错.");
            e.printStackTrace();
        }
    }

程序运行结果：

程序运行后会发现文件中没有任何内容，这是因为字符流操作时使用了缓冲区，而   在关闭字符流时会强制性地将缓冲区中的内容进行输出，但是如果程序没有关闭，则缓冲区中的内容是无法输出的，所以得出结论：字符流使用了缓冲区，而字节流没有使用缓冲区。

1. 什么叫缓冲区？
缓冲区可以简单地理解为一段内存区域。
某些情况下，如果一个程序频繁地操作一个资源（如文件或数据库），则性能会很低，此时为了提升性能，就可以将一部分数据暂时读入到内存的一块区域之中，以后直接从此区域中读取数据即可，因为读取内存速度会比较快，这样可以提升程序的性能。
在字符流的操作中，所有的字符都是在内存中形成的，在输出前会将所有的内容暂时保存在内存之中，所以使用了缓冲区暂存数据。
如果想在不关闭时也可以将字符流的内容全部输出，则可以使用Writer类中的flush()方法完成。

2. 使用字节流好还是字符流好？
使用字节流更好。
所有的文件在硬盘或在传输时都是以字节的方式进行的，包括图片等都是按字节的方式存储的，而字符是只有在内存中才会形成，所以在开发中，字节流使用较为广泛。

要把一片二进制数据数据逐一输出到某个设备中，或者从某个设备中逐一读取一片二进制数据，不管输入输出设备是什么，我们要用统一的方式来完成这些操作，用一种抽象的方式进行描述，这个抽象描述方式起名为IO流，对应的抽象类为OutputStream和InputStream ，不同的实现类就代表不同的输入和输出设备，它们都是针对字节进行操作的。

       在应用中，经常要完全是字符的一段文本输出去或读进来，用字节流可以吗？计算机中的一切最终都是二进制的字节形式存在。对于“中国”这些字符，首先要得到其对应的字节，然后将字节写入到输出流。读取时，首先读到的是字节，可是我们要把它显示为字符，我们需要将字节转换成字符。由于这样的需求很广泛，人家专门提供了字符流的包装类。

  底层设备永远只接受字节数据，有时候要写字符串到底层设备，需要将字符串转成字节再进行写入。字符流是字节流的包装，字符流则是直接接受字符串，它内部将串转成字节，再写入底层设备，这为我们向IO设别写入或读取字符串提供了一点点方便。

 

 

 

参考文献：

https://www.cnblogs.com/progor/p/9357676.html

https://www.cnblogs.com/dongguacai/p/5676254.html

https://www.cnblogs.com/jun9207/p/5197697.html