杂谈——探秘字节流与字符流

正所谓，一切事情皆有缘由。而程序中的所有数据，自然也有它自己的流。（哈哈，强行押韵最为致命 ヽ(✿ﾟ▽ﾟ)ノ）

今天我们要认识的就是字节流和字符流这两个小兔崽子。

想要认识它们，我们就得先获得“流”这本秘籍，去看看“流”到底是什么。

1.流是什么呢？

要知道，在程序中所有的数据都是以流的方式进行传输或保存的，程序需要数据的时候要使用输入流读取数据，而当程序需要将一些数据保存起来的时候，就要使用输出流完成。

程序中的输入输出都是以流的形式保存的，流中保存的实际上全都是字节文件。

好的，看完上面两段的介绍，大家想必就知道流的重要性了。它作为数据输入输出的基础，少了它可万万不行。

接下来我们就进入正题，探究一下字节流和字符流的真面目。

2.字节流与字符流

在java.io包中操作文件内容的按数据类型划分的话主要有两大类：字节流、字符流。两类都分为输入和输出操作。

如下图：

java中提供了专用于输入输出功能的包Java.io,其中包括：InputStream,OutputStream,Reader,Writer。（这四个都是抽象类）。

•      InputStream 和OutputStream,两个是为字节流设计的,主要用来处理字节或二进制对象,
•      Reader和 Writer.两个是为字符流（一个字符占两个字节）设计的,主要用来处理字符或字符串.

即在字节流中输出数据主要是使用OutputStream完成，输入使的是InputStream；在字符流中输出主要是使用Writer类完成，输入流主要使用Reader类完成。

字节流处理单元为1个字节，操作字节和字节数组；而字符流是由Java虚拟机将字节转化为2个字节的Unicode字符为单位的字符而成的，因此字符流处理的单元为2个字节的Unicode字符，分别操作字符、字符数组或字符串。

简单点说呢：字节流就是普通的二进制流，读出来的是bit；字符流就是在字节流的基础按照字符编码处理，处理的是char。

由此我们可以粗略地知道，如果是处理音频文件、图片、歌曲，就用字节流好点。而字符流对多国语言支持性比较好，比如如果是关系到中文（文本）的，则用字符流好点。

所有文件的储存是都是字节（byte）的储存，在磁盘上保留的并不是文件的字符而是先把字符编码成字节，再储存这些字节到磁盘。在读取文件（特别是文本文件）时，也是一个字节一个字节地读取以形成字节序列

因此可以总结二者区别如下：

• 字节流处理单元为1个字节，操作字节和字节数组；字符流处理的单元为2个字节的Unicode字符，分别操作字符、字符数组或字符串。
• 字节流可用于任何类型的对象，包括二进制对象，而字符流只能处理字符或者字符串。
• 字节流提供了处理任何类型的IO操作的功能，但它不能直接处理Unicode字符，而字符流就可以。

字节流是最基本的，所有的InputStrem和OutputStream的子类都是,主要用在处理二进制数据，它是按字节来处理的。这个我们都知道，那既然字节流可以直接处理二进制数据，那为什么不直接用字节流，反而还多出一个字符流呢，这岂不是多此一举？

但是，我们知道，一个字节是8位，只能有256个值，如果用来表示文字，可以表示ASCII码，包括控制字符，数字，符号，英文字母，西欧字母，制表符。那中文呢？中文少说有几千汉字，所以一个字节表示不了，得用两个字节，编码方案有GB2312，GBK，Big5等。后来又出现统一字符集，把各个常用语言都容纳进来，肯定1个字节也放不下。Java使用Unicode，用char这个数据类型表示一个多字节的字符。

因此，由于实际中很多的数据是文本，所以才提出了字符流的概念。它是按虚拟机的encode来处理，也就是要进行字符集的转化 。字节流与字符流之间通过 InputStream | Reader,OutputStream | Writer来关联，即通过byte[]和String来关联。因此，我们可以知晓，平常在实际开发中出现的汉字问题实际上都是在字符流和字节流之间转化不统一而造成的 。

注：大部分人认为一切都是字节流，其实没有字符流这个东西。字符只是根据编码集对字节流翻译之后的产物。

3.字节流

字节流主要是操作byte类型数据，以byte数组为准，主要操作类就是OutputStream、InputStream。

3.1字节输出流：OutputStream

OutputStream是整个IO包中字节输出流的最大父类，此类的定义如下：

public abstract class OutputStream extends Object implements Closeable,Flushable

从以上的定义可以发现，该类是一个抽象类，如果想要使用此类的话，就首先必须通过子类实例化对象。那么如果现在要操作的是一个文件，则可以使用：FileOutputStream类。通过向上转型之后，可以将OutputStream实例化。

Closeable表示可以关闭的操作，因为程序运行到最后肯定要关闭

Flushable：表示刷新，清空内存中的数据

FileOutputStream类的构造方法如下：

public FileOutputStream(File file)throws FileNotFoundException

举个例子：

对Test11.txt进行写数据操作，代码如下：

package javatest;
 import java.io.File;
 import java.io.FileOutputStream;
 import java.io.IOException;
 import java.io.OutputStream;

public class Test11 {
	public static void main(String[] args) throws IOException {       
		File f = new File("C:\\Users\\lenovo\\Desktop" + File.separator+"Test11.txt");
        OutputStream out=new FileOutputStream(f);//如果文件不存在会自动创建
        String str="Searchin";
        byte[] b=str.getBytes();
        out.write(b);//因为是字节流，所以要转化成字节数组进行输出
     /* 也可以一个字节一个字节写入
        for(int i=0;i<b.length;i++){
        	            out.write(b[i]);
        }
    */
        out.close();
     }
 }

上文程序将Searchin这个字符串写入文件中，这种方式将覆盖原有的内容。我们打开文件看一下是否写入了字符串：

现在就写入成功了。 

当然了，因为上面这种方法会覆盖文件中的内容，那么我要是不想覆盖内容，而是在内容后面追加的话，这就要用到FileOutputStream类的另一个构造方法了。

public FileOutputStream(File file,boolean append)throws FileNotFoundException

在构造方法中，如果将append的值设置为true，则表示在文件的末尾追加内容。

我们来玩一下这个方法。

代码如下：

package javatest;
 import java.io.File;
 import java.io.FileOutputStream;
 import java.io.IOException;
 import java.io.OutputStream;

public class Test11 {
	public static void main(String[] args) throws IOException {       
		File f = new File("C:\\Users\\lenovo\\Desktop" + File.separator+"Test11.txt");
        String str="Searchin";
        OutputStream out=new FileOutputStream(f,true);//追加内容
 
       byte[] b=str.getBytes();
        for(int i=0;i<b.length;i++){
        	out.write(b[i]);
        }
        out.close();
     }
 }

程序运行之后就出现在Searchin后面又追加了一个Searchin了。

当然，你要是觉得这样不好看，你也可以换个行，文件中换行为：\r\n。我们来试试看： 

 String str="\r\nSearchin";

运行结果如下： 

好了，现在就换了个行啦。 

 

3.2字节输入流：InputStream

既然程序可以向文件中写入内容，那当然可以通过InputStream从文件中把内容读取进来啦，首先来看InputStream类的定义：

public abstract class InputStream extends Object implements Closeable

与OutputStream类一样，InputStream本身也是一个抽象类，必须依靠其子类，如果现在是从文件中读取，就用FileInputStream来实现。

观察FileInputStream类的构造方法：

public FileInputStream(File file)throws FileNotFoundException

还是用刚才的文件，我们看看读文件是怎么玩的：

package javatest;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
public class Test22 {
   public static void main(String[] args) throws IOException {
		File f = new File("C:\\Users\\lenovo\\Desktop" + File.separator+"Test11.txt");
      InputStream in=new FileInputStream(f);
      byte[] b=new byte[4096];
//（注意：这里以前写作1024，现在不能再这样写，必须是4096的倍数） 
      int len=in.read(b);
      in.close();
      System.out.println(new String(b,0,len));
     }
 }

这个程序将读取文件中的内容，即，然后再输出。

我们来看看输出结果：

好的，读取成功。

不过，这个方法是有问题的呀。上文中的代码自定义了一个固定的字节数组，用来存储从文件中读出来的内容。但是显然我读出来的字符用不了这么大的数组，剩下的那部分空间就完全给浪费了。

那么我们可不可以根据文件的大小来定义字节数组的大小，从而减少浪费呢？

当然可以，File类中的方法：public long length()就是做这个的。

我们只要上边程序中的

byte[] b=new byte[4096];

 

改为：

 byte[] b=new byte[(int) f.length()];

这样就可以根据文件大小来定义字节数组的大小了。效果还是一样完美~

 到这里可能有人会问，我就是想要一个字节一个字节地读出来，可以吗？可以啊！

当你知道输入文件的大小的时候，就可以将读操作的语句改为如下语句：

for(int i=0;i<b.length;i++){
           b[i]=(byte) in.read();
 }

即（这里为了看得方便，就直接给main函数啦）

 public static void main(String[] args) throws IOException {
	 File f = new File("C:\\Users\\lenovo\\Desktop" + File.separator+"Test11.txt");
     InputStream in=new FileInputStream(f);
     byte[] b=new byte[(int) f.length()];
     for(int i=0;i<b.length;i++){
         b[i]=(byte) in.read();
     }
     in.close();
     System.out.println(new String(b));
}

 

当然，要是你不知道输入文件是多大的话，那也没有问题，只不过需要借助标志来完成咯，用如下语句就可以了：

public static void main(String[] args) throws IOException {
	  File f = new File("C:\\Users\\lenovo\\Desktop" + File.separator+"Test11.txt");
      InputStream in=new FileInputStream(f);
      byte[] b=new byte[4096];
      int temp=0;
      int len=0;
      while((temp=in.read())!=-1){//-1为文件读完的标志
          b[len]=(byte) temp;
          len++;
      }
      in.close();
      System.out.println(new String(b,0,len));
}

 

4.字符流

在程序中一个字符等于两个字节，那么java提供了Reader、Writer两个专门操作字符流的类。

4.1字符输出流：Writer

Writer本身是一个字符流的输出类，此类的定义如下：

public abstract class Writer extends Object implements Appendable，Closeable，Flushable

此类本身也是一个抽象类，如果要使用此类，则肯定要使用其子类，此时如果是向文件中写入内容，所以应该使用FileWriter的子类。

FileWriter类的构造方法定义如下：

public FileWriter(File file)throws IOException

字符流的操作比字节流操作好在一点，就是可以直接输出字符串了，不用再像之前那样进行转换操作了。

那么我们接下来就看看它是怎么进行读写操作的。

写文件：

这个程序默认会将原内容覆盖，我们来运行看看

如果想要在文件后边追加，也是依靠在构造函数上加上追加标记。即 

Writer out=new FileWriter(f,true);

现在就变成在后面追加啦~ 

 

4.2字符输入流：Reader

Reader是使用字符的方式从文件中取出数据，Reader类的定义如下：

public abstract class Reader extends Objects implements Readable，Closeable

Reader本身也是抽象类，如果现在要从文件中读取内容，则可以直接使用FileReader子类。

FileReader的构造方法定义如下：

public FileReader(File file)throws FileNotFoundException

以字符数组的形式读取出数据：

package javatest;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;
import java.io.Reader;
public class Test22 {
   public static void main(String[] args) throws IOException {
		File f = new File("C:\\Users\\lenovo\\Desktop" + File.separator+"Test11.txt");
		Reader input=new FileReader(f);
		char[] c=new char[4096];
		int len=input.read(c);
		input.close();
		System.out.println(new String(c,0,len));
     }
 }

现在就读出文件里的内容啦~~

 当然啦，也可以想字节流的读取一样，用循环方式，判断是否读到底：

package javatest;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;
import java.io.Reader;
public class Test22 {
   public static void main(String[] args) throws IOException {
		File f = new File("C:\\Users\\lenovo\\Desktop" + File.separator+"Test11.txt");
		Reader input=new FileReader(f);
		 char[] c=new char[4096];
		int temp=0;
		int len=0;
		while((temp=input.read())!=-1){
		c[len]=(char) temp;
		len++;
		}
		input.close();
		System.out.println(new String(c,0,len));
     }
 }

 5.总结

字节流和字符流使用是非常相似的，那么除了操作代码的不同之外，还有哪些不同呢？

• 字节流在操作的时候本身是不会用到缓冲区（内存）的，是与文件本身直接操作的；而字符流在操作的时候会使用到缓冲区的。
• 字节流在操作文件时，即使不关闭资源（close方法），文件也能输出，但是如果字符流不使用close方法的话，则不会输出任何内容，说明字符流用的是缓冲区，并且可以使用flush方法强制进行刷新缓冲区，这时才能在不close的情况下输出内容（这一点需要注意）

那开发中究竟用字节流好还是用字符流好呢？

在所有的硬盘上保存文件或进行传输的时候都是以字节的方法进行的，包括图片也是按字节完成，而字符是只有在内存中才会形成的，所以使用字节的操作是最多的。

如果要java程序实现一个拷贝功能，应该选用字节流进行操作（可能拷贝的是图片），并且采用边读边写的方式（节省内存）。

 

 

好啦，以上就是字节流和字符流的相关总结，如果大家有什么更具体的发现或者发现文中有描述错误的地方，欢迎留言评论，我们一起学习呀~~

 

Biu~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~pia！