Java中的I/O

1、Java中的I/O分类

I/O分类：

• 输入流，输出流，或者字节流，字符流

I/O中的四个抽象基类：

• InputStream，OutputStream：两者属于字节流，前者输入，后者输出。一般后缀名为这两个的都属于字节流家族。
• Reader，Writer：两者属于字符流，前者输入，后者输出。一般后缀名为这两个的都属于字符流家族。

2、File常用方法

常用方法：

• mkdir()创建一个文件夹，mkdirs()创建一个文件夹以及它的上级文件夹。
• createNewFile()创建一个文件。
• isDirectory()判断文件是否存在以及是否是一个目录，exists()判断文件路径是否存在。
• delete()删除文件或者目录。
• 示例代码如下

package com.spring.test.service;

import java.io.File;
import java.io.IOException;

/**
 * @Author: philosopherZB
 * @Date: 2019/9/29
 */
public class Test {
    public static void main(String[] args){
        //File.separator返回本系统的名称分隔符，方便代码跨系统移植，比如windows下文件分隔符是，而其他系统可能就不是。
        //创建一个文件夹
        String path1 = "D:" + File.separator + "Test";
        File file1 = new File(path1);
        file1.mkdir();

        //创建一个文件夹以及他的上级文件夹
        String path2 = "D:" + File.separator + "Test" + File.separator + "Temp" + File.separator + "demo";
        File file2 = new File(path2);
        file2.mkdirs();

        //创建一个文件
        String path3 = "D:" + File.separator + "Test" + File.separator + "Test.txt";
        File file3 = new File(path3);
        try {
            file3.createNewFile();
        } catch (IOException e) {
            e.printStackTrace();
        }

        //读取文件夹以及文件
        String path4 = "D:" + File.separator  + "Test";  //指定读取目录
        File file4 = new File(path4);
        //判断目录是否存在
        if(file4.isDirectory()){
//            String[] str = file4.list();
//            for(int i=0;i<str.length;i++){
//                File f = new File("D:" + File.separator + "Test" + File.separator + str[i]);
//                if(f.isDirectory()) {
//                    System.out.println(str[i] + "是一个目录");
//                }else{
//                    System.out.println(str[i] + "是一个文件");
//                    f.delete();//删除该文件
//                }
//            }
            //如果需要获取全路径可以使用listFiles，这个方法的返回时File。
            File[] files = file4.listFiles();
            if(files.length!=0) {
               for(File file : files){
                   if(file.isDirectory()) {
                    System.out.println(file + "是一个目录");
                   }else{
                    System.out.println(file + "是一个文件");
                    file.delete();//删除该文件
                  }
               }
            }
        }else{
            System.out.println("目录不存在");
        }
    }
}

3、对文件进行写入，读出

分别使用字符流，字节流写入读出：

• 字节流使用的是：BufferedOutputStream（写入），BufferedInputStream（读出）
• 字符流使用的是：BufferedWriter（写入），BufferedReader（读出）
• 其中字符流是线程安全的（源码中对应的方法加了sychronized），字节流不是线程安全的。
• 其中使用的try-with-resource是一个Java的语法糖，如果是实现了Closeable接口的类，可以免去自己写finally块进行资源关闭的操作
• 示例代码如下：

package com.spring.test.service;

import java.io.*;

/**
 * @Author: philosopherZB
 * @Date: 2019/9/29
 */
public class Test {
    public static void main(String[] args){
        String path = "D:" + File.separator + "Test" + File.separator + "Test.txt";
        String str = "文件测试内容";
        //字节流
        writeFile(path,str);
        System.out.println("字节流：" + readFile(path));
        //字符流
        writeFileByStr(path,str);
        System.out.println("字符流：" + readFileByStr(path));
    }

    //写入字符串到指定文件中----字节流，字节流线程不安全，可以通过synchronized来使其成为一个静态同步方法
    public static synchronized void writeFile(String fileName,String content){
        //此处使用的是try-with-resource，实现了Closeable接口的类，可以免去自己写finally块进行资源关闭的操作，是一个java的语法糖
        try(BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(new File(fileName)))){
            byte[] b = content.getBytes();
            bos.write(b);  //写入
            bos.flush();   //刷新缓存，及时将缓存中的数据刷到文件中
        }catch (IOException e){
            throw new RuntimeException(e.getMessage(), e);
        }
    }

    //从指定文件中读取字符串-----字节流，字节流线程不安全，可以通过synchronized来使其成为一个静态同步方法
    public static synchronized String readFile(String fileName){
        try(BufferedInputStream bis = new BufferedInputStream(new FileInputStream(new File(fileName)))){
            byte[] b = new byte[256];
            int count = 0;
            int temp = 0;
            //不确定文件内容有多大，循环读取
            //读到文件末尾的时候才会返回-1
            while((temp = bis.read()) != -1){
                b[count++] = (byte) temp;
            }
            return new String(b);
        }catch (IOException e){
            throw new RuntimeException(e.getMessage(), e);
        }
    }

    //写入字符串到指定文件中----字符流，字符流的write方法是线程安全的
    public static void writeFileByStr(String fileName,String content){
        try(BufferedWriter bw = new BufferedWriter(new FileWriter(new File(fileName)))){
            bw.write(content);
            bw.flush();
        }catch (IOException e){
            throw new RuntimeException(e.getMessage(), e);
        }
    }

    //从指定文件中读取字符串-----字符流
    public static String readFileByStr(String fileName){
        try(BufferedReader br = new BufferedReader(new FileReader(new File(fileName)))){
            char[] c = new char[256];
            int count = 0;
            int temp = 0;
            //不确定文件内容有多大，循环读取
            //读到文件末尾的时候才会返回-1
            while((temp = br.read()) != -1){
                c[count++] = (char) temp;
            }
            return new String(c);
        }catch (IOException e){
            throw new RuntimeException(e.getMessage(), e);
        }
    }

}

4、BIO，NIO，AIO

BIO（Block IO）：

• 同步阻塞式IO，一般指平常所用的IO类。
• 一个请求对应一个响应，为了合理的利用资源，可以使用多线程（线程池）。
• 此IO一般针对并发量较小的场景（<1000）。
• BIO操作的对象是流（Stream）。
• 比如：在ATM机上取钱，只能一个一个的取，前面有人的时候，需要等待；取钱的时候，需要本人进行相关取钱操作（取出之后拿到钱才走）。

NIO（NewIO）：

• 同步非阻塞式IO。
• 利用Channel（通道）通讯，实现了多路复用。
• 核心组件：Buffer（缓冲区），Channel（通道），Selector（选择器）
• NIO操作的对象是缓存区（Buffer）。
• 基本运行流程：当Channel发生新连接、就绪读，就绪写的时候，首先会在Selector上注册相应的事件，生成一个与Channel绑定的selectKey；其次由一个线程轮询selectKey集合，利用操作系统底层的函数select() 或者 epoll（Linux 2.6之前是select、poll，2.6之后是epoll，Windows是iocp）去操作系统查询IO是否就绪，如果就绪则执行相应的事件处理器（通过selectKey找到Channel，然后利用与Channel绑定的buffer进行实际读写）。
• 比如：在银行大厅取钱，对于前面是否有人等候，只需要隔一段时间去问一下大堂经理是否可以取钱就可以了，不需要一直去排队（这段时间可以做其他事）；取钱的时候，需要柜员进行相关操作，同时也需要保证你也在柜员面前（不能离开，不然柜员可能会找不到你，然后钱就没有实际拿到手里了）。

AIO（Asynchronous IO）：

• 异步非阻塞式IO。
• 其实现是基于事件以及回调机制。
• AIO与NIO有点相似，不过对于实际读写而言，AIO是交给操作系统底层自己去完成的，完成之后会返回一个IO完成的回调消息。
• 比如：同样是去银行取钱，不过这次你是让朋友去帮忙取的，你朋友会帮你排队，然后取钱，接着把钱给你，并告诉你已经取好了。

IO阶段：

• IO中对于读写一般分为两个阶段：就绪读写（准备数据）以及实际读写（真正读写数据）。
  
• 对应上面取钱例子而言，就绪读写指的是排队，实际读写指的是取钱操作。

同步，异步：

• 同步指的是操作的时候，需要等待当前任务返回结果；异步则相反，它不需要等待当前任务返回，通常情况下是依赖于事件，回调机制来实现任务间的次序关系。
• 同步，异步对于IO而言指的是实际读写阶段；对应取钱例子而言，就是真正取钱操作（同步，自己取钱；异步，朋友帮忙取钱）。

阻塞，非阻塞：

• 阻塞指的是如果任务在执行，当前线程会阻塞，需要等待任务执行完，这期间该线程不能执行其他任务；非阻塞则是说在一个任务执行期间，线程不会阻塞，可以执行其他任务。
• 阻塞，非阻塞对于IO而言指的是就绪读写阶段；对应取钱例子而言，就是排队等候（阻塞，排队没带手机，只能干等着；非阻塞，排队带了手机，可以一边玩手机一边排队）。

BIO，NIO，AIO示例代码参考：

• https://blog.csdn.net/anxpp/article/details/51512200
  

（以上所有内容皆为个人笔记，如有错误之处还望指正。）