InputStream.read

1个字节 8位

read方法做的事情：把8个二进制的字节，读成1位的十进制数（0-255）

一般这样做

byte[] buffer = new byte[2048];
int len;
while ((len = inputStream.read(buffer)) != -1) {//buffer数组作为一个缓冲区，把输入流中的东西写入缓冲区
    fileOutputStream.write(buffer, 0, len);
}

虽然我们指定了byte的大小为2048B

但是我们读取依然是以一个字节为单位读取的

对于汉字占用的字节往往大于1

所以read汉字的时候就会进行一个割裂

所以需要指定为GBK、UTF-8就可以解决（他们规定一个汉字占多个字节）

回到上面那个代码例子，错误版本是这样的：

1. import java.io.*;  
2. public class FileOutputStreamTest{  
3.     public static void main(String[] args) throws IOException{  
4.         try{  
5.             FileInputStream fis = new FileInputStream("Test.txt");  
6.             byte[] bbuf = new byte[5];  
7.             int hasRead=0;  
8.             FileOutputStream fos = new FileOutputStream("result.txt");  
9.             while ((fis.read(bbuf)) != -1){  
10.                 fos.write(bbuf);  
11.             }  
12.         }     
13.         catch(IOException e){  
14.             e.printStackTrace();  
15.         }  
16.     }  
17. }  

测试文件Test.txt数据为： abcdef

运行结果result.txt数据为：abcdefbcde

所以需要讲一下原理：比如一串输入流

缓冲区的大小是5B，每次就会读5B，进行一个fis.read(bbuf)，所以abcde就读到byte数组里去了，然后write把byte数组里的东西写到输出流里了

同时输入流中有一个偏移，记录下读取到哪个地方了

有了这个偏移，第二次就是从f开始读了，原来数组里存储的是abcded，现在被更新成fbcde了

有了这个思路，优化起来就简单了

1. import java.io.*;  
2. public class FileOutputStreamTest{  
3.     public static void main(String[] args) throws IOException{  
4.         try{  
5.             FileInputStream fis = new FileInputStream("Test.txt");  
6.             byte[] bbuf = new byte[5];  
7.             int hasRead=0;  
8.             FileOutputStream fos = new FileOutputStream("result.txt");  
9.             while ((hasRead = fis.read(bbuf)) != -1){  
10.                 fos.write(bbuf,0,hasRead);  
11.             }  
12.         }     
13.         catch(IOException e){  
14.             e.printStackTrace();  
15.         }  
16.     }  
17. }  

read的返回值也不用我们说了，本次从输入流中读取的长度