IO体系之详解BIO

https://blog.youkuaiyun.com/u012250875/article/details/78341874原博链接
体系图（截不全，就分了两次截，不要见怪，可以看原博）

BIO体系中的类该怎么使用？

1、什么时候该用输入流，什么时候用输出流？

读的时候用输入流(xxxInputStream/xxxReader)；写的时候用输出流(xxxOutputStream/xxxWriter）。

2、什么时候该用字节流，什么时候用字符流？

处理纯文本数据时用字符流（xxxReader/xxxWriter），处理非纯文本数据时使用字节流（xxxStream）。
最后，其实不管是什么类型的数据都可以用字节流，包括纯文本，但会增加一些额外的工作量，所以还是按原则选择最合适的流来处理。

3、什么时候使用节点流，什么时候用包装（处理）流？

不管你用什么包装流，都需要先使用节点流获取对应节点的数据流，然后根据具体需求来选择相应的包装流来对节点流进行包装修饰，从而获取相应的功能。

4、什么时候使用普通流，什么时候使用缓冲流？

一般如果对数据流不做加工处理，只是单纯的读写，使用普通流就可以了。如果数据转移（拷贝，上传、下载），则需要使用缓冲流来提高性能，当然你也可以使用buff数组来提高读写效率。

---

判断操作的物理节点：

内存：ByteArrayXXX
硬盘：FileXXX
键盘（输入设备）：System.in
显示器（输出设备）：System.out

判断是否需增加特殊功能：

如需要用缓冲提高读写效率则使用BufferedXXX，如果需要获取文本行号，则使用LineNumberXXX，如果需要转换刘则使用InputStreamReader和OutputStreamWriter，如果需要写入和读取对象则使用ObjectOutputStream和ObjectInputStream。

关于流读写性能问题

流的读写是比较耗时的操作，因此为了提高性能，便有了缓冲的这个概念。 （什么是缓冲？假如你是个搬砖工，你工头让你把1000块砖从A点运到B点，你可以一次拿一块砖从A点运到B点放下砖，这样你要来回跑1000次，大多数的时间开销在路上了；你还可以使用一辆小车，在A点装满一车的砖，然后运到B点放下砖，如果一车最多可以装500块，那么你来回两次便可以把这些砖运完。这里的小车便是那个缓冲）
在java BIO中使用缓冲一般有两种方式。一种是自己申明一个缓冲数组，利用这个数组提高读写效率；另一种方式是使用jdk提供的处理流BufferedXXX类。

示例

/***
* 拷贝文件（方法一），无缓冲读写文件
* @param src 被拷贝的文件
* @param dest 拷贝到的目的地
*/
public static void copyByFileStream(File src, File dest){
FileInputStream fis = null;
FileOutputStream fos = null;
long start = System.currentTimeMillis();
try{
fis = new FileInputStream(src);
fos = new FileOutputStream(dest);
int b = 0;
while((b = fis.read())!=-1){//一个字节一个字节的读
fos.write(b);//一个字节一个字节的写
}


}catch (Exception e){
e.printStackTrace();
}finally {
close(fis,fos);
}
System.out.println("1、使用FileOutputStream拷贝大小为"+getFileSize(src)+"的文件未使用缓冲数组耗时："+(System.currentTimeMillis()-start)+"毫秒");

}

/***
* 拷贝文件（方式2），自定义数组做缓冲读写文件
* @param src 被拷贝的文件
* @param dest 拷贝到的目的地
* @param size 缓冲数组大小
*/
public static void copyByFiileStream2(File src,File dest,int size){
FileInputStream fis = null;
FileOutputStream fos = null;
long start = System.currentTimeMillis();
try{
fis = new FileInputStream(src);
fos = new FileOutputStream(dest);
int b = 0;
byte[] buff = new byte[size];
while((b = fis.read(buff))!=-1){//read()返回读了多少个数据，数据放入数组中
fos.write(buff,0,b);
}
}catch (Exception e){
e.printStackTrace();
}finally {
close(fis,fos);
}
System.out.println("2、使用FileOutputStream拷贝大小"+getFileSize(src)+"的文件使用了自定义缓冲数组大小为"+size+"耗时："+(System.currentTimeMillis()-start)+"毫秒，生成的目标文件大小为"+getFileSize(dest));
}

/***
* 拷贝文件（方式3），使用BufferedXXX类使用默认大小缓冲来读写文件
* @param src 被拷贝的文件
* @param dest 拷贝到的目的地
*/
public static void copyByBufferedStream(File src,File dest){
BufferedInputStream bis = null;
BufferedOutputStream bos = null;
long start = System.currentTimeMillis();
try {
/**
* 我们先来查看一下默认缓冲数组的大小，可以通过bos.buf.length获取，
* 但是呢，buf变量是protected修饰的，不能直接获取，所以我们可以自定义一个类MyBufferedOutputStream继承自BufferedOutputStream。
* 然后在子类中写一个获取父类的buf.length的方法，这样我们就可以查看到默认缓冲数组的大小啦。
* 其实也可以直接从下面源码中直接看到，嘿嘿嘿，好傻：
* public BufferedOutputStream(OutputStream out) {
* this(out, 8192);
* }
*/
MyBufferedOutputStream mbos = new MyBufferedOutputStream(new FileOutputStream(dest));
System.out.println("BufferedOutputStream默认缓冲数组大小："+mbos.getBufSize()+"字节");

/**===========正文============*/
bis = new BufferedInputStream(new FileInputStream(src));
bos = new BufferedOutputStream(new FileOutputStream(dest));

int b = 0;
while((b = bis.read())!=-1){
bos.write(b);
//使用BufferedXXX重写的write方法进行写入数据，该方法看似未缓冲实际做了缓冲处理，可以查看源码验证
/**
* 部分源码
* public class BufferedOutputStream extends FilterOutputStream {
* protected byte buf[];
*
* public BufferedOutputStream(OutputStream out) {
* this(out, 8192);
* }
*
* public BufferedOutputStream(OutputStream out, int size){
* super(out);
* if (size <= 0) {
* throw new IllegalArgumentException("Buffer size <= 0");
* }
* buf = new byte[size];
* }
*
* public synchronized void write ( int b) throws IOException {
* if (count >= buf.length) {
* flushBuffer();
* }
* buf[count++] = (byte) b;
* }
* private void flushBuffer() throws IOException {
* if (count > 0) {
* out.write(buf, 0, count);
* count = 0;
* }
* }
* }
* 从上面源码中可以看出，构造实例时就创建了一个大小为8192字节的缓冲数组，
* 当我们调用write(int b)方法时并没有直接写入，而是写入到缓冲数组buf中，
* 只有当count>=buf.length时，也就是达到8192个字节时，才会调用flushBuffer将缓冲区的数据写入。
* */
}
bos.flush();
/**flush方法和close方法对比*/
/**
* flush：刷新缓冲区，流对象可以继续使用。
* close：刷新缓冲区，然后通知系统释放资源，流对象不能再使用。
*/
/**
* 在这个示例中，结合源码，即缓冲区数据填满的时候（达到8192字节）才会调用源码中的flushBuffer()方法
* 将缓冲区数据进行写入，也就是说如果缓冲区数据未满则将不会写入，这时需要我们人为的调用flush()方法
* 将未满的缓冲区数据进行写入。
* 如这个文件有9000个字节，在达到8192个字节时会自动写入一次数据，而剩下的808个字节数据需要手动调用
* flush()方法写入，否则可能会造成部分数据丢失。
* 为什么说是可能呢？
* 因为调用close()方法后会自动调用flush（）方法
*/
} catch (IOException e) {
e.printStackTrace();
}finally {
close(bis,bos);
}
System.out.println("3、使用BufferedXXXStream拷贝大小"+getFileSize(src)+"的文件使用默认缓冲大小8192字节耗时："+(System.currentTimeMillis()-start)+"毫秒");

}

/***
* 拷贝文件（方式四），使用BufferedXXX类自定义大小缓冲来读写文件
* @param src 被拷贝的文件
* @param dest 拷贝到的目的地
* @param size 自定义缓冲区大小
*/
public static void copyByBufferedStream2(File src,File dest,int size){
BufferedInputStream bis = null;
BufferedOutputStream bos = null;
long start = System.currentTimeMillis();
try {
bis = new BufferedInputStream(new FileInputStream(src));
bos = new BufferedOutputStream(new FileOutputStream(dest));
int b = 0;
byte[] buff = new byte[size];
while((b = bis.read(buff))!=-1){
bos.write(buff,0,b);//使用BufferedXXX重写的write方法进行写入数据
}
bos.flush();

} catch (IOException e) {
e.printStackTrace();
}finally {
close(bis,bos);
}
System.out.println("4、使用BufferedXXXStream拷贝大小"+getFileSize(src)+"的文件自定义缓冲大小为"+size+"字节耗时："+(System.currentTimeMillis()-start)+"毫秒");

}

public static void close(Closeable...closeables){
for(Closeable c :closeables){
try {
if(c!=null){
c.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}

public static String getFileSize(File file){
long size = file.length();
if(size<1024){
return String.valueOf(size)+"B";
}else{
size = size/1024;
// if(size<1024){
return String.valueOf(size)+"KB";
// }
// else{
// size = size/1024;
// return String.valueOf(size)+"MB";
// }
}
}

public static void sleep(long time){
try {
Thread.sleep(time);
} catch (InterruptedException e) {
e.printStackTrace();
}
}

public static void main(String[] args){
File src = new File("F:/img/mmt.jpg");
File dest = new File("F:img/mmt_cogy.jpg");
if(!dest.exists()){
try {
dest.createNewFile();
} catch (IOException e) {
e.printStackTrace();
}
}
//1、无缓冲区拷贝文件
copyByFileStream(src,dest);
sleep(1000);
//2、32字节缓冲区
copyByFiileStream2(src,dest,32);//可以通过fis.available()方法观察到每次移动多少个字节
sleep(1000);
//3、64字节缓冲区
copyByFiileStream2(src,dest,64);
sleep(1000);
//4、使用BufferedXXXStream使用默认缓冲大小（8192字节）
copyByBufferedStream(src,dest);
sleep(1000);
//5、使用BufferedXXXStream使用自定义缓冲大小
copyByBufferedStream2(src,dest,8192*2);
}

执行结果

判断文件是否读写完毕

一般来说可以根据read方法返回的值，如果返回了-1表示没有可读取的字节了。
另一种是使用available()方法查看还有多少可供读取的，当输入流没读一个字节，available()返回的值就会 -1，这种模式很像游标的模式。但要注意的是available的适用场景是非阻塞读取，如本地文件读取，如果是网络io使用该方法，可能拿到的值不对。
总的来说，一般输入流提供的读取方法是可以获取文件是否结束的标志的，比如流默认的read方法，根据返回值是否非负，比如PrintReader和BufferedReader的readLine()方法，根据返回数据是否非空。

关于网络流中使用available()方法的问题

当你在网络io中，比如你用socket变成时获取到的流进行读写时，会发现使用available方法有问题，这是因为网络io的特点：
1、非实时性。你调用available()方法判断剩余流的大小时，远端数据可能还未发送，或者要发送的数据处于队列中，因此通过available()拿到的可用长度可能是0。
2、非连续性。由于网络数据传输中，一般会分段多次发送，available()仅仅能返回本次的可用长度。
鉴于以上两个特点，使用available()判断网络io还有多少数据可读是不合适的，因此解决该问题一般采用自定义协议，比如文件大小、文件名等信息放入流的头几个字节中，接收方根据收到的头信息来解析出传送的文件大小，根据大小来判断还剩多少字节需要读取，是否读取完毕。

关于关闭流的问题

1）为什么需要手动关闭？
参见“有gc为什么需要手动释放资源问题”篇链接：

2）关闭流的正确写法

不规范示例

	/**
     * 案例一
     */
    public static void main(String[] args) {
        try {
            FileInputStream fis = new FileInputStream(new File("E:\\iotest\\1.bmp"));
            FileOutputStream fos = new FileOutputStream(new File("E:\\iotest\\1_copy.bmp"));
            //其他代码
            //......
            fos.close();
            fis.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

/**
 * 案例二
 */
public static void main(String[] args) {
    FileInputStream fis = null;
    FileOutputStream fos = null;
    try {
        fis = new FileInputStream(new File("E:\\iotest\\1.bmp"));
        fos = new FileOutputStream(new File("E:\\iotest\\1_copy.bmp"));
        //其他代码
        //......
    } catch (IOException e) {
        e.printStackTrace();
    } finally{
        try {
            if(fos!=null){
                fos.close();    
            }
            if(fis!=null){
                fis.close();    
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

案例一写法不规范的原因是fis和fos对象执行一些方法时是可能发生异常的，一旦出现异常，虽然进行了try catch操作，但也是因为异常出现时直接进入了catch中，导致跳过了流的关闭操作。
案例二写法不规范的原因是，虽然讲close操作放入了finally中，但是一旦fos.close执行出现异常，则导致fis无法正常关闭。
所以修改方法是在finally块中，对每个close都单独try catch。（已写在上面的操作io流示例代码中）

5、java io流到底能干什么？

主要做两类事情：
    1）数据传输，例如：文件上传，下载，文件拷贝拷贝等。
    2）数据处理：，例如：文本内容加密，图片处理，文件压缩，音视频处理等。

6、实践一下

6.1文本加密
因为我们通过java io流处理可以获得文本的原始数据，我们在数据上进行加工就可以加密文本，通过相反的方式就可以解密文本，实际生产中当然不会像下面这么简单的加密，下面我们只是做个示意

我试了一个案例，没成功，明明我也是按照原博主那样写的，但是不行，，，哈哈哈哈哈，那就先算了。