从Java1.4开始，出现了NIO，即NEW IO，用作可以替代原有Java IO的API。
本文主要介绍NIO的一些基础知识，后面文章对主要的类进行分析。
What is NIO
对于NIO，需要知道几个概念，Channel，Buffer，非阻塞，Selectors：
- 标准的IO基于字节流和字符流进行操作的，而NIO是基于通道（Channel）和缓冲区（Buffer）进行操作，数据总是从通道读取到缓冲区中，或者从缓冲区写入到通道中。
即相关的操作，是针对Channel与与Buffer的。 - 另一方面，Java NIO可以让你非阻塞的使用IO，例如：当线程从通道读取数据到缓冲区时，线程还是可以进行其他事情。当数据被写入到缓冲区时，线程可以继续处理它。从缓冲区写入通道也类似。
- Java NIO引入了选择器的概念，选择器用于监听多个通道的事件（比如：连接打开，数据到达）。因此，单个的线程可以监听多个数据通道。
接下来看看NIO中的Buffer是个啥。
Buffer
先看一个例子：
private static void buffer() throws IOException{
RandomAccessFile aFile = new RandomAccessFile("/home/anla7856/workspace/io.examples/pom.xml", "rw");
FileChannel inChannel = aFile.getChannel();
ByteBuffer buf = ByteBuffer.allocate(48);
int bytesRead = inChannel.read(buf);
while (bytesRead != -1) {
buf.flip(); //准备读
while(buf.hasRemaining()){
System.out.print((char) buf.get()); // 一次从buf中读取一个字节，并且转化为char输出
}
buf.clear(); //清空buf，让其处于待写状态。
bytesRead = inChannel.read(buf);
}
aFile.close();
}对于buffer的使用情况，有以下步骤：
- 先由一个RandomAccessFile获取一个FileChannel
- 由FileChannel读取数据到ByteBuffer中
- 通过flip，把写状态改为读状态
- 清空buf，让其处于写状态。
使用Buffer读写数据一般遵循以下四个步骤：
- 写入数据到Buffer
- 调用flip()方法
- 从Buffer中读取数据
- 调用clear()方法或者compact()方法
Buffer有以下几种实现，对应这8中Java中的基本数据类型：
- ByteBuffer
- CharBuffer
- DoubleBuffer
- FloatBuffer
- IntBuffer
- LongBuffer
- ShortBuffer
- MappedByteBuffer：用于表示内存映射文件
下面以ByteBuffer为例分析。
ByteBuffer内部原理
先看看ByteBuffer的定义：
public abstract class ByteBuffer
extends Buffer
implements Comparable<ByteBuffer>
{
final byte[] hb; // 用来存储字节的数组
final int offset; //起始值，主要是当使用直接内存地址，也就是映射的
boolean isReadOnly; // Valid only for heap buffers
...利用一个byte[]数组来作为buffer存储，再看看它的父类Buffer：
public abstract class Buffer {
/**
* 对应与spliterator的，说明Buffer具有的特性
*/
static final int SPLITERATOR_CHARACTERISTICS =
Spliterator.SIZED | Spliterator.SUBSIZED | Spliterator.ORDERED;
// 不变量: mark <= position <= limit <= capacity
private int mark = -1;
private int position = 0;
private int limit;
private int capacity;
// Used only by direct buffers
// NOTE: hoisted here for speed in JNI GetDirectBufferAddress
//用于直接内存，直接指明内存地址，jni变量。
long address;
对于父类Buffer中的几个变量是很有用的，针对于其数组进行各种操作。
- mark：作为一个标记
position：
当你写数据到Buffer中时，position表示当前的位置。初始的position值为0.当一个byte、long等数据写到Buffer后， position会向前移动到下一个可插入数据的Buffer单元。position最大可为capacity – 1.
当读取数据时，也是从某个特定位置读。当将Buffer从写模式切换到读模式，position会被重置为0. 当从Buffer的position处读取数据时，position向前移动到下一个可读的位置。
limit：
在写模式下，Buffer的limit表示你最多能往Buffer里写多少数据。 写模式下，limit等于Buffer的capacity。
读模式时， limit表示你最多能读到多少数据。因此，当切换Buffer到读模式时，limit会被设置成写模式下的position值。换句话说，你能读到之前写入的所有数据（limit被设置成已写数据的数量，这个值在写模式下就是position）
- capacity：作为一个内存块，Buffer有一个固定的大小值，也叫“capacity”.你只能往里写capacity个byte、long，char等类型。一旦Buffer满了，需要将其清空（通过读数据或者清除数据）才能继续写数据往里写数据。
position和limit的含义取决于Buffer处在读模式还是写模式。不管Buffer处在什么模式，capacity的含义总是一样的。
看一张图有助以理解：
构造一个ByteBuffer
如何构造一个ByteBuffer呢？
里面的构造函数是包私有的，也就是外部无法直接初始化。
可以有两种方法，这里先说第一种方法：
CharBuffer buf = CharBuffer.allocate(1024);看看它的代码走向：
public static ByteBuffer allocate(int capacity) {
if (capacity < 0) //检查
throw new IllegalArgumentException();
return new HeapByteBuffer(capacity, capacity);
}再看看HeapByteBuffer，这个是ByteBuffer的子类，读过源码就知道，ByteBuffer里面方法大部分是抽象方法，具体实现则交由子类去实现。
HeapByteBuffer(int cap, int lim) { // package-private
super(-1, 0, lim, cap, new byte[cap], 0);
}而HeapByteBuffer的构造方法，也是直接调用父类也就是ByteBuffer的方法进行初始化。
第二种方法则是基于MappedByteBuffer进行的，直接通过Unsafe类操作底层存储空间，这里等到单独讲MappedByteBuffer进行分析。
下面看看一些ByteBuffer中重要的方法：
flip方法
这个是父类Buffer中定义的方法，flip方法将Buffer从写模式切换到读模式。调用flip()方法会将position设回0，并将limit设置成之前position的值。
换句话说，position现在用于标记读的位置，limit表示之前写进了多少个byte、char等 —— 现在能读取多少个byte、char等。
public final Buffer flip() {
limit = position;
position = 0;
mark = -1;
return this;
}rewind方法
rewind()将position设回0，所以你可以重读Buffer中的所有数据。limit保持不变，仍然表示能从Buffer中读取多少个元素（byte、char等）。
public final Buffer rewind() {
position = 0;
mark = -1;
return this;
}clear方法
clear()方法，position将被设回0，limit被设置成 capacity的值。换句话说，Buffer 被清空了。Buffer中的数据并未清除，只是这些标记告诉我们可以从哪里开始往Buffer里写数据。即只是将内部的变量赋予一个初始化的位置。
public final Buffer clear() {
position = 0;
limit = capacity;
mark = -1;
return this;
}compact方法
如果Buffer中有一些未读的数据，调用clear()方法，数据将“被遗忘”，意味着不再有任何标记会告诉你哪些数据被读过，哪些还没有。
如果Buffer中仍有未读的数据，且后续还需要这些数据，但是此时想要先先写些数据，那么使用compact()方法。
compact()方法将所有未读的数据拷贝到Buffer起始处。然后将position设到最后一个未读元素正后面。limit属性依然像clear()方法一样，设置成capacity。现在Buffer准备好写数据了，但是不会覆盖未读的数据。
compact方法是子类HeapByteBuffer里面的方法：
public ByteBuffer compact() {
System.arraycopy(hb, ix(position()), hb, ix(0), remaining()); //拷贝剩余的数组
position(remaining()); //设置position
limit(capacity()); //设置limit
discardMark(); //设置mark
return this;
}equals方法
在ByteBuffer中，重写了equals方法：
public boolean equals(Object ob) {
if (this == ob)
return true;
if (!(ob instanceof ByteBuffer)) //1，类型一致
return false;
ByteBuffer that = (ByteBuffer)ob;
if (this.remaining() != that.remaining()) //2，剩余数量一致
return false;
int p = this.position();
for (int i = this.limit() - 1, j = that.limit() - 1; i >= p; i--, j--)
if (!equals(this.get(i), that.get(j))) //3，剩余的每一项都equals
return false;
return true;
}如上，只有当满足下面三种条件时候，才能认为equals：
- 类型一致
- 剩余数量一致
- 剩余的每一项都equals
compareTo方法
这个compareTo类似于c++里面的字符串比较方法：
public int compareTo(ByteBuffer that) {
int n = this.position() + Math.min(this.remaining(), that.remaining());
for (int i = this.position(), j = that.position(); i < n; i++, j++) {
int cmp = compare(this.get(i), that.get(j)); //比较每一个
if (cmp != 0)
return cmp;
}
return this.remaining() - that.remaining(); //如果每一个都相等，那么就比较剩余容量
}上述compareTo比较两个方面：
1. 比较position开始的每一个元素，终点是二者remaining小的一方
2. 如果都想等，那么就比较remainning。
参考资料：
1. http://ifeve.com/buffers/