NIO与IO的区别
由面向存取数据的载体、是否阻塞等可以分为以下三点不同：
面向流：
数据像水流一样传输，并且，要么输入要么输出，流是单向的。所以以前的IO流都有输入流，输出流。
面向缓冲区：
NIO会在程序与文件（磁盘、网络）之间建立一个通道用于连接，然后通过缓冲区进行数据存取，通过通道进行连接传递。
阻塞IO和非阻塞IO、选择器主要是针对网络编程而言的。
通道（ Channel）与缓冲区（ Buffer）
Java NIO系统的核心在于：通道(Channel)和缓冲区(Buffer)。通道表示打开到 IO 设备(例如：文件、套接字)的连接。若需要使用 NIO 系统，需要获取用于连接 IO 设备的通道以及用于容纳数据的缓冲区。然后操作缓冲区，对数据进行处理。
简而言之， Channel 负责传输、连接， Buffer 负责数据存储、操作
缓冲区（ Buffer）
缓冲区（ Buffer） ：一个用于特定基本数据类型的容器。由 java.nio 包定义的，所有缓冲区都是 Buffer 抽象类的子类。
Java NIO 中的 Buffer 主要用于与 NIO 通道进行交互，数据是从通道读入缓冲区，从缓冲区写入通道中。
Buffer 就像一个数组，可以保存多个相同类型的数据。根据数据类型不同(boolean 基本数据类型除外) ，有以下 Buffer 七个常用子类：
- ByteBuffer
- CharBuffer
- ShortBuffer
- IntBuffer
- LongBuffer
- FloatBuffer
- DoubleBuffer
上述 Buffer 类 他们都采用相似的方法进行管理数据，只是各自管理的数据类型不同而已。都是通过allocate方法获取一个 Buffer对象：
static XxxBuffer allocate(int capacity) : 创建一个容量为 capacity 的 XxxBuffer 对象
Buffer 中的重要概念：
- 容量 (capacity) ： 表示 Buffer 最大数据容量，缓冲区容量不能为负，并且创建后不能更改。
- 限制 (limit)： 第一个不应该读取或写入的数据的索引，即位于 limit 后的数据不可读写。缓冲区的限制不能为负，并且不能大于其容量。
- 位置 (position)： 下一个要读取或写入的数据的索引。缓冲区的位置不能为负，并且不能大于其限制
- 标记 (mark)与重置 (reset)： 标记是一个索引，通过 Buffer 中的 mark() 方法指定 Buffer 中一个特定的 position，之后可以通过调用 reset() 方法恢复到这个 position。
标记、 位置、 限制、 容量遵守以下不变式： 0 <= mark <= position <= limit <= capacity
注意：mark初始化为-1，表示没有标记过。
Clearing, flipping, and rewinding说明
-
clear()makes a buffer ready for a new sequence of channel-read or relative put operations: It sets the limit to the capacity and the position to zero.
翻译：clear()为一系列的读取通道数据到缓冲区(channel.read())或relative put操作准备好缓冲区：它将limit设置为capacity并将positon设置为零。
注意：put操作有absolute put and relative put 操作，具体见Buffer的具体实现类如：ByteBuffer
-
flip()makes a buffer ready for a new sequence of channel-write or relative get operations: It sets the limit to the current position and then sets the position to zero.
翻译：flip()为一些列的将缓冲区数据写入到通道(channel.write())或relative get操作准备好缓冲区：它将limit设置为当前position，然后将position设置为0。
-
rewind()makes a buffer ready for re-reading the data that it already contains: It leaves the limit unchanged and sets the position to zero.
翻译：rewind()为重新读取它已经包含的数据准备好缓冲区：它使limit保持不变并将position设置为零。
四个核心属性与缓冲区的存取操作的关系
我们通过下面简单的图例进行了解
1、allocate(int)申请缓冲区
当我们用XxxBuffer申请allocate(int)了一个缓冲区后，我们得到了一个capacity为指定参数的大小的数组缓冲区。当前我们什么都没做，position当然保持在初始0的位置，因为初始状态没有切换到读模式，没有什么需要标记其后不能读的，写只要不超过capacity就可以，所以limit放在最后，与capacity值一样。
2、put向缓冲区写数据
当我们put()写入5个数值之后，position变为5（0到4已经写了数，若要继续写需要从5开始）。因为没有切换到读模式，所以没有什么需要声明其后不能读，写只要不超过capacity就可以，所以limit放在最后，与capacity值一样。
3、flip()将缓冲区切换成读取数据模式
当我们需要读取我们刚才写入缓冲区的数据时，首先需要做的是调用缓冲区的flip()方法，将缓冲区切换到读模式。
切换到读模式之后，我们要做的是将刚才的写入的5个数据读取出来，很自然地，postion会变回0，因为0是写入的起始位置；因为刚才只写入了5个，因此数据只写到0-4，所以从第5个开始之后的不能被读取，所以limit变成5，限定5开始之后的缓冲区空间不能够被读取。postion会随着读而变化位置。
如果调用了rewind()准备重读，那么position一定变回为0。
如果读到当中的某个位置我们mark()了，这个标记的postion值会被缓冲区的核心属性mark记录下来，等到后来reset()的时候，mark属性记录的值会赋给position属性，用于回到刚才mark标记的位置用于重读。
Buffer 的常用方法
| 方 法 | 描 述 |
| Buffer clear() | 清空缓冲区并返回对缓冲区的引用 |
| Buffer flip() | 将缓冲区的界限设置为当前位置，并将当前位置充值为 0 |
| int capacity() | 返回 Buffer 的 capacity 大小 |
| boolean hasRemaining() | 判断缓冲区中是否还有元素 |
| int limit() | 返回 Buffer 的界限(limit) 的位置 |
| Buffer limit(int n) | 将设置缓冲区界限为 n, 并返回一个具有新 limit 的缓冲区对象 |
| Buffer mark() | 对缓冲区设置标记 |
| int position() | 返回缓冲区的当前位置 position |
| Buffer position(int n) | 将设置缓冲区的当前位置为 n , 并返回修改后的 Buffer 对象 |
| int remaining() | 返回 position 和 limit 之间的元素个数 |
| Buffer reset() | 将位置 position 转到以前设置的 mark 所在的位置 |
| Buffer rewind() | 将位置设为为 0， 取消设置的 mark |
测试代码
package com;
import java.nio.ByteBuffer;
import org.junit.Test;
/**
* 一、缓冲区（Buffer）：在java NIO中负责数据的存取。缓冲区就是数据容器，用于存储不同数据类型的数据。
*
* 根据数据类型的不同（boolean除外，其他7种基本类型全有），提供相应类型的缓冲区： ByteBuffer CharBuffer ShortBuffer
* IntBuffer LongBuffer FloatBuffer DoubleBuffer
*
* 上述缓冲区的管理方式几乎一致，通过allocate()获取缓冲区 最常用的是ByteBuffer，因为无论磁盘还是网络传输的都是Byte。
*
* 有了缓冲区，接下来要往缓冲区存取数据
*
* 二、缓冲区存取数据的两个核心方法： put()：存入数据到缓冲区中 get()：获取缓冲区中的数据
*
* 要想对缓冲区的数据进行正确的存取的话，必须要先了解几个缓冲区的核心属性
*
*
* 三、缓冲区中的四个核心属性：<br/>
* capacity：容量，表示缓冲区中最大存储数据的容量。一旦声明不能改变。（因为缓冲区就是数组，数组大小不可改变）<br/>
* limit：界限，表示缓冲区中可以操作数据的大小。（limit后面的数据不能进行读写） <br/>
* position：位置，表示缓冲区正在操作数据的位置。<br/>
*
* position <= limit <= capacity
*
* mark：标记，表示记录当前position的位置。可以用过reset()恢复到mark的位置。
*
* 0 <= mark <= position <= limit <= capacity
*
* mark初始化为-1，表示没有标记过
*/
public class TestBuffer {
@Test
public void test1() {
// 1、分配一个是指定大小的缓冲区
ByteBuffer buf = ByteBuffer.allocate(1024);// 指定缓冲区大小capacity为1024
printBufferStatus(buf, "allocate()");
// 2、利用put()方法存入数据到缓冲区中
final String dataStr = "abcde";
buf.put(dataStr.getBytes());
printBufferStatus(buf, "put()");
// 3、切换读取数据模式
buf.flip();
printBufferStatus(buf, "flip()");
// 4、利用get()读取缓冲区中的数据
byte[] dst = new byte[buf.limit()];
buf.get(dst);
System.out.println(new String(dst, 0, dst.length));
printBufferStatus(buf, "get()");
// 5、调用rewind()，恢复读模式到读之前的初始状态，用于可重复再读一次
buf.rewind();
printBufferStatus(buf, "rewind()");
// 6、clear()清空缓冲区，回到allocate()申请缓冲区的最初状态。
// 但是请注意，这个恢复到最初状态，指定是buffer的几个核心属性恢复到最初状态，
// 里面的数据依然还在，只不过这些数据处于“被遗忘”状态。
// 所谓被遗忘状态，是指buffer的几个指针都恢复到了初始位置，里面有几个数据，从哪读到哪，已经都不知道了。
buf.clear();
printBufferStatus(buf, "clear()");
// 尝试读取被clear()清空之后的缓冲区，数据依然在。（因为clear之后，我们无法知道原来有几个数据，所以读一个）
System.out.println("clear()之后试着get()一个byte: " + (char) buf.get());
}
private void printBufferStatus(ByteBuffer buf, String info) {
System.out.println("---------" + info + "----------");
System.out.println("position: " + buf.position());
System.out.println("limit: " + buf.limit());
System.out.println("capacity: " + buf.capacity());
System.out.println();
}
@Test
public void test2() {
final String dataStr = "abcde";
ByteBuffer buf = ByteBuffer.allocate(1024);
buf.put(dataStr.getBytes());
buf.flip();
byte[] dst = new byte[buf.limit()];
buf.get(dst, 0, 2);
System.out.println("get(dst, 0, 2): " + new String(dst, 0, 2));
System.out.println("get(dst, 0, 2) position: " + buf.position());
// mark()：标记
buf.mark();
System.out.println("mark() position: " + buf.position());
buf.get(dst, 2, 2);
System.out.println("get(dst, 2, 2): " + new String(dst, 2, 2));
System.out.println("get(dst, 2, 2) position: " + buf.position());
// reset()：恢复到mark的位置
buf.reset();
System.out.println("reset() position: " + buf.position());
// 判断缓冲区中是否还有剩余数据
if (buf.hasRemaining()) {
// 获取缓冲区中剩余的可以操作的数据量
System.out.println("buf.remaining(): " + buf.remaining());
}
}
}test1结果
---------allocate()----------
position: 0
limit: 1024
capacity: 1024
---------put()----------
position: 5
limit: 1024
capacity: 1024
---------flip()----------
position: 0
limit: 5
capacity: 1024
abcde
---------get()----------
position: 5
limit: 5
capacity: 1024
---------rewind()----------
position: 0
limit: 5
capacity: 1024
---------clear()----------
position: 0
limit: 1024
capacity: 1024
clear()之后试着get()一个byte: atest2结果
get(dst, 0, 2): ab
get(dst, 0, 2) position: 2
mark() position: 2
get(dst, 2, 2): cd
get(dst, 2, 2) position: 4
reset() position: 2
buf.remaining(): 3