前言
上篇文章，我们介绍了 java 的文件字节流框架中的相关内容，而我们本篇文章将着重于文件字符流的相关内容。
首先需要明确一点的是，字节流处理文件的时候是基于字节的，而字符流处理文件则是基于一个个字符为基本单元的。
但实际上，字符流操作的本质就是「字节流操作」+「编码」两个过程的封装，你想是不是，无论你是写一个字符到文件，你需要将字符编码成二进制，然后以字节为基本单位写入文件，或是你读一个字符到内存，你需要以字节为基本单位读出，然后转码成字符。
理解这一点很重要，这将决定你对字符流整体上的理解是怎样的，下面我们一起看看相关 api 的设计。
基类 reader/writer
在正式学习字符流基类之前，我们需要知道 java 中是如何表示一个字符的。
首先，java 中的默认字符编码为：utf-8，而我们知道 utf-8 编码的字符使用 1 到 4 个字节进行存储，越常用的字符使用越少的字节数。
而 char 类型被定义为两个字节大小，也就是说，对于通常的字符来说，一个 char 即可存储一个字符，但对于一些增补字符集来说，往往会使用两个 char 来表示一个字符。
reader 作为读字符流的基类，它提供了最基本的字符读取操作，我们一起看看。
先看看它的构造器：
|
1
2
3
4
5
6
7
8
9
10
11
|
protected object lock;
protected reader() {
this.lock = this;
}
protected reader(object lock) {
if (lock == null) {
throw new nullpointerexception();
}
this.lock = lock;
}
|
reader 是一个抽象类，所以毋庸置疑的是，这些构造器是给子类调用的，用于初始化 lock 锁对象，这一点我们后续会详细解释。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
public int read() throws ioexception {
char cb[] = new char[1];
if (read(cb, 0, 1) == -1)
return -1;
else
return cb[0];
}
public int read(char cbuf[]) throws ioexception {
return read(cbuf, 0, cbuf.length);
}
abstract public int read(char cbuf[], int off, int len)
|
基本的读字符操作都在这了，第一个方法用于读取一个字符出来，如果已经读到了文件末尾，将返回 -1，同样的以 int 作为返回值类型接收，为什么不用 char？原因是一样的，都是由于 -1 这个值的解释不确定性。
第二个方法和第三个方法是类似的，从文件中读取指定长度的字符放置到目标数组当中。第三个方法是抽象方法，需要子类自行实现，而第二个方法却又是基于它的。
还有一些方法也是类似的：
- public long skip(long n)：跳过 n 个字符
- public boolean ready()：下一个字符是否可读
- public boolean marksupported()：见 reset 方法
- public void mark(int readaheadlimit)：见 reset 方法
- public void reset()：用于实现重复读操作
- abstract public void close()：关闭流
这些个方法其实都见名知意，并且和我们的 inputstream 大体上都差不多，都没有什么核心的实现，这里不再赘述，你大致知道它内部有些个什么东西即可。
writer 是写的字符流，它用于将一个或多个字符写入到文件中，当然具体的 write 方法依然是一个抽象的方法，待子类来实现，所以我们这里亦不再赘述了。
适配器 inpuststramreader/outputstreamwriter
适配器字符流继承自基类 reader 或 writer，它们算是字符流体系中非常重要的成员了。主要的作用就是，将一个字节流转换成一个字符流，我们先以读适配器为例。
首先就是它最核心的成员：
|
1
|
private final streamdecoder sd;
|
streamdecoder 是一个解码器，用于将字节的各种操作转换成字符的相应操作，关于它我们会在后续的介绍中不间断的提到它，这里不做统一的解释。
然后就是构造器：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
public inputstreamreader(inputstream in) {
super(in);
try {
sd = streamdecoder.forinputstreamreader(in, this, (string)null);
} catch (unsupportedencodingexception e) {
throw new error(e);
}
}
public inputstreamreader(inputstream in, string charsetname)
throws unsupportedencodingexception
{
super(in);
if (charsetname == null)
throw new nullpointerexception("charsetname");
sd = streamdecoder.forinputstreamreader(in, this, charsetname);
}
|
这两个构造器的目的都是为了初始化这个解码器，都调用的方法 forinputstreamreader，只是参数不同而已。我们不妨看看这个方法的实现：
这是一个典型的静态工厂模式，三个参数，var0 和 var1 没什么好说的，分别代表的是字节流实例和适配器实例。
而参数 var2 其实代表的是一种字符编码的名称，如果为 null，那么将使用系统默认的字符编码：utf-8 。
最终我们能够得到一个解码器实例。
接着介绍的所有方法几乎都是依赖的这个解码器而实现的。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
public string getencoding() {
return sd.getencoding();
}
public int read() throws ioexception {
return sd.read();
}
public int read(char cbuf[], int offset, int length){
return sd.read(cbuf, offset, length);
}
public void close() throws ioexception {
sd.close();
}
|
解码器中相关的方法的实现代码还是相对复杂的，这里我们不做深入的研究，但大体上的实现思路就是：「字节流读取 + 解码」的过程。
当然了，outputstreamwriter 中必然也存在一个相反的 streamencoder 实例用于编码字符。
除了这一点外，其余的操作并没有什么不同，或是通过字符数组向文件中写入，或是通过字符串向文件中写入，又或是通过 int 的低 16 位向文件中写入。
文件字符流 filereader/writer
文件的字符流可以说非常简单了，除了构造器，就不存在任何其他方法了，完全依赖文件字节流。
我们以 filereader 为例，
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
filereader 继承自 inputstreamreader，有且仅有以下三个构造器：
public filereader(string filename) throws filenotfoundexception {
super(new fileinputstream(filename));
}
public filereader(file file) throws filenotfoundexception {
super(new fileinputstream(file));
}
public filereader(filedescriptor fd) {
super(new fileinputstream(fd));
}
|
理论上来说，所有的字符流都应当以我们的适配器为基类，因为只有它提供了字符到字节之间的转换，无论你是写或是读都离不开它。
而我们的 filereader 并没有扩展任何一个自己的方法，父类 inputstreamreader 中预实现的字符操作方法对他来说已经足够，只需要传入一个对应的字节流实例即可。
filewriter 也是一样的，这里不再赘述了。
字符数组流 chararrayreader/writer
字符数组和字节数组流是类似的，都是用于解决那种不确定文件大小，而需要读取其中大量内容的情况。
由于它们内部提供动态扩容机制，所以既可以完全容纳目标文件，也可以控制数组大小，不至于分配过大内存而浪费了大量内存空间。
先以 chararrayreader 为例
|
1
2
3
4
5
6
7
8
9
10
11
|
protected char buf[];
public chararrayreader(char buf[]) {
this.buf = buf;
this.pos = 0;
this.count = buf.length;
}
public chararrayreader(char buf[], int offset, int length){
//....
}
|
构造器核心任务就是初始化一个字符数组到内部的 buf 属性中，以后所有对该字符数组流实例的读操作都基于 buf 这个字符数组。
关于 chararrayreader 的其他方法以及 chararraywriter，这里不再赘述了，和上篇的字节数组流基本类似。
除此之外，这里还涉及一个 stringreader 和 stringwriter，其实本质上和字符数组流是一样的，毕竟 string 的本质就是 char 数组。
缓冲数组流 bufferedreader/writer
同样的，bufferedreader/writer 作为一种缓冲流，也是装饰者流，用于提供缓冲功能。大体上类似于我们的字节缓冲流，这里我们简单介绍下。
|
1
2
3
4
5
6
7
8
9
|
private reader in;
private char cb[];
private static int defaultcharbuffersize = 8192;
public bufferedreader(reader in, int sz){..}
public bufferedreader(reader in) {
this(in, defaultcharbuffersize);
}
|
cb 是一个字符数组，用于缓存从文件流中读取出来的部分字符，你可以在构造器中初始化这个数组的长度，否则将使用默认值 8192 。
|
1
2
3
|
public int read() throws ioexception {..}
public int read(char cbuf[], int off, int len){...}
|
关于 read，它依赖成员属性 in 的读方法，而 in 作为一个 reader 类型，内部往往又依赖的某个 inputstream 实例的读方法。
所以说，几乎所有的字符流都离不开某个字节流实例。
关于 bufferedwriter，这里也不再赘述了，大体上都是类似的，只不过一个是读一个是写而已，都围绕着内部的字符数组进行。
标准打印输出流
打印输出流主要有两种，printstream 和 printwriter，前者是字节流，后者是字符流。
这两个流算是对各自类别下的流做了一个集成，内部封装有丰富的方法，但实现也稍显复杂，我们先来看这个 printstream 字节流：
主要的构造器有这么几个：
- public printstream(outputstream out)
- public printstream(outputstream out, boolean autoflush)
- public printstream(outputstream out, boolean autoflush, string encoding)
- public printstream(string filename)
显然，简单的构造器会依赖复杂的构造器，这已经算是 jdk 设计「老套路」了。区别于其他字节流的一点是，printstream 提供了一个标志 autoflush，用于指定是否自动刷新缓存。
接着就是 printstream 的写方法：
- public void write(int b)
- public void write(byte buf[], int off, int len)
除此之外，printstream 还封装了大量的 print 的方法，写入不同类型的内容到文件中，例如：
- public void print(boolean b)
- public void print(char c)
- public void print(int i)
- public void print(long l)
- public void print(float f)
- 等等
当然，这些方法并不会真正的将数值的二进制写入文件，而只是将它们所对应的字符串写入文件，例如：
|
1
|
print(123);
|
最终写入文件的不是 123 所对应的二进制表述，而仅仅是 123 这个字符串，这就是打印流。
printstream 使用的缓冲字符流实现所有的打印操作，如果指明了自动刷新，则遇到换行符号「\n」会自动刷新缓冲区。
所以说，printstream 集成了字节流和字符流中所有的输出方法，其中 write 方法是用于字节流操作，print 方法用于字符流操作，这一点需要明确。
至于 printwriter，它就是全字符流，完全针对字符进行操作，无论是 write 方法也好，print 方法也好，都是字符流操作。
总结一下，我们花了三篇文章讲解了 java 中的字节流和字符流操作，字节流基于字节完成磁盘和内存之间的数据传输，最典型的就是文件字符流，它的实现都是本地方法。有了基本的字节传输能力后，我们还能够通过缓冲来提高效率。
而字符流的最基本实现就是，inputstreamreader 和 outputstreamwriter，理论上它俩就已经能够完成基本的字符流操作了，但也仅仅局限于最基本的操作，而构造它们的实例所必需的就是「一个字节流实例」+「一种编码格式」。
所以，字符流和字节流的关系也就如上述的等式一样，你写一个字符到磁盘文件中所必需的步骤就是，按照指定编码格式编码该字符，然后使用字节流将编码后的字符二进制写入文件中，读操作是相反的。
文章中的所有代码、图片、文件都云存储在我的 github 上：
(https://github.com/singleyam/overview_java)
总结
以上就是这篇文章的全部内容了，希望本文的内容对大家的学习或者工作具有一定的参考学习价值，如果有疑问大家可以留言交流，谢谢大家对服务器之家的支持。
原文链接：https://www.cnblogs.com/yangming1996/p/9072330.html