Java NIO

 

 

Capacity

A buffer's capacity is the number of elements it contains. The capacity of a buffer is never negative and never changes. 

 

Limit

A buffer's limit is the index of the first element that should not be read or written. A buffer's limit is never negative and is never greater than its capacity. 

limit 变量限制了当前buffer中可操作的容量大小。 向buffer写入数据时limit =capacity (除非使用limit(n)限制了limit大小)，表明可写入的容量为limit ；调用flip()时Limit=Position，表面当前buffer可读取的容量是limit。 

 

Position 

A buffer's position is the index of the next element to be read or written. A buffer's position is never negative and is never greater than its limit. 

在从通道读取时，您将所读取的数据放到底层的数组中。 position 变量跟踪已经写了多少数据。更准确地说，它指定了下一个字节将放到数组的哪一个元素中。因此，如果您从通道中读三个字节到缓冲区中，那么缓冲区的 position 将会设置为3，指向数组中第四个元素。

同样，在写入通道时，您是从缓冲区中获取数据。 position 值跟踪从缓冲区中获取了多少数据。更准确地说，它指定下一个字节来自数组的哪一个元素。因此如果从缓冲区写了5个字节到通道中，那么缓冲区的 position 将被设置为5，指向数组的第六个元素。

 

Mark

A buffer's mark is the index to which its position will be reset when the reset method is invoked. The mark is not always defined, but when it is defined it is never negative and is never greater than the position.

标记读写的位置

 

0 <= mark <= position <= limit <= capacity 

remaining= limit - position 

 

默认值：

mark =-1 （未定义）

position =0

limit = capacity = n

 

重要方法：

flip()  由写buffer模式 改为从buffer读出模式

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

 

 clear() 重新回到写buffer模式

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

 

 

 mark() 标记当前读或写得位置

    public final Buffer mark() {
        mark = position;
        return this;
    }

 

reset() 回到标记的位置

    public final Buffer reset() {
        int m = mark;
        if (m < 0)
            throw new InvalidMarkException();
        position = m;
        return this;
    }

 

discarkMark() 清除标记

    final void discardMark() {                          // package-private
        mark = -1;
    }

 

 rewind() 位置归0，清除标记， 从头开始读或写

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

 

 

以下对比两种不同IO copy文件的方式：

	@Test
	public void copyByIO() throws Exception{
		FileInputStream fin = new FileInputStream("E:\\TechTools\\windows\\DEEP_GHOST_WIN7_SP1_X64_V2016_01.iso");
		FileOutputStream fout = new FileOutputStream("D:\\Data\\Log\\future\\DEEP_GHOST_WIN7_SP1_X64_V2016_01.iso");
		byte[] buffer = new byte[1024*1024];
		while(fin.read(buffer, 0, 1024*1024)!=-1){
			fout.write(buffer);
		}
		fin.close();
		fout.close();
	}


	@Test
	public void copyByNIO() throws Exception{
		FileInputStream fin = new FileInputStream("E:\\TechTools\\windows\\DEEP_GHOST_WIN7_SP1_X64_V2016_01.iso");
		FileOutputStream fout = new FileOutputStream("D:\\Data\\Log\\future\\DEEP_GHOST_WIN7_SP1_X64_V2016_01.iso");
		try {
			FileChannel chin = fin.getChannel();
			FileChannel chout = fout.getChannel();
			ByteBuffer buffer =ByteBuffer.allocate(1024*1024);
			int flag = 0;
			while(flag!=-1){
				buffer.flip();
				chout.write(buffer);
				
				buffer.clear();
				flag = chin.read(buffer);
			}
		} catch (Exception e) {
			e.printStackTrace();
		}finally{
			fin.close();
			fout.close();
		}
	}

  测试结果： NIO比IO略快。

 

Direct Buffer

与ByteBuffer.allocate(1024*1024)相似的另一个方法是ByteBuffer.allocateDirect(1024*1024)。它直接在OS内核分配内存，不占用JVM空间，就好比是“内核缓冲区”的内容直接写入了Channel，减少了数据拷贝,因此速度更快。著名的Netty就是使用DirectBuffer。

 

 

MappedByteBuffer 

将文件的全部或部分直接映射到内存，可以实现对文件的快速随机读取，对MappedByteBuffer的修改操作也可以直接反应到文件

	@Test
	public void testMappedByteBuffer() throws Exception{
		RandomAccessFile file = new RandomAccessFile("D:\\Data\\Log\\future\\1.txt", "rw");
		FileChannel chin = file.getChannel();
		MappedByteBuffer buffer = chin.map(MapMode.READ_WRITE, 0, chin.size());
		buffer.put(0, (byte)1);
		file.close();
	}

 

 

 

 

参考：

https://www.ibm.com/developerworks/cn/education/java/j-nio/index.html

<Direct buffer 与Heap Buffer的区别>http://blog.csdn.net/shibushiyouwenti/article/details/7396016