IO流（IO|NIO|NIO2）

IO是Java中处理文件数据的类，为我们进行文件数据交互提供途径。首先了解最初实现交互的底层代码，再了解后来发展更新的新设计类和外部实现。
1.了解文件类（java.io.File类： ）

• 文件和文件目录路径的抽象表示形式，与平台无关
  File 能新建、删除、重命名文件和目录，但 File 不能访问文件内容本身。如果需要访问文件内容本身，则需要使用输入/输出流。
  想要在Java程序中表示一个真实存在的文件或目录，那么必须有一个File对象，但是Java程序中的一个File对象，可能没有一个真实存在的文件或目录。
  File对象可以作为参数传递给流的构造器
  路径分隔符和系统有关：windows和DOS系统默认使用“\”来表示，UNIX和URL使用“/”来表示Java程序支持跨平台运行，因此路径分隔符要慎用。为了解决这个隐患， File类提供了一个常量：public static final String separator。根据操作系统，动态的提供分隔符。

构造方法

• public File(String pathname)
  以pathname为路径创建File对象，可以是绝对路径或者相对路径，如果pathname是相对路径，则默认的当前路径在系统属性user.dir中存储。
  public File(String parent,String child)
  以parent为父路径， child为子路径创建File对象。
  public File(File parent,String child)
  根据一个父File对象和子文件路径创建File对象

常用方法

• File类的获取功能
  public String getAbsolutePath()： 获取绝对路径
  public String getPath() ： 获取路径
  public String getName() ： 获取名称
  public String getParent()： 获取上层文件目录路径。 若无， 返回null
  public long length() ： 获取文件长度（即：字节数） 。 不能获取目录的长度。
  public long lastModified() ： 获取最后一次的修改时间， 毫秒值
  public String[] list() ： 获取指定目录下的所有文件或者文件目录的名称数组
  public File[] listFiles() ： 获取指定目录下的所有文件或者文件目录的File数组
  File类的重命名功能
  public boolean renameTo(File dest):把文件重命名为指定的文件路径
  File类的判断功能
  public boolean isDirectory()： 判断是否是文件目录
  public boolean isFile() ： 判断是否是文件
  public boolean exists() ： 判断是否存在
  public boolean canRead() ： 判断是否可读
  public boolean canWrite() ： 判断是否可写
  public boolean isHidden() ： 判断是否隐藏
  File类的创建功能
  public boolean createNewFile() ： 创建文件。 若文件存在， 则不创建， 返回false
  public boolean mkdir() ： 创建文件目录。 如果此文件目录存在， 就不创建了。如果此文件目录的上层目录不存在， 也不创建。
  public boolean mkdirs() ： 创建文件目录。 如果上层文件目录不存在， 一并创建
  注意事项：如果你创建文件或者文件目录没有写盘符路径， 那么， 默认在项目路径下。
  File类的删除功能
  public boolean delete()： 删除文件或者文件夹
  删除注意事项：Java中的删除不走回收站。要删除一个文件目录， 请注意该文件目录内不能包含文件或者文件目录

底层交互设计API——IO：

第1行属于基类，第2-4属于节点流，第5-10属于处理流。第1.3列属于字节流，第2.4列属于字符流。
节点流：直接从数据源或目的地读写数据
处理流：不直接连接到数据源或目的地，而是“连接” 在已存在的流（节点流或处理流）之上，通过对数据的处理为程序提供更为强大的读写功能。
字节流操作字节，比如： .mp3， .avi， .rmvb， mp4， .jpg， .doc， .ppt
字符流操作字符，只能操作普通文本文件。 最常见的文本文件： .txt， .java， .c， .cpp 等语言的源代码。尤其注意.doc,excel,ppt这些不是文本文件。

所有的流都包含基本的操作方法：

• close();

InputStream/Reader：

• int read();
  int read(byte/char[] b);
  int read(byte/char[] b, int off, int len);

OutputStream/Writer：

• int write();
  int write(byte/char[] b);
  int write(byte/char[] b, int off, int len);
  flush();

此位置转底层练习代码：底层IO使用练习

2.IO API——NIO：

Java NIO 概述

Java NIO (New IO， Non-Blocking IO)是从Java 1.4版本开始引入的一套新的IO API，可以替代标准的Java IO API。 NIO与原来的IO有同样的作用和目的，但是使用的方式完全不同， NIO支持面向缓冲区的(IO是面向流的)、基于通道的IO操作。 NIO将以更加高效的方式进行文件的读写操作。
Java API中提供了两套NIO， 一套是针对标准输入输出NIO， 另一套就是网络编程NIO。
|-----java.nio.channels.Channel
|-----FileChannel:处理本地文件
|-----SocketChannel： TCP网络编程的客户端的Channel
|-----ServerSocketChannel:TCP网络编程的服务器端的Channel
|-----DatagramChannel： UDP网络编程中发送端和接收端的Channel

NIO主要是面向缓冲区的IO，Java NIO系统的核心在于：通道(Channel)和缓冲区(Buffer)。通道表示打开到 IO 设备(例如：文件、套接字)的连接。若需要使用 NIO 系统，需要获取用于连接 IO 设备的通道以及用于容纳数据的缓冲区。然后操作缓冲区，对数据进行处理。简而言之，Channel 负责传输， Buffer 负责存储。
相比于IO，NIO不需要我们自己定义数组将文件数据读入，他自己提供缓冲数组用来存储更加多样化的数据类型。

Buffer

就像一个数组，可以保存多个相同类型的数据。根据数据类型不同(boolean 除外)
缓冲区的基本属性：
容量 (capacity)：表示 Buffer 最大数据容量，缓冲区容量不能为负，并且创建后不能更改。
限制 (limit)：第一个不应该读取或写入的数据的索引，即位于 limit 后的数据不可读写。缓冲区的限制不能为负，并且不能大于其容量。
位置 (position)：下一个要读取或写入的数据的索引。缓冲区的位置不能为负，并且不能大于其限制
标记 (mark)与重置 (reset)：标记是一个索引，通过 Buffer 中的 mark() 方法指定 Buffer 中一个特定的 position，之后可以通过调用 reset() 方法恢复到这个 position.
标记、位置、限制、容量遵守以下不变式： 0 <= mark <= position <= limit <= capacity

Buffer常用方法：

缓冲区的数据操作：
Buffer 所有子类提供了两个用于数据操作的方法：get()与 put() 方法
获取 Buffer 中的数据
get() ：读取单个字节
get(byte[] dst)：批量读取多个字节到 dst 中
get(int index)：读取指定索引位置的字节(不会移动 position)
放入数据到 Buffer 中
put(byte b)：将给定单个字节写入缓冲区的当前位置
put(byte[] src)：将 src 中的字节写入缓冲区的当前位置
put(int index, byte b)：将指定字节写入缓冲区的索引位置(不会移动 position)

Channel

由 java.nio.channels 包定义的。Channel 表示 IO 源与目标打开的连接。Channel 类似于传统的“流”。只不过 Channel本身不能直接访问数据，Channel 只能与Buffer 进行交互。

@Test
    public void test1(){//10874-10953
       long start = System.currentTimeMillis();
       
       FileInputStream fis = null;
       FileOutputStream fos = null;
       //①获取通道
       FileChannel inChannel = null;
       FileChannel outChannel = null;
       try {
         fis = new FileInputStream("d:/1.mkv");
         fos = new FileOutputStream("d:/2.mkv");
         
         inChannel = fis.getChannel();
         outChannel = fos.getChannel();
         
         //②分配指定大小的缓冲区
         ByteBuffer buf = ByteBuffer.allocate(1024);
         
         //③将通道中的数据存入缓冲区中
         while(inChannel.read(buf) != -1){
            buf.flip(); //切换读取数据的模式
            //④将缓冲区中的数据写入通道中
            outChannel.write(buf);
            buf.clear(); //清空缓冲区
         }
       } catch (IOException e) {
         e.printStackTrace();
       } finally {
         if(outChannel != null){
            try {
              outChannel.close();
            } catch (IOException e) {
              e.printStackTrace();
            }
         }
         if(inChannel != null){
            try {
              inChannel.close();
            } catch (IOException e) {
              e.printStackTrace();
            }
         }
         if(fos != null){
            try {
              fos.close();
            } catch (IOException e) {
              e.printStackTrace();
            }
         }
         if(fis != null){
            try {
              fis.close();
            } catch (IOException e) {
              e.printStackTrace();
            }
         }
       }
       long end = System.currentTimeMillis();
       System.out.println("耗费时间为：" + (end - start));
    }
  }

3.IO API——NIO2：

NIO. 2

为了解决NIO的局限，同时为了支持现代硬件和软件的I/O新规范。引入了NIO.2 API。
主要特性为：
1）一个能批量获取文件属性的文件系统接口，取消和特定文件系统相关的API，还有一个用于引入标准文件系统实现的服务提供者接口。
2）引入一个套接字和文件都能够进行异步I/O操作的API。
3）完成JSR-51中定义的套接字——通道功能。
随着 JDK 7 的发布， Java对NIO进行了极大的扩展，增强了对文件处理和文件系统特性的支持，以至于我们称他们为 NIO.2。因为 NIO 提供的一些功能， NIO已经成为文件处理中越来越重要的部分。

Path、 Paths和Files核心API

• Path是File的升级。早期的Java只提供了一个File类来访问文件系统，但File类的功能比较有限，所提供的方法性能也不高。而且， 大多数方法在出错时仅返回失败，并不会提供异常信息。NIO. 2为了弥补这种不足，引入了Path接口，代表一个平台无关的平台路径，描述了目录结构中文件的位置。 Path可以看成是File类的升级版本，实际引用的资源也可以不存在。
• Paths和Files属于工具类。为对应于的类相关的方法实现。Files 类:java.nio.file.Files 用于操作文件或目录的工具类。

Path 常用方法：

Paths 类提供的静态 get() 方法用来获取 Path 对象：
static Path get(String first, String … more) : 用于将多个字符串串连成路径
static Path get(URI uri): 返回指定uri对应的Path路径
String toString() ： 返回调用 Path 对象的字符串表示形式
boolean startsWith(String path) : 判断是否以 path 路径开始
boolean endsWith(String path) : 判断是否以 path 路径结束
boolean isAbsolute() : 判断是否是绝对路径
Path getParent() ：返回Path对象包含整个路径，不包含 Path 对象指定的文件路径
Path getRoot() ：返回调用 Path 对象的根路径
Path getFileName() : 返回与调用 Path 对象关联的文件名
int getNameCount() : 返回Path 根目录后面元素的数量
Path getName(int idx) : 返回指定索引位置 idx 的路径名称
Path toAbsolutePath() : 作为绝对路径返回调用 Path 对象
Path resolve(Path p) :合并两个路径，返回合并后的路径对应的Path对象
File toFile(): 将Path转化为File类的对象

Files常用方法：

Path copy(Path src, Path dest, CopyOption … how) : 文件的复制
Path createDirectory(Path path, FileAttribute<?> … attr) : 创建一个目录
Path createFile(Path path, FileAttribute<?> … arr) : 创建一个文件
void delete(Path path) : 删除一个文件/目录，如果不存在，执行报错
void deleteIfExists(Path path) : Path对应的文件/目录如果存在，执行删除
Path move(Path src, Path dest, CopyOption…how) : 将 src 移动到 dest 位置
long size(Path path) : 返回 path 指定文件的大小
Files常用方法：用于判断
boolean exists(Path path, LinkOption … opts) : 判断文件是否存在
boolean isDirectory(Path path, LinkOption … opts) : 判断是否是目录
boolean isRegularFile(Path path, LinkOption … opts) : 判断是否是文件
boolean isHidden(Path path) : 判断是否是隐藏文件
boolean isReadable(Path path) : 判断文件是否可读
boolean isWritable(Path path) : 判断文件是否可写
boolean notExists(Path path, LinkOption … opts) : 判断文件是否不存在
Files常用方法：用于操作内容
SeekableByteChannel newByteChannel(Path path, OpenOption…how) : 获取与指定文件的连接， how 指定打开方式。
DirectoryStream newDirectoryStream(Path path) : 打开 path 指定的目录
InputStream newInputStream(Path path, OpenOption…how):获取 InputStream 对象
OutputStream newOutputStream(Path path, OpenOption…how) : 获取 OutputStream 对象

在目录中查找文件
例如在文件夹中罗列出.properties后缀文件。在以前需要遍历然后比较文件的后缀名称。文件使用glob表达式过滤

@Test
public void test2() {
    Path path = Paths.get("D:\\path");
    try (
        DirectoryStream<Path> paths = Files.newDirectoryStream(path, "*.properties");
    ) {
        for (Path p : paths ) {
            System.out.println("file name = " + p.getFileName());
        }
    } catch (IOException e) {
 
    }
}

遍历目录树
Java7支持整个目录树（子目录也会遍历）的遍历操作。这样可以简单的对子目录查找并执行操作。Files.walkFileTree(Path startingDir, FileVisitor<? Super Path> vistor);是最关键的方法。FileVisitor需要实现4个方法（Java 8），但是API已经提供了默认实现类SimpleFileVisitor。

@Test
public void test3() throws IOException {
    Path path = Paths.get("D:\\path");
    Files.walkFileTree(path, new FindXMLVisitor());
}
 
class FindXMLVisitor extends SimpleFileVisitor<Path> {
    @Override
    public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) throws IOException {
        if (file.toString().endsWith(".xml")) {
            System.out.println(file.getFileName());
        }
        return FileVisitResult.CONTINUE;
    }
}

快速读写数据
Java7中可以直接使用带有缓冲区的读取器和写入器或输入输出流操作文件。

public void test5() {
    Path readers = Paths.get("D:\\path\\123.txt");
    Path writes = Paths.get("D:\\path\\456.txt");
    try (BufferedReader reader = Files.newBufferedReader(readers,StandardCharsets.UTF_8);
        BufferedWriter writer = Files.newBufferedWriter(writes, StandardCharsets.UTF_8)) {
        //读取
        String line;
        while ((line = reader.readLine()) != null) {
            System.out.println(line);
        }
        //写入
        writer.write("write");
    } catch (IOException e) {
        e.printStackTrace();
    }
}

异步I/O操作
异步IO其实只是在进行读写操作的时候允许进行其它操作处理。
将来式
将来式只是使用java.util.concurrent.Future接口来，在使用该接口的get方法后，如果处理完毕立即返回数据，如果没有则阻塞。

public void test6() throws IOException, ExecutionException, InterruptedException {
    Path readers = Paths.get("D:\\path\\123.txt");
    //异步打开文件
    AsynchronousFileChannel channel = AsynchronousFileChannel.open(readers);
    ByteBuffer buffer = ByteBuffer.allocate(100_000);//读取100 000字节
    Future<Integer> result = channel.read(buffer, 0);//读取
    //处理其它事情
    System.out.println("处理其它事情");
    Integer integer = result.get();//获取结果，如果已经执行完立即返回，否则阻塞到执行完毕
}

回调式
回调式通过处理完毕后执行回调函数的方法去通知。

@Test
public void test7() throws IOException {
    Path readers = Paths.get("D:\\path\\123.txt");
    //异步打开文件
    AsynchronousFileChannel channel = AsynchronousFileChannel.open(readers);
    ByteBuffer buffer = ByteBuffer.allocate(100_000);//读取100 000字节
    channel.read(buffer, 0, buffer, new CompletionHandler<Integer, ByteBuffer>() {
        @Override
        public void completed(Integer result, ByteBuffer attachment) {
            System.out.println("执行完毕后执行这里的方法");
        }
 
        @Override
        public void failed(Throwable exc, ByteBuffer attachment) {
            System.out.println("失败后执行这里的方法");
        }
    });
}