Java NIO系列教程（三） Buffer

Java NIO系列教程（三） Buffer

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

缓冲区本质上是一块能够写入数据，而后能够从中读取数据的内存。这块内存被包装成 NIO Buffer 对象，并提供了一组方法，用来方便的访问该块内存。

1. Buffer 的基本用法

使用 Buffer 读写数据通常遵循如下四个步骤：

1. 写入数据到 Buffer
2. 调用 flip() 方法
3. 从 Buffer 中读取数据
4. 调用 clear() 方法或者 compact() 方法

当向 buffer 写入数据时，buffer 会记录下写了多少数据。一旦要读取数据，须要经过 flip() 方法将 Buffer 从写模式切换到读模式。在读模式下，能够读取以前写入到 buffer 的全部数据。

一旦读完了全部的数据，就须要清空缓冲区，让它能够再次被写入。有两种方式能清空缓冲区：调用 clear() 或 compact() 方法。clear() 方法会清空整个缓冲区。compact() 方法只会清除已经读过的数据。任何未读的数据都被移到缓冲区的起始处，新写入的数据将放到缓冲区未读数据的后面。

//1. 分配一个指定大小的缓冲区
ByteBuffer buf1= ByteBuffer.allocate(1024);
System.out.println(buf1); // [pos=0 lim=1024 cap=1024]

//2. 利用 put() 存放数据到缓冲区
buf1.put("abc".getBytes());
System.out.println(new String(buf1.array())); // abc
System.out.println(buf1); // [pos=3 lim=1024 cap=1024]

//3. buf1.put(0, (byte)'z')时position不变
buf1.put(0, (byte)'z');
System.out.println(new String(buf1.array())); // zbc
System.out.println(buf1); // [pos=3 lim=1024 cap=1024]

//4. 切换到读模式
buf1.flip();
System.out.println(buf1); // [pos=0 lim=3 cap=1024]

//5. get() 读数据，position + 1
for (int i = 0; i < buf1.limit(); i++) {
    System.out.println(buf1.get());
}
System.out.println(buf1); // [pos=3 lim=3 cap=1024]

//6. get(0) 读数据，position 不变
buf1.get(1);
System.out.println(buf1); // [pos=3 lim=3 cap=1024]

//7. rewind() 重读模式，postion = 0，limit 不变
buf1.rewind();
System.out.println(buf1); // [pos=0 lim=3 cap=1024]

//8. buf.get(bytes)读一个字节数组
byte[] bytes = new byte[buf.limit()];
buf.get(bytes);
System.out.println(new String(bytes));  //[pos=3 lim=3 cap=1024]

//9. buf.hasRemaining()
if (buf.hasRemaining()) {
   System.out.println(buf.remaining());
}

//10. buf.duplicate()
ByteBuffer buf2 = buf.duplicate();

//11. mark() 和 reset()
buf1.mark();
buf1.reset();

//12. compact() 保留未读的部分切换到时写模式
buf1.position(1).limit(3);
System.out.println(buf1); // [pos=1 lim=3 cap=1024]
buf1.compact();
System.out.println(buf1); // [pos=2 lim=1024 cap=1024]

//13. clear() 切换到时写模式
buf1.clear();
System.out.println(buf1); // [pos=0 lim=1024 cap=1024]

2. Buffer 的 capacity, position 和 limit

缓冲区本质上是一块能够写入数据，而后能够从中读取数据的内存。这块内存被包装成 NIO Buffer 对象，并提供了一组方法，用来方便的访问该块内存。

为了理解 Buffer 的工做原理，须要熟悉它的三个属性：

• capacity
• position
• limit

position 和 limit 的含义取决于 Buffer 处在读模式仍是写模式。无论 Buffer 处在什么模式，capacity 的含义老是同样的。

这里有一个关于 capacity，position 和 limit 在读写模式中的说明，详细的解释在插图后面。

Java源代码： java.nio.Buffer

// Invariants: mark <= position <= limit <= capacity
private int mark = -1;
private int position = 0;
private int limit;
private int capacity;

(1) capacity

做为一个内存块，Buffer 有一个固定的大小值，也叫 “capacity”。你只能往里写 capacity 个 byte、long，char 等类型。一旦 Buffer 满了，须要将其清空（经过读数据或者清除数据）才能继续写数据往里写数据。

(2) position

当你写数据到 Buffer 中时，position 表示当前的位置。初始的 position 值为 0。当一个 byte、long 等数据写到 Buffer 后， position 会向前移动到下一个可插入数据的 Buffer 单元。position 最大可为 capacity – 1。

当读取数据时，也是从某个特定位置读。当将 Buffer 从写模式切换到读模式，position 会被重置为 0。 当从 Buffer 的 position 处读取数据时，position 向前移动到下一个可读的位置。

(3) limit

在写模式下，Buffer 的 limit 表示你最多能往 Buffer 里写多少数据。 写模式下，limit 等于 Buffer 的 capacity。

当切换 Buffer 到读模式时， limit 表示你最多能读到多少数据。所以，当切换 Buffer 到读模式时，limit 会被设置成写模式下的 position 值。换句话说，你能读到以前写入的全部数据（limit 被设置成已写数据的数量，这个值在写模式下就是 position）。

(4) mark

标记，表示记录当前 postion 的位置。能够经过 reset 恢复到时 mark 的位置。

注：mark <= postion <= limit <= capacity

3. Buffer 的类型

Java NIO 有如下 Buffer 类型

• ByteBuffer
• MappedByteBuffer
• CharBuffer
• DoubleBuffer
• FloatBuffer
• IntBuffer
• LongBuffer
• ShortBuffer

如你所见，这些 Buffer 类型表明了不一样的数据类型。换句话说，就是能够经过 char，short，int，long，float 或 double 类型来操做缓冲区中的字节。

MappedByteBuffer 有些特别，在涉及它的专门章节中再讲。

4. Buffer 的分配

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

ByteBuffer buf = ByteBuffer.allocate(48);

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

CharBuffer buf = CharBuffer.allocate(1024);

5. 向 Buffer 中 写数据

写数据到 Buffer 有两种方式：

1. 从 Channel 写到 Buffer。
2. 经过 Buffer 的 put() 方法写到 Buffer 里。

从 Channel 写到 Buffer 的例子

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

经过 put 方法写 Buffer 的例子：

buf.put(127);

注意： buf.put(127) 和 buf.put(0， 127) 区别，前者 postion 会 +1，后者不变，buf.get() 和 buf.get(0) 相似。

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

6. flip() 方法

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

flip 方法将 Buffer 从写模式切换到读模式。调用 flip() 方法会将 position 设回 0，并将 limit 设置成以前 position 的值。

换句话说，position 如今用于标记读的位置，limit 表示以前写进了多少个 byte、char 等，如今能读取多少个 byte、char 等。

7. 从 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 中读取数据到字节数组。

8. rewind() 方法

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

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

9. clear() 与 compact() 方法

一旦读完 Buffer 中的数据，须要让 Buffer 准备好再次被写入。能够经过 clear() 或 compact() 方法来完成。

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

若是调用的是 clear() 方法，position 将被设回 0，limit 被设置成 capacity 的值。换句话说，Buffer 被清空了。Buffer 中的数据并未清除，只是这些标记告诉咱们能够从哪里开始往 Buffer 里写数据。

若是 Buffer 中有一些未读的数据，调用 clear() 方法，数据将“被遗忘”，意味着再也不有任何标记会告诉你哪些数据被读过，哪些尚未。

public ByteBuffer compact() {
    System.arraycopy(hb, ix(position()), hb, ix(0), remaining());
    position(remaining());
    limit(capacity());
    discardMark();
    return this;
}

若是 Buffer 中仍有未读的数据，且后续还须要这些数据，可是此时想要先先写些数据，那么使用 compact() 方法。

compact() 方法将全部未读的数据拷贝到 Buffer 起始处。而后将 position 设到最后一个未读元素正后面。limit 属性依然像 clear() 方法同样，设置成 capacity。如今 Buffer 准备好写数据了，可是不会覆盖未读的数据。

10. mark() 与 reset() 方法

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

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

经过调用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.

11. equals() 与 compareTo() 方法

可使用 equals() 和 compareTo() 方法两个 Buffer。

equals

当知足下列条件时，表示两个 Buffer 相等：

1. 有相同的类型（byte、char、int等）。
2. Buffer 中剩余的 byte、char 等的个数相等。
3. Buffer 中全部剩余的 byte、char 等都相同。

如你所见，equals 只是比较 Buffer 的一部分，不是每个在它里面的元素都比较。实际上，它只比较 Buffer 中的剩余元素。

compareTo

compareTo() 方法比较两个 Buffer 的剩余元素(byte、char等)， 若是知足下列条件，则认为一个 Buffer “小于”另外一个 Buffer：

1. 第一个不相等的元素小于另外一个 Buffer 中对应的元素 。
2. 全部元素都相等，但第一个 Buffer 比另外一个先耗尽(第一个Buffer的元素个数比另外一个少)。

（译注：剩余元素是从 position 到 limit 之间的元素）

转载自并发编程网 – ifeve.com，本文连接地址: Java NIO系列教程（三） Buffer