Java NIO使用(上)

1. NIO使用

1.1 Buffer

以IntBuffer为例，初始化一个Buffer,InputBuffer是一个抽象类，是Buffer的子类:

//初始化buffer,allocate方法用于初始化，参数是缓冲区容量
IntBuffer buffer = IntBuffer.allocate(10);

查看InputBuffer源码：

public static IntBuffer allocate(int capacity) {
    if (capacity < 0)
        throw new IllegalArgumentException();
    return new HeapIntBuffer(capacity, capacity);
}

可以看到实际返回的是HeapIntBuffer的对象，继续查看HeapIntBuffer源码：

HeapIntBuffer(int cap, int lim) {            // package-private
    super(-1, 0, lim, cap, new int[cap], 0);
    /*
    hb = new int[cap];
    offset = 0;
    */
}

区中的super调用的是IntBuffer中的构造方法：

IntBuffer(int mark, int pos, int lim, int cap,   // package-private
             int[] hb, int offset)
{
    super(mark, pos, lim, cap);
    this.hb = hb;
    this.offset = offset;
}

其中几个参数说明如下： cap是capacity,即容量，就是缓冲区的大小
hb是一个数组，是缓冲区实际存储数据的地方，数组大小根据capacity值设定
pos是position,表示位置，是一个标记。表示缓冲区(hb)中当前要读取或写入的数据位置
lim是limit,在写入的时候，它的值和capacity一致，读取的时候，它是缓冲区中数据的实际长度 offset是偏移量 mark是标记
这些参数的作用，具体要看写入和读取的代码 写入数据使用put方法：

//初始化buffer,allocate方法用于初始化，参数是缓冲区容量
IntBuffer buffer = IntBuffer.allocate(10);
buffer.put(1);//写入数字1
buffer.put(2);//写入数字2

查看HeapIntBuffer中的源码：

public IntBuffer put(int x) {

    hb[ix(nextPutIndex())] = x;
    return this;
}

可以看到是在hb数组中放入要写入的数字，放入的位置通过nextPutIndex()和ix()两个方法获得：

final int nextPutIndex() {                          // package-private
    if (position >= limit)
        throw new BufferOverflowException();
    return position++;
}

可以看到，在方法中判断了position和limit的大小，在缓冲区初始化的时候，position是0，limit是缓冲区的大小，如果要放入的索引位置超出了缓冲区大小，就抛出异常。第一个写入的位置position是0，之后position++,即下一次从索引1开始写入。

protected int ix(int i) {
    return i + offset;
}

ix()方法用于计算偏移后的位置。因为开始的时候offset=0，所以默认是不偏移的。 对于已经写入得效果，我们可以输出缓冲区中的数组：

System.out.println(Arrays.toString(buffer.array()));

其中array()返回的就是前面说到的数组hb,即缓冲区实际存放数据的地方，源码如下：

public final int[] array() {
    if (hb == null)
        throw new UnsupportedOperationException();
    if (isReadOnly)
        throw new ReadOnlyBufferException();
    return hb;
}

运行效果如下图： 在array()方法中看到了一个isReadOnly属性，顾名思义，它是设置只读的
查看源码：

public IntBuffer asReadOnlyBuffer() {
    return new HeapIntBufferR(hb,
                                 this.markValue(),
                                 this.position(),
                                 this.limit(),
                                 this.capacity(),
                                 offset);
}

asReadOnlyBuffer()方法创建了一个新的HeapIntBufferR（注意后面多了个R，不是原来的HeapIntBuffer了），新缓冲区的属性和当前的对象一致，并且新缓冲区把isReadOnly属性设置成了true

protected HeapIntBufferR(int[] buf,
                               int mark, int pos, int lim, int cap,
                               int off)
{
    super(buf, mark, pos, lim, cap, off);
    this.isReadOnly = true;
}

HeapIntBufferR的put()方法是不能写入的：

public IntBuffer put(int x) {
    throw new ReadOnlyBufferException();
}

Buffer是既可以写入，又可以读取的。默认是写入模式。如果想读取已经写入的内容，需要切换读写模式：

IntBuffer buffer = IntBuffer.allocate(10);
buffer.put(1);//写入数字1，写完之后position是1
buffer.put(2);//写入数字2，写完之后position是2
buffer.flip();//切换到读
while (buffer.hasRemaining()) {
    System.out.println(buffer.get());
}

首先看get()方法，get()用于读取缓冲区数组中的元素，每次返回一个元素，查看源码：

public int get() {
    return hb[ix(nextGetIndex())];
}
final int nextGetIndex() {                          // package-private
    if (position >= limit)
        throw new BufferUnderflowException();
    return position++;
}

可以看到返回的是第position个位置的元素。但是position在put()写入的时候记录的是下一次该写入的位置，如果直接从position开始读，是读不到数据的。所以需要flip()方法：

public final Buffer flip() {
    limit = position;
    position = 0;
    mark = -1;
    return this;
}

flip()方法中，limit=position,即已经写入的数据长度，设置position=0，之后再读取的时候，就是从索引0开始读的了。每次读取一个元素，position自增1。

public final boolean hasRemaining() {
    return position < limit;
}

hasRemainig()中对position和limit进行判断，保证不会读取的数据不会超出写入的部分。
所以capacity>limit>position
因为读取之后，重置了position和limit，所以不能再继续写入了。需要从读模式再切换回写模式：
从写切换到读有两个方法，clear()和compact()

//初始化buffer
IntBuffer buffer = IntBuffer.allocate(10);
buffer.put(1);//写入数字1
buffer.put(2);//写入数字2
buffer.flip();//切换到读
System.out.println(buffer.get());//读取的是数字1，数字2未读取
System.out.println("===================");
//buffer.clear();//切换到写模式，后写入的数据覆盖原来的内容
buffer.compact();//切换到写模式，不清除未读取的数据
buffer.put(3);
buffer.put(4);
buffer.flip();//切换到读
while (buffer.hasRemaining()) {
    System.out.println(buffer.get());
}

上面的代码，用clear()之后，输出第二次读取输出的是34，2被后写入的3覆盖了；用compact()，第二次输出的是234，因为2没有被读取，被保留，3和4会在它之后写入。
clear()方法之后，position=0，写入的数据会覆盖以前的数据；而compact()方法会保留未读的数据(注意只是未读的，已经写入的数据如果读取过了就不会保留)。

public final Buffer clear() {
    position = 0;
    limit = capacity;
    mark = -1;
    return this;
}
public IntBuffer compact() {
    System.arraycopy(hb, ix(position()), hb, ix(0), remaining());
    position(remaining());
    limit(capacity());
    discardMark();
    return this;
}
public final int remaining() {
    return limit - position;
}

clear()方法比较直观，把position重置为0，下次就从索引0开始写入，所以后写入的数据会覆盖原来位置的数据。
compact()方法里，可以看到这里调用了一个数组复制的方法，查看几个参数的意义：

public static native void arraycopy(Object src,  int  srcPos,
                                    Object dest, int destPos,
                                    int length);

src是原始数组，srcPos是从原始数组的第几个位置开始复制，desc是目标数组，destPos是目标数组开始写入的位置，length是从原始数组中复制几个元素到目标数组中。
在读取模式的时候，position是读取的位置，limit是一共有多少数据，remaining()中limit-position就是还有几个是没有读取的。
复制数组的之后，从position开始复制，到新数组，一共复制remaining个，就是把没有读取的数据都复制到新数组去，destPos=0，就是从新数组的索引0开始插入。所以compact()方法是把原来缓冲区中没有读取的数据全部放放到新缓冲区的头部，新插入的数据在头部之后。
通过上面的案例可以看出，所谓的读模式和写模式，就通过改变position和limit的值，对数组中指定位置的元素进行操作。
另外两个和position方法，mark()和reset(),mark()用于记录当前position，reset()可以将position恢复到mark()记录的值。

IntBuffer buffer = IntBuffer.allocate(10);
buffer.put(1);//写入数字1
buffer.put(2);//写入数字2
buffer.mark();//对position进行标记，当前mark=2
System.out.println("get之前："+buffer.position());//2
System.out.println(buffer.get());//输出0，position++,position=3
System.out.println("get之后："+buffer.position());//3
buffer.reset();//重置position,position等于mark标记值2
System.out.println("reset之后："+buffer.position());//2

1.2 FileChannel

FileChannel写文件：

FileOutputStream outputStream = new FileOutputStream("G:/file_channel.txt");
FileChannel channelOut = outputStream.getChannel();
ByteBuffer buffer = ByteBuffer.allocate(1024);
String string = "你好";
buffer.put(string.getBytes());
buffer.flip(); // 切换到读模式
channelOut.write(buffer); //把buffer中的数据写入channel
channelOut.close();
outputStream.close();

java1.7之后提供的新的打开FileChannel的方式：

FileChannel channel = FileChannel.open(Paths.get("D://test.txt"), StandardOpenOption.CREATE,StandardOpenOption.WRITE);

注意在调用channel的write方法之前必须调用buffer的flip方法，否则无法正确写入内容 FileChannel读文件：

FileInputStream inputStream = new FileInputStream("G:/ip.txt");
FileChannel channelIn=inputStream.getChannel();
ByteBuffer buf = ByteBuffer.allocate(128);
int len=-1;
while((len=channelIn.read(buf))!=-1){
	buf.flip();//从写模式切换到读模式
byte[] arr = new byte[len];
	buf.get(arr, 0, len); //讲buffer中的数据写入arr
	System.out.println(new String(arr,"GBK"));
	buf.compact();//让Buffer准备再次写入
}
channelIn.close();
inputStream.close();

java1.7之后提供的新的打开FileChannel的方式：

FileChannel channel = FileChannel.open(Paths.get("D://test.log"), StandardOpenOption.READ);

使用FileChannel复制文件：

FileInputStream fileInputStream = new FileInputStream("G:/java.zip");
FileOutputStream fileOutputStream = new FileOutputStream("G:/java2.zip");
// 得到fileInputStream的文件通道
FileChannel fileChannelInput = fileInputStream.getChannel();
// 得到fileOutputStream的文件通道
FileChannel fileChannelOutput = fileOutputStream.getChannel();
// 将fileChannelInput通道的数据，写入到fileChannelOutput通道
fileChannelInput.transferTo(0, fileChannelInput.size(), fileChannelOutput);
fileInputStream.close();
fileChannelInput.close();
fileOutputStream.close();
fileChannelOutput.close();

transferTo方法文件大小限制在2G以内，可以直接使用缓冲区，不受限制。

FileChannel in = FileChannel.open(Paths.get("D://test.log"), StandardOpenOption.READ);
FileChannel out = FileChannel.open(Paths.get("D://test.txt"), StandardOpenOption.CREATE, StandardOpenOption.WRITE);
ByteBuffer buffer = ByteBuffer.allocate(1024);
while (in.read(buffer) != -1) {
    buffer.flip();//从写模式切换到读模式
    out.write(buffer);
    buffer.clear();//让Buffer准备再次写入
}
out.close();
in.close();