尚硅谷_初级_IO流（java_NIO(new IO)）

一：File 类的使用
       1.File 类的理解
          （1）File 类的一个实例化对象，代表 一个文件 或者 一个文件目录（俗称：文件夹）
          （2）File 类声明在 java.io 包下
          （3）File 类中涉及到，关于文件 或者 文件目录 的操作方法，
               比如：创建，删除，重命名，修改时间文件大小 等方法。
               并未涉及到 写入或者读取文件内容的操作，如果涉及到 文件中的内容，则需要使用 IO 流处理
          （4）File 类的实例化对象，经常作为参数，传入到流的构造其中。
          （5）什么是 比特（Bit），什么是 字节（Byte），什么是字符（char）
               1.Bit 是最小的 二进制单位，是计算机的操作部分，取值 0/1
               2.Byte 是计算机 操作数据的 最小单位，由 8位 Bit 组成，取值（-128 ~ 127） 
               3.Char 使用户的可读写的 最小单位，在 java 里面，由 16 位 Bit 组成，取值（0 ~ 65535） 
           (7)BIO,NIO,AIO
               1.BIO：Block Io： 同步阻塞式IO，就是我们平时使用的传统 IO ，它的特点就是：模式简单，使用方便，并发处理能力低。
               2.NIO：New Io  ： 同步非阻塞IO，是传统 IO 的升级，客户端 服务端 通过 Channel（通道）进行通讯，实现了多路复用。
               3.AIO：AsynChroNous IO :是 NIO 的升级，也叫 NIO2 ，实现了 异步非阻塞 IO，异步IO的操作基于事件和回调机制。

      2.File 实例化
          （1）常用构造器
                 File("D:\\1.txt")
                 封装一个 磁盘路径 的字符串。
                    可以是文件，
                    可以使文件夹，
                    也可以不存在。
          （2）路径的分类
              路径：
                  相对路径：相较于某个 路径下 指明的 路径
                     File file1 = new File("D:"+File.separator+"1.txt");
                  绝对路径：包含磁盘在内的 文件 或者文件夹
                     File file2 = new File("1.txt");
              idea说明：
                如果使用 Junit 测试，相对路径为当前module
                如果使用 main 进行测试，相对路径为 project
              eclipse说明：
                不管使用单元测试还是main测试
                相对路径都是，当前的 project。
          （3）路径分隔符
                 路径分隔符：
                    window：\\
                    unix:/
                 为了解决这个问题：
                    File 类提供了 常量 File.separator。根据操作系统，动态的解决这个问题
                    例：File file1 = new File("D:"+File.separator+"1.txt");
          （4）File类的常用方法
             1.查询：
                File absoluteFile = file2.getAbsoluteFile();//获取文件绝对路径
                String path = file1.getPath(); //获取文件路径
                String name = file1.getName(); //获取名称
                String parent = file2.getParent();//获取上级目录
                long length = file2.length();  //获取文件长度（文件字节数，文件大小）
                long l = file2.lastModified(); //获取文件最后修改时间
                String[] list = file.list();   //查询 File 路径下 所有的文件或者文件夹，["a.txt", "b.jpg", "abc"]
                File[] files = file.listFiles();//查询 File 路径下 所有的文件或者文件夹 的全路径
             2.判断：
                boolean file = file2.isFile();------//判断是否为文件
                boolean directory = file2.isDirectory();//判断是否为文件夹
                boolean exists = file2.exists();----//判断文件是否存在
                boolean b = file2.canRead();--------//判断是否可读
                boolean b1 = file2.canWrite();------//判断是否可写
                boolean hidden = file2.isHidden();--//判断是否隐藏
             3.创建删除功能：
                boolean newFile = file2.createNewFile();//创建文件
                boolean mkdir = file2.mkdir(); //创建目录
                boolean mkdirs = file2.mkdirs();//创建多级目录
                boolean delete = file.delete();    //根据 File 路径删除 文件 或者 文件夹
二：IO 流的原理 及 流的分类
       1.java IO 原理
          （1）输入输出：（都是相对于程序而言）（读进来，写出去）
                 1.输入（input）：读取外部数据到内存中
                 2.输出（output）：内存中数据写到外面
          （2）流的分类：
             1.按照 操作数据的基本单位 不同：
                        字节流                    字符流
                 (抽象基类)        (8 bit)(非文本数据)                  (16 bit)(文本数据)
                 输入流：        InputStream (byte[])                  Reader (char[])
                 输出流：         OutputStream                        Writer
                 对应的节点流：    FileInputStream(read(byte[] b))       FileReader(read(char[] c))
                 （或文件流） FileOutputStream(write(byte[] b,0,len))    FileWriter(write(char[] c,0,len))
                 对应的处理流：    BufferInputStream(和节点流一样)        BufferReader
                 （处理流一种）    bufferOutputStream                    BufferWriter
             2.按 数据的流向分类
                 输入流：
                 输出流：
             3.按 流的角色分类
                 节点流：直接作用在文件上
                 处理流：包在 节点流 外面的流，包了一层
             4.IO 流体系图片
                 分清 字节流，字符流（字节流为Stream，字符流为 Reader）
                 分清 输入流，输出流（input 为输入，output 为输出）
                 分清 节点流，处理流（访问文件为节点流，以下其他都为处理流）
                 蓝色的为常用的
          （3）使用io流，读取文件内容
                 1.read()的理解：返回读取的一个字符。返回读到的char。如果读到文件末尾，则返回-1
                   read(char[] c):一下读取一个 char 数组长度，返回读取的长度。
                 2.异常的处理：   为了保证流资源一定可以执行关闭操作，需要使用 try-catch-finally 进行异常处理
                 3.读入的文件一定要存在，否则就会报 FileNotFoundException。
                 4.操作代码:
                FileReader fileReader = null;
                try {
                    //相对于当前module
                    File file = new File("d:" + File.separator + "ddd" + File.separator + "4.txt");
                    /*读取 文件 内容到 控制台* /
                    fileReader = new FileReader(file);
                    int read = 0;
                    while ((read = fileReader.read()) != -1) {
                        System.out.print((char) read);
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                } finally {
                     try {
                         //保证流不为空
                         if (fileReader != null) {
                             fileReader.close();
                         }
                    } catch (IOException e) {
                         e.printStackTrace();
                    }
                }
                 5.使用 read(char[] aa)
                     char[] chars = new char[3];
                     int read;
                     while ((read = fileReader.read(chars)) != -1) {
                          // for (int i = 0; i < read; i++) {
                         //    System.out.print(chars[i]);
                         // }
                         String s = new String(chars);
                         System.out.print(s);
                     }
          （4）使用io流，往文本里写数据
          （5）使用io流，实现图片或者视频的复制
       2.缓冲流：
          （1）缓冲流：
                 为处理流的一种，主要作用，就是为了提高文件的读写效率。
          （2）只是在 FileInputStream 外面的基础上，多套了一层处理流 BufferedInputStream，
                 还是使用 byte[] 数组存数据，
          （3）先关闭外面流，在关闭里面流。但是关闭外层流的同时，内层流会自动被关闭。
          （4）BufferOutputStream 有 flush() 方法，是清空缓冲区。
          （5）使用缓冲流，复制图片。flush(),
                 使用缓冲流，赋值文本。readLine(),newLine()。
       3.转换流：
          （1）转换流，提供了在 字节流 和 字符流 之间的转换。
          （2）转换流，属于字符流：
                 1.InputStreamReader：将一个 字节的 输入流，转换为 字符的 输入流。
                 2.OutputStreamWriter：将一个 字符的 输出流，转换为 字节的 输出流。
          （3）作用：
                 可以 用 字节流，读取文本数据，转换成 字符流 在控制台展示，
                    再将 字符流 转换为 字节流，写到文本中。
                 也可以进行 ，文本编码集的转换。
          （4）方法：
                 同样是使用，read() 方法读取，创建转换流时候，可以指定编码。
       4.对象流：
          （1）对象流作用：
                 用于存储和读取，基本数据类型数据，或者 对象的处理流。他的强大之处，就是可以把，Java中的
                 对象，写入到数据源中，也能把 对象 从数据源中还原回来。
          （2）ObjectInputStream 和 ObjectOutputStream
          （3）使用场景：
                 序列化：用 ObjectOutputStream 类 保存基本类型数据 或者 对象 的机制
                反序列化：用 ObjectInputStream 类 读取基本类型数据 或者 对象 的机制
                 注意：  
                      1.不能序列化 static 和 transient 修饰的成员变量。
                      2.对象是可序列化的，实现 Serializable 接口
                      3.写序列化版本号：public static final long serialVersionUID = 213123123L;
                      4.除了实现 接口之外，还要保证，类里面属性，都要是可序列化的，
                         （默认情况下，基本数据类型，都可以序列化）
          （4）代码：
               User user = new User("张三", 18);
               File file = new File("d:" + File.separator + "ddd" + File.separator + "4.txt");
               FileOutputStream fileOutputStream = new FileOutputStream(file);
               ObjectOutputStream objectOutputStream = new ObjectOutputStream(fileOutputStream);
               objectOutputStream.writeObject(user);（ readObject() ）
               objectOutputStream.close();
          （5）serialVersionUID：
                 详情见（3）
       5.随机存储文件流：（可以存，可以取）
          （1）RandomAccessFile 类的使用
                 1.RandomAccessFile 直接继承于 java.lang.Object 类，实现了 DataInput 和 DataOutput 接口
                 2.RandomAccessFile 既可以作为一个输入流，又可以作为一个输出流。
          （2）代码：
                 File file = new File("d:"+File.separator+"ddd"+File.separator+"4.txt");
                 RandomAccessFile randomAccessFile = new RandomAccessFile(file,"rw");
                 randomAccessFile.writeBytes("aaaaaaaaaaaaaaaaaaa");
                 randomAccessFile.close();
          （3）可以移动指针，到指定位置读写：
                    randomAccessFile.seek("3");
          （3）作为输出流时：写出到文件，对原有文件内容，进行覆盖，默认从头覆盖，类似于 insert 方式。
          （4）作为输出流时：写出到文件，实现插入，可以使用 seek(long l) 方法。先调动插入指针，后插入
       6.标准的输入输出流：（了解）
          （1）标准的输入流：
              System.in：默认从键盘输入
          （2）标准的输出流：
              System.out：默认从控制台输出
       7.打印流：（了解）
          （1）printStream 和 printWriter
          （2）println()：点进去，就是打印流中的方法。
          （3）提供了一系列 重载的 print() 和 println()
       8.数据流：（了解）
          （1）DataInputStream 和 DataOutputStream
          （2）作用：用于 读取 或者 写出 基本数据类型的变量或者字符串。
               读取：int ，boolean，等基本类型。
               需要按照，写入顺序读取。
三：java_NIO 概述
       1.传统的IO流是阻塞式的，会一直监听一个ServerSocket，在调用read等方法时，他会一直等到数        
            据到来或者缓冲区已满时才返回。
         调用accept也是一直阻塞到有客户端连接才会返回。每个客户端连接过来后，服务端都会启动一个线 
            程去处理该客户端的请求。
         并且多线程处理多个连接。每个线程拥有自己的栈空间并且占用一些 CPU 时间。每个线程遇到外部 
            未准备好的时候，都会阻塞掉。阻塞的结果就是会带来大量的进程上下文切换。
         对于NIO，它是非阻塞式，核心类：
              1）.Buffer为所有的原始类型提供 (Buffer)缓存支持。
              2）.Charset字符集编码解码解决方案
              3）.Channel一个新的原始 I/O抽象，用于读写Buffer类型，通道可以认为是一种连接，可以 
                 是到特定设备，程序或者是网络的连接。
       1.因为 传统 IO 的效率低，java推出 NIO，以更加高效的方式，进行对文件的读写操作。
       2.随着 JDK7 的发布，java 对 NIO 有了极大的扩展，增强对文件处理和文件系统特性的支持，以至于称他们为 NIO2。
       3. NIO2 中，对于 Path，Paths，Files 类的使用。
       4.实际开发中，多使用 commons.io 包，第三方的jar包，
          去执行 io 流 操作。都给封装好了。