（三）Java NIO

一、Buffer简介

Java NIO中的Buffer用于和NIO通道进行交互。数据是从通道读入缓冲区，从缓冲区写入到通道中的。

缓冲区本质上是一块可以写入数据，然后可以从中读取数据的内存。这块内存被包装成NIO Buffer对象，并提供了一组方法，用来方便的访问该块内存。缓冲区实际上是一个容器对象，更直接的说，其实就是一个数组，在NIO库中，所有数据都是用缓冲区处理的。在读取数据时，它是直接读到缓冲区中的；在写入数据时，它也是写入到缓冲区中的；任何时候访问NIO中的数据，都是将它放到缓冲区中。而在面向流I/O系统中，所有数据都是直接写入或者直接将数据读取到Stream对象中。
在NIO中，所有的缓冲区类型都继承于抽象类Buffer，最常用的就是ByteBuffer，对于Java中的基本类型，基本都有一个具体Buffer类型与之相对应，它们之间的继承关系如下图所示：

二、Buffer的基本用法

2.1使用Buffer读写数据，一般遵循以下四个步骤：

（1）写入数据到Buffer
（2）调用flip()方法
（3）从Buffer中读取数据
（4）调用clear()方法或者compact()方法
当向buffer写入数据时，buffer会记录下写了多少数据。一旦要读取数据，需要通过flip()方法将Buffer从写模式切换到读模式。在读模式下，可以读取之前写入到buffer的所有数据。一旦读完了所有的数据，就需要清空缓冲区，让它可以再次被写入。有两种方式能清空缓冲区：调用clear(或compact()方法。clear()方法会清空整个缓冲区。compact()方法只会清除已经读过的数据。任何未读的数据都被移到缓冲区的起始处，新写入的数据将放到缓冲区未读数据的后面。

2.2使用Buffer的例子

@Test
public void buffer01() throws Exception {
	RandomAccessFile aFile = new RandomAccessFile("e:\\java\\a.txt", "rw");
	FileChannel channel = aFile.getChannel();

	ByteBuffer buffer = ByteBuffer.allocate(1024);

	int bytesRead = channel.read(buffer);

	while (bytesRead != -1) {
		//read模式
		buffer.flip();

		while (buffer.hasRemaining()) {
			System.out.println((char)buffer.get());
		}
		buffer.clear();
		bytesRead = channel.read(buffer);
	}

	aFile.close();
}

2.3使用IntBuffer的例子

@Test
public void buffer02() {
	//创建buffer
	IntBuffer buffer = IntBuffer.allocate(8);

	for (int i = 0; i < buffer.capacity(); i++) {
		int j = 2 * (i + 1);
		buffer.put(j);
	}

	//重置缓冲区
	buffer.flip();

	//获取
	while (buffer.hasRemaining()) {
		int value = buffer.get();
		System.out.println(value + " ");
	}
}

三、Buffer的capacity、position和limit

为了理解Buffer的工作原理，需要熟悉它的三个属性：
- Capacitye
- Positione
- limit
position和limit的含义取决于Buffer处在读模式还是写模式。不管Buffer处在什么模式，capacity的含义总是一样的。
这里有一个关于capacity，position和limit在读写模式中的说明：

（1）capacity
作为一个内存块，Buffer有一个固定的大小值，也叫“capacity”。你只能往里写capacity个byte、long、char等类型。一旦Buffer满了，需要将其清空（通过读数据或者清除数据）才能继续写数据往里写数据。
（2）position
1）写数据到Buffer中时，position表示写入数据的当前位置，position的初始值为0。当一个byte、long等数据写到Buffer后，position 会向下移动到下一个可插入数据的 Buffer单元。position最大可为capacity-1（因为position的初始值为0）。
2）读数据到Buffer中时，position表示读入数据的当前位置，如position=2时表示已开始读入了3个byte，或从第3个byte开始读取。通过 ByteBuffer.flip()切换到读模式时position会被重置为0，当Buffer从 position读入数据后，position会下移到下一个可读入的数据Buffer单元。
（3）limit
1）写数据时，limit表示可对Buffer最多写入多少个数据。写模式下，limit等于Buffer的capacity。
2）读数据时，limit表示 Buffer里有多少可读数据（not null的数据），因此能读到之前写入的所有数据（limit被设置成已写数据的数量，这个值在写模式下就是
position）。

四、Buffer的类型

Java NIO有以下Buffer类型：

ByteBuffer
MappedByteBuffer
CharBuffer
DoubleBuffer
FloatBuffer
IntBuffer
LongBuffer
这些Buffer类型代表了不同的数据类型。换句话说，就是可以通过char，short，intl，ong，float或double类型来操作缓冲区中的字节。

五、Buffer分配和写数据

5.1 Buffer分配

要想获得一个Buffer对象首先要进行分配。每一个Buffer类都有一个allocate方法。
下面是一个分配48字节capacity的 ByteBuffer的例子：

ByteBuffer buf = ByteBuffer.allocate(48);

这是分配一个可存储1024个字符的CharBuffer：

CharBuffer buf = CharBuffer.allocate(1024);

5.2向Buffer中写数据

写数据到Buffer有两种方式：
(1)从Channel写到Buffer。
(2)通过Buffer的put()方法写到Buffer里。
从Channel写到Buffer的例子：

int bytesRead = inChannel.read(buf); //read into buffer

通过put方法写Buffer的例子：

buf.put(127);

put方法有很多版本，允许你以不同的方式把数据写入到Buffer中。例如，写到一个指定的位置，或者把一个字节数组写入到Buffer。

5.3 filp()方法

flip方法将Buffer从写模式切换到读模式。调用flip()方法会将position设回0，并将limit设置成之前position的值。换句话说，position现在用于标记读的位置，limit表示之前写进了多少个byte、char等（现在能读取多少个byte、char等）。

六、从Buffer中读取数据

从Buffer中读取数据有两种方式：
（1）从 Buffer读取数据到Channel。
（2）使用get()方法从Buffer中读取数据。
从Buffer读取数据到Channel的例子：

//read from buffer-into channel
int bytesWritten = inChannel.write(buf);

使用get()方法从Buffer中读取数据的例子：

byte aByte = buf.get();

get方法有很多版本，允许你以不同的方式从Buffer中读取数据。例如，从指定position读取，或者从Buffer中读取数据到字节数组。

七、Buffer几个方法

7.1 rewind()方法

Buffer.rewind()将position设回0，所以你可以重读Buffer中的所有数据。limit保持不变，仍然表示能从Buffer中读取多少个元素（byte、char等）。

7.2 clear()与compact()方法

一旦读完Buffer中的数据，需要让Buffer准备好再次被写入。可以通过clear()或compact()方法来完成。
如果调用的是clear()方法，position将被设回0，limit被设置成capacity的值。换句话说，Buffer被清空了。Buffer中的数据并未清除，只是这些标记告诉我们可以从哪里开始往Buffer里写数据。e
如果Buffer中有一些未读的数据，调用clear()方法，数据将“被遗忘”，意味着不再有任何标记会告诉你哪些数据被读过，哪些还没有。
如果Buffer中仍有未读的数据，且后续还需要这些数据，但是此时想要先写一些数据，那么使用compact()方法。
compact()方法将所有未读的数据拷贝到Buffer起始处。然后将position设到最后一个未读元素正后面。limit属性依然像clear()方法一样，设置成capacity。现在Buffer准备好写数据了，但是不会覆盖未读的数据。

7.3 mark()与reset()方法

通过调用Buffer.mark()方法，可以标记Buffer中的一个特定position。之后可以通过调用Buffer.reset()方法恢复到这个position。例如：

buffer.mark();
//call buffer.get() a couple of times, e.g. during parsing.
buffer.reset(); //set position back to mark.

八、缓冲区操作

8.1缓冲区分片

在NIO中，除了可以分配或者包装一个缓冲区对象外，还可以根据现有的缓冲区对象来创建一·个子缓冲区，即在现有缓冲区上切出一片来作为一个新的缓冲区，但现有的缓冲区与创建的子缓冲区在底层数组层面上是数据共享的，也就是说，子缓冲区相当于是现有缓冲区的一个视图窗口。调用slice()方法可以创建一个子缓冲区。

@Test
public void b01() {
	ByteBuffer buffer = ByteBuffer.allocate(10);

	for (int i = 0; i < buffer.capacity(); i++) {
		buffer.put((byte)i);
	}

	//创建子缓冲区
	buffer.position(3);
	buffer.limit(7);
	ByteBuffer slice = buffer.slice();

	//改变子缓冲区内容
	for (int i = 0; i < slice.capacity(); i++) {
		byte b = slice.get(i);
		b *= 10;
		slice.put(i, b);
	}

	buffer.position(0);
	buffer.limit(buffer.capacity());
	while (buffer.remaining() > 0) {
		System.out.println(buffer.get());
	}
}

8.2只读缓冲区

只读缓冲区非常简单，可以读取它们，但是不能向它们写入数据。可以通过调用缓冲区的asReadOnlyBuffer()方法，将任何常规缓冲区转换为只读缓冲区，这个方法返回一个与原缓冲区完全相同的缓冲区，并与原缓冲区共享数据，只不过它是只读的。如果原缓冲区的内容发生了变化，只读缓冲区的内容也随之发生变化：

@Test
public void b02() {
	ByteBuffer buffer = ByteBuffer.allocate(10);

	for (int i = 0; i < buffer.capacity(); i++) {
		buffer.put((byte)i);
	}

	//创建只读缓冲区
	ByteBuffer readOnlyBuffer = buffer.asReadOnlyBuffer();

	//改变子缓冲区内容
	for (int i = 0; i < buffer.capacity(); i++) {
		byte b = buffer.get(i);
		b *= 10;
		buffer.put(i, b);
	}

	readOnlyBuffer.position(0);
	readOnlyBuffer.limit(buffer.capacity());
	while (readOnlyBuffer.remaining() > 0) {
		System.out.println(readOnlyBuffer.get());
	}
}

8.3直接缓冲区

直接缓冲区是为加快I/O速度，使用一种特殊方式为其分配内存的缓冲区，JDK文档中的描述为：给定一个直接字节缓冲区，Java虚拟机将尽最大努力直接对它执行本机I/O操作。也就是说，它会在每一次调用底层操作系统的本机 I/O操作之前(或之后)，尝试避免将缓冲区的内容拷贝到一个中间缓冲区中或者从一个中间缓冲区中拷贝数据。要分配直接缓冲区，需要调用allocateDirect()方法，而不是allocate()方法，使用方式与普通缓冲区并无区别。
拷贝文件示例：

@Test
public void b03() throws Exception {
	String inFile = "e:\\java\\a1.txt";
	FileInputStream fin = new FileInputStream(inFile);
	FileChannel finChannel = fin.getChannel();

	String outFile = "e:\\java\\a2.txt";
	FileOutputStream fout = new FileOutputStream(outFile);
	FileChannel foutChannel = fout.getChannel();

	buffer = ByteBuffer.allocateDirect(1024);

	while (true) {
		buffer.clear();
		int r = finChannel.read(buffer);
		if (r == -1) {
			break;
		}
		buffer.flip();
		foutChannel.write(buffer);
	}
}

8.4内存映射文件I/O

内存映射文件I/O是一种读和写文件数据的方法，它可以比常规的基于流或者基于通道的I/O快的多。内存映射文件I/O是通过使文件中的数据出现为内存数组的内容来完成的，这其初听起来似乎不过就是将整个文件读到内存中，但是事实上并不是这样。一般来说，只有文件中实际读取或者写入的部分才会映射到内存中。
示例代码：

static private final int start = 0;
static private final int size = 1024;

public static void main(String[] args) throws Exception {
	RandomAccessFile raf = new RandomAccessFile("d:java\\01.txt","rw");
	FileChannel fc = raf.getChannel();
	MappedByteBuffer mbb = fc.map(FileChannel.MapMode.READ _WRITE, start, size);
	mbb.put(0, (byte)97);
	mbb.put(1023,(byte)122);
	raf.close();
}

posted @ 2021-10-07 12:52 SEVEN_CCODE 阅读(31) 评论(0) 收藏举报

刷新页面返回顶部

SEVEN_CCODE