java 字节流与字符流的区别

港控/mmm° 2022-08-03 12:54 300阅读 0赞

字节流与和字符流的使用非常相似，两者除了操作代码上的不同之外，是否还有其他的不同呢？  
  
实际上字节流在操作时本身不会用到缓冲区（内存），是文件本身直接操作的，而字符流在操作时使用了缓冲区，通过缓冲区再操作文件，如图12-6所示。  
![162655699.jpg][]  
下面以两个写文件的操作为主进行比较，但是在操作时字节流和字符流的操作完成之后都不关闭输出流。  
  
范例：使用字节流不关闭执行

Java代码  ![收藏代码][icon_star.png]

1.  **package** org.lxh.demo12.byteiodemo;    
2.  **import** java.io.File;    
3.  **import** java.io.FileOutputStream;    
4.  **import** java.io.OutputStream;    
5.  **public** **class** OutputStreamDemo05 \{    
6.  **public** **static** **void** main(String\[\] args) **throws** Exception \{   // 异常抛出，  不处理    
7.  // 第1步：使用File类找到一个文件    
8.       File f = **new** File("d:" + File.separator + "test.txt"); // 声明File  对象    
9.  // 第2步：通过子类实例化父类对象    
10.      OutputStream out = **null**;            
11. // 准备好一个输出的对象    
12.      out = **new** FileOutputStream(f);      
13. // 通过对象多态性进行实例化    
14. // 第3步：进行写操作    
15.      String str = "Hello World!!!";      
16. // 准备一个字符串    
17.      **byte** b\[\] = str.getBytes();          
18. // 字符串转byte数组    
19.      out.write(b);                      
20. // 将内容输出    
21.  // 第4步：关闭输出流    
22.     // out.close();                  
23. // 此时没有关闭    
24.         \}    
25.     \}

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

Java代码  ![收藏代码][icon_star.png]

1.  **package** org.lxh.demo12.chariodemo;    
2.  **import** java.io.File;    
3.  **import** java.io.FileWriter;    
4.  **import** java.io.Writer;    
5.  **public** **class** WriterDemo03 \{    
6.      **public** **static** **void** main(String\[\] args) **throws** Exception \{ // 异常抛出，  不处理    
7.          // 第1步：使用File类找到一个文件    
8.          File f = **new** File("d:" + File.separator + "test.txt");// 声明File 对象    
9.          // 第2步：通过子类实例化父类对象    
10.         Writer out = **null**;                 
11. // 准备好一个输出的对象    
12.         out = **new** FileWriter(f);            
13. // 通过对象多态性进行实例化    
14.         // 第3步：进行写操作    
15.         String str = "Hello World!!!";      
16. // 准备一个字符串    
17.         out.write(str);                    
18. // 将内容输出    
19.         // 第4步：关闭输出流    
20.         // out.close();                   
21. // 此时没有关闭    
22.     \}    
23. \}

程序运行结果：  
![162913379.jpg][]  
  
  
  
程序运行后会发现文件中没有任何内容，这是因为字符流操作时使用了缓冲区，而   在关闭字符流时会强制性地将缓冲区中的内容进行输出，但是如果程序没有关闭，则缓冲区中的内容是无法输出的，所以得出结论：字符流使用了缓冲区，而字节流没有使用缓冲区。  
  
提问：什么叫缓冲区？  
  
在很多地方都碰到缓冲区这个名词，那么到底什么是缓冲区？又有什么作用呢？  
  
回答：缓冲区可以简单地理解为一段内存区域。  
  
可以简单地把缓冲区理解为一段特殊的内存。  
  
某些情况下，如果一个程序频繁地操作一个资源（如文件或数据库），则性能会很低，此时为了提升性能，就可以将一部分数据暂时读入到内存的一块区域之中，以后直接从此区域中读取数据即可，因为读取内存速度会比较快，这样可以提升程序的性能。  
  
在字符流的操作中，所有的字符都是在内存中形成的，在输出前会将所有的内容暂时保存在内存之中，所以使用了缓冲区暂存数据。  
  
如果想在不关闭时也可以将字符流的内容全部输出，则可以使用Writer类中的flush()方法完成。  
  
范例：强制性清空缓冲区

Java代码  ![收藏代码][icon_star.png]

1.  **package** org.lxh.demo12.chariodemo;    
2.  **import** java.io.File;    
3.  **import** java.io.FileWriter;    
4.  **import** java.io.Writer;    
5.  **public** **class** WriterDemo04 \{    
6.      **public** **static** **void** main(String\[\] args) **throws** Exception \{ // 异常抛出不处理    
7.          // 第1步：使用File类找到一个文件    
8.          File f = **new** File("d:" + File.separator + "test.txt");// 声明File    
9.  对象    
10.         // 第2步：通过子类实例化父类对象    
11.         Writer out = **null**;                   
12. // 准备好一个输出的对象    
13.         out = **new** FileWriter(f);             
14. // 通过对象多态性进行实例化    
15.         // 第3步：进行写操作    
16.         String str = "Hello World!!!";      
17. // 准备一个字符串    
18.         out.write(str);                    
19. // 将内容输出    
20.         out.flush();                       
21. // 强制性清空缓冲区中的内容    
22.         // 第4步：关闭输出流    
23.         // out.close();                
24. // 此时没有关闭    
25.     \}    
26. \}

程序运行结果：  
![163055734.jpg][]  
此时，文件中已经存在了内容，更进一步证明内容是保存在缓冲区的。这一点在读者日后的开发中要特别引起注意。  
  
提问：使用字节流好还是字符流好？  
  
学习完字节流和字符流的基本操作后，已经大概地明白了操作流程的各个区别，那么在开发中是使用字节流好还是字符流好呢？  
  
回答：使用字节流更好。  
  
在回答之前，先为读者讲解这样的一个概念，所有的文件在硬盘或在传输时都是以字节的方式进行的，包括图片等都是按字节的方式存储的，而字符是只有在内存中才会形成，所以在开发中，字节流使用较为广泛。  
  
  
字节流与字符流主要的区别是他们的的处理方式  
  
流分类：  
1.Java的字节流  
   InputStream是所有字节输入流的祖先，而OutputStream是所有字节输出流的祖先。  
2.Java的字符流  
  Reader是所有读取字符串输入流的祖先，而writer是所有输出字符串的祖先。  
InputStream，OutputStream,Reader,writer都是抽象类。所以不能直接new   
  
  
  
字节流是最基本的，所有的InputStream和OutputStream的子类都是,主要用在处理二进制数据，它是按字节来处理的  
但实际中很多的数据是文本，又提出了字符流的概念，它是按虚拟机的encode来处理，也就是要进行字符集的转化  
这两个之间通过 InputStreamReader,OutputStreamWriter来关联，实际上是通过byte\[\]和String来关联  
在实际开发中出现的汉字问题实际上都是在字符流和字节流之间转化不统一而造成的  
  
在从字节流转化为字符流时，实际上就是byte\[\]转化为String时，  
public String(byte bytes\[\], String charsetName)  
有一个关键的参数字符集编码，通常我们都省略了，那系统就用操作系统的lang  
而在字符流转化为字节流时，实际上是String转化为byte\[\]时，  
byte\[\]    String.getBytes(String charsetName)  
也是一样的道理  
  
至于java.io中还出现了许多其他的流，按主要是为了提高性能和使用方便，  
如BufferedInputStream,PipedInputStream等  
补充两点关于流的读取:

<pre name="code" class="html">1.	FileInputStream fs=new FileInputStream("E:/a.txt");
    	int length=0;
    	byte[] by=new byte[1024];
    	while((length=fs.read(by))>0){
    		System.out.println(new String(by,0,length));
    	}
    	fs.close();
    2.	Reader rd=new FileReader("E:/a.txt");
    	int length=0;
    	char[] c=new char[1024];
    	while((length=fs.read(c))>0){
    		System.out.println(new String(c,0,length));
    	}
    	rd.close();
    3.      try {
                HttpSession session=request.getSession();
                User sessionUser=(User) session.getAttribute("user");
                String uploadBaseDir = configer.imgServerBaseDir;
                String downLoadPath=uploadBaseDir+sessionUser.getRealQrCodeUrl();
                long fileLength = new File(downLoadPath).length();   
                response.setContentType("application/octet-stream;charset=utf-8");   
                response.setHeader("Content-disposition", "attachment; filename=" + new String("qrCode.jpg".getBytes("utf-8"), "ISO8859-1"));   
                response.setHeader("Content-Length", String.valueOf(fileLength)); 
                
                bis = new BufferedInputStream(new FileInputStream(downLoadPath));   
                bos = new BufferedOutputStream(response.getOutputStream());   
                byte[] buff = new byte[2048];   
                int bytesRead;   
                while (-1 != (bytesRead = bis.read(buff, 0, buff.length))) {   
                    bos.write(buff, 0, bytesRead);   
                }
            } catch (Exception e) {
                LOG.error("qrCodeDown.error:"+ e.getMessage());
                return ErrorPages._500;
            }finally{
                if (bis != null){
                    try {
                        bis.close();
                    } catch (IOException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
                if (bos != null){
                    try {
                        bos.close();
                    } catch (IOException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    } 
                }
            }

[162655699.jpg]: /images/20220731/18a2a19c8d1849e29497352611d70a51.png
[icon_star.png]: /images/20220731/c3dc545ab380460e9e2ebb5ce18581e0.png
[162806761.jpg]: /images/20220731/1276b821ac04445995b44f9bede25c74.png
[162913379.jpg]: /images/20220731/03a3762c1f034aba8ef6eb473a7486eb.png
[163055734.jpg]: /images/20220731/cccca224fadf4c8ea2b9510cb6ad08dc.png