字节流与字符流的区别详解

时间  2019-11-09
标签 节流 字符 区别 详解 繁體版
原文   原文链接

字节流与字符流html

先来看一下流的概念：java

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

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

字节流与字符流函数

在java.io包中操做文件内容的主要有两大类：字节流、字符流，两类都分为输入和输出操做。在字节流中输出数据主要是使用OutputStream完成，输入使的是InputStream，在字符流中输出主要是使用Writer类完成，输入流主要使用Reader类完成。（这四个都是抽象类）编码

 

java中提供了专用于输入输出功能的包Java.io,其中包括：
     InputStream,OutputStream,Reader,Writer
     InputStream 和OutputStream,两个是为字节流设计的,主要用来处理字节或二进制对象,
     Reader和 Writer.两个是为字符流（一个字符占两个字节）设计的,主要用来处理字符或字符串.spa


　　字符流处理的单元为2个字节的Unicode字符，分别操做字符、字符数组或字符串，而字节流处理单元为1个字节，操做字节和字节数组。因此字符流是由Java虚拟机将字节转化为2个字节的Unicode字符为单位的字符而成的，因此它对多国语言支持性比较好！若是是音频文件、图片、歌曲，就用字节流好点，若是是关系到中文（文本）的，用字符流好点。
     全部文件的储存是都是字节（byte）的储存，在磁盘上保留的并非文件的字符而是先把字符编码成字节，再储存这些字节到磁盘。在读取文件（特别是文本文件）时，也是一个字节一个字节地读取以造成字节序列。设计

     字节流可用于任何类型的对象，包括二进制对象，而字符流只能处理字符或者字符串； 2. 字节流提供了处理任何类型的IO操做的功能，但它不能直接处理Unicode字符，而字符流就能够。
     字节流是最基本的，全部的InputStrem和OutputStream的子类都是,主要用在处理二进制数据，它是按字节来处理的 但实际中不少的数据是文本，又提出了字符流的概念，它是按虚拟机的encode来处理，也就是要进行字符集的转化 这两个之间经过 InputStreamReader,OutputStreamWriter来关联，其实是经过byte[]和String来关联 在实际开发中出现的汉字问题实际上都是在字符流和字节流之间转化不统一而形成的 

==================咱们还能够看到：============
Reader类的read()方法返回类型为int ：做为整数读取的字符（占两个字节共16位），范围在 0 到 65535 之间 (0x00-0xffff)，若是已到达流的末尾，则返回 -1code

inputStream的read()虽然也返回int，但因为此类是面向字节流的，一个字节占8个位，因此返回 0 到 255 范围内的 int 字节值。若是由于已经到达流末尾而没有可用的字节，则返回值 -1。所以对于不能用0-255来表示的值就得用字符流来读取！好比说汉字.htm

 

操做流程

在Java中IO操做也是有相应步骤的，以文件操做为例，主要的操做流程以下：

1 使用File类打开一个文件

经过字节流或字符流的子类，指定输出的位置

3 进行读/写操做

4 关闭输入/输出

IO操做属于资源操做，必定要记得关闭

 

字节流

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

 

字节输出流：OutputStream

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

public abstract class OutputStream extends Object implements Closeable,Flushable

从以上的定义能够发现，此类是一个抽象类，若是想要使用此类的话，则首先必须经过子类实例化对象，那么若是如今要操做的是一个文件，则可使用：FileOutputStream类。经过向上转型以后，能够为OutputStream实例化

Closeable表示能够关闭的操做，由于程序运行到最后确定要关闭

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

FileOutputStream类的构造方法以下：

public FileOutputStream(File file)throws FileNotFoundException

写数据：

1 import java.io.File;
 2 import java.io.FileOutputStream;
 3 import java.io.IOException;
 4 import java.io.OutputStream;
 5
 6 public class Test11 {
 7     public static void main(String[] args) throws IOException {
 8         File f = new File("d:" + File.separator+"test.txt");
 9         OutputStream out=new FileOutputStream(f);//若是文件不存在会自动建立
10         String str="Hello World";
11         byte[] b=str.getBytes();
12         out.write(b);//由于是字节流，因此要转化成字节数组进行输出
13         out.close();
14     }
15 }

 

也能够一个字节一个字节进行输出，以下：

1 import java.io.File;
 2 import java.io.FileOutputStream;
 3 import java.io.IOException;
 4 import java.io.OutputStream;
 5
 6 public class Test11 {
 7     public static void main(String[] args) throws IOException {
 8         File f = new File("d:" + File.separator+"test.txt");
 9         OutputStream out=new FileOutputStream(f);//若是文件不存在会自动建立
10         String str="Hello World";
11         byte[] b=str.getBytes();
12         for(int i=0;i<b.length;i++){
13             out.write(b[i]);
14         }
15         out.close();
16     }
17 }

 

以上输出只会进行覆盖，若是要追加的话，请看FileOutputStream类的另外一个构造方法：

public FileOutputStream(File file,boolean append)throws FileNotFoundException

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

 

1 import java.io.File;
 2 import java.io.FileOutputStream;
 3 import java.io.IOException;
 4 import java.io.OutputStream;
 5
 6 public class Test11 {
 7     public static void main(String[] args) throws IOException {
 8         File f = new File("d:" + File.separator+"test.txt");
 9         OutputStream out=new FileOutputStream(f,true);//追加内容
10         String str="\r\nHello World";
11         byte[] b=str.getBytes();
12         for(int i=0;i<b.length;i++){
13             out.write(b[i]);
14         }
15         out.close();
16     }
17 }

 

文件中换行为：\r\n

字节输入流：InputStream

既然程序能够向文件中写入内容，则就能够经过InputStream从文件中把内容读取进来，首先来看InputStream类的定义：

public abstract class InputStream extends Object implements Closeable

与OutputStream类同样，InputStream自己也是一个抽象类，必须依靠其子类，若是如今是从文件中读取，就用FileInputStream来实现。

观察FileInputStream类的构造方法：

public FileInputStream(File file)throws FileNotFoundException

读文件：

1 import java.io.File;
 2 import java.io.FileInputStream;
 3 import java.io.IOException;
 4 import java.io.InputStream;
 5
 6 public class Test12 {
 7     public static void main(String[] args) throws IOException {
 8         File f = new File("d:" + File.separator+"test.txt");
 9         InputStream in=new FileInputStream(f);
10         byte[] b=new byte[1024];
11         int len=in.read(b);
12         in.close();
13         System.out.println(new String(b,0,len));
14     }
15 }

但以上方法是有问题的，用不用开辟这么大的一个字节数组，明显是浪费嘛，咱们能够根据文件的大小来定义字节数组的大小，File类中的方法：public long length()

1 import java.io.File;
 2 import java.io.FileInputStream;
 3 import java.io.IOException;
 4 import java.io.InputStream;
 5
 6 public class Test13 {
 7     public static void main(String[] args) throws IOException {
 8         File f = new File("d:" + File.separator+"test.txt");
 9         InputStream in=new FileInputStream(f);
10         byte[] b=new byte[(int) f.length()];
11         in.read(b);
12         in.close();
13         System.out.println(new String(b));
14     }
15 }

 

咱们换种方式，一个字节一个字节读入~

1 import java.io.File;
 2 import java.io.FileInputStream;
 3 import java.io.IOException;
 4 import java.io.InputStream;
 5
 6 public class Test14 {
 7     public static void main(String[] args) throws IOException {
 8         File f = new File("d:" + File.separator+"test.txt");
 9         InputStream in=new FileInputStream(f);
10         byte[] b=new byte[(int) f.length()];
11         for(int i=0;i<b.length;i++){
12             b[i]=(byte) in.read();
13         }
14         in.close();
15         System.out.println(new String(b));
16     }
17 }

但以上状况只适合知道输入文件的大小，不知道的话用以下方法：

1 import java.io.File;
 2 import java.io.FileInputStream;
 3 import java.io.IOException;
 4 import java.io.InputStream;
 5
 6 public class Test15 {
 7     public static void main(String[] args) throws IOException {
 8         File f = new File("d:" + File.separator+"test.txt");
 9         InputStream in=new FileInputStream(f);
10         byte[] b=new byte[1024];
11         int temp=0;
12         int len=0;
13         while((temp=in.read())!=-1){//-1为文件读完的标志
14             b[len]=(byte) temp;
15             len++;
16         }
17         in.close();
18         System.out.println(new String(b,0,len));
19     }
20 }

 

字符流

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


字符输出流：Writer

Writer自己是一个字符流的输出类，此类的定义以下：

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

此类自己也是一个抽象类，若是要使用此类，则确定要使用其子类，此时若是是向文件中写入内容，因此应该使用FileWriter的子类。

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

public FileWriter(File file)throws IOException

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

写文件：

1 import java.io.File;
 2 import java.io.FileWriter;
 3 import java.io.IOException;
 4 import java.io.Writer;
 5
 6 public class Test16 {
 7     public static void main(String[] args) throws IOException {
 8         File f = new File("d:" + File.separator+"test.txt");
 9         Writer out=new FileWriter(f);
10         String str="Hello World";
11         out.write(str);
12         out.close();
13     }
14 }

在默认状况下再次输出会覆盖，追加的方法也是在构造函数上加上追加标记

1 import java.io.File;
 2 import java.io.FileWriter;
 3 import java.io.IOException;
 4 import java.io.Writer;
 5
 6 public class Test17 {
 7     public static void main(String[] args) throws IOException {
 8         File f = new File("d:" + File.separator+"test.txt");
 9         Writer out=new FileWriter(f,true);//追加
10         String str="\r\nHello World";
11         out.write(str);
12         out.close();
13     }
14 }

 

字符输入流：Reader

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

public abstract class Reader extends Objects implements Readable，Closeable

Reader自己也是抽象类，若是如今要从文件中读取内容，则能够直接使用FileReader子类。

FileReader的构造方法定义以下：

public FileReader(File file)throws FileNotFoundException

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

1 import java.io.File;
 2 import java.io.FileReader;
 3 import java.io.IOException;
 4 import java.io.Reader;
 5
 6 public class Test18 {
 7     public static void main(String[] args) throws IOException {
 8         File f = new File("d:" + File.separator+"test.txt");
 9         Reader input=new FileReader(f);
10         char[] c=new char[1024];
11         int len=input.read(c);
12         input.close();
13         System.out.println(new String(c,0,len));
14     }
15 }

也能够用循环方式，判断是否读到底：

1 import java.io.File;
 2 import java.io.FileReader;
 3 import java.io.IOException;
 4 import java.io.Reader;
 5
 6 public class Test19 {
 7     public static void main(String[] args) throws IOException {
 8         File f = new File("d:" + File.separator+"test.txt");
 9         Reader input=new FileReader(f);
10         char[] c=new char[1024];
11         int temp=0;
12         int len=0;
13         while((temp=input.read())!=-1){
14             c[len]=(char) temp;
15             len++;
16         }
17         input.close();
18         System.out.println(new String(c,0,len));
19     }
20 }

 

字节流和字符流使用是很是类似的，那么除了操做代码的不一样以外，还有哪些不一样呢？

字节流在操做的时候自己是不会用到缓冲区（内存）的，是与文件自己直接操做的，而字符流在操做的时候是使用到缓冲区的

字节流在操做文件时，即便不关闭资源（close方法），文件也能输出，可是若是字符流不使用close方法的话，则不会输出任何内容，说明字符流用的是缓冲区，而且可使用flush方法强制进行刷新缓冲区，这时才能在不close的状况下输出内容

 

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

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

 

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

 

参考原文连接：http://www.javashuo.com/article/p-xnwtjmkl-cw.html

　　写博客是为了记住本身容易忘记的东西，另外也是对本身工做的总结，文章能够转载，无需版权。但愿尽本身的努力，作到更好，你们一块儿努力进步！

若是有什么问题，欢迎你们一块儿探讨，代码若有问题，欢迎各位大神指正！

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程