CodePlayer

第二章 缓冲区

我们以 Buffer类开始我们对java.nio软件包的浏览历程。这些类是java.nio的构造基础。在本章中，我们将深入研究缓冲区，了解各种不同的类型，并学会怎样使用。到那时我们将明了java.nio缓冲区是如何与java.nio.channels这一通道类相联系的。

一个Buffer对象是固定数量的数据的容器。其作用是一个存储器，或者分段运输区，在这里数据可被存储并在之后用于检索。缓冲区如我们在第一章所讨论的那样被写满和释放。对于每个非布尔原始数据类型都有一个缓冲区类。尽管缓冲区作用于它们存储的原始数据类型，但缓冲区十分倾向于处理字节。非字节缓冲区可以在后台执行从字节或到字节的转换，这取决于缓冲区是如何创建的。我们将在本章节后面的部分检查缓冲区数据存储的含义。

缓冲区的工作与通道紧密联系。通道是 I/O 传输发生时通过的入口，而缓冲区是这些数据传输的来源或目标。对于离开缓冲区的传输，您想传递出去的数据被置于一个缓冲区，被传送到通道。对于传回缓冲区的传输，一个通道将数据放置在您所提供的缓冲区中。这种在协同对象(通常是您所写的对象以及一到多个Channel对象之间进行的缓冲区数据传递是高效数据处理的关键。通道将在第三章被详细涉及。

图 2-1 是 Buffer的类层次图。在顶部是通用Buffer类(抽象父类)。Buffer定义所有缓冲区类型共有的操作，无论是它们所包含的数据类型还是可能具有的特定行为。这一共同点将会成为我们的出发点。

2.1 缓冲区基础

概念上，缓冲区是包在一个对象内的基本数据元素数组。Buffer类相比一个简单数组的优点是它将关于数据的数据内容和信息包含在一个单一的对象中。Buffer类以及它专有的子类定义了一个用于处理数据缓冲区的 API。

2.1.1 属性

所有的缓冲区都具有四个属性来提供关于其所包含的数据元素的信息。它们是：

容量(Capacity)

缓冲区能够容纳的数据元素的最大数量。这一容量在缓冲区创建时被设定，并且永远不能被改变。

上界(Limit)

缓冲区的第一个不能被读或写的元素。或者说，缓冲区中现存元素的计数。

位置(Position)

下一个要被读或写的元素的索引。位置会自动由相应的 get()和 put()函数更新。

标记(Mark)

一个备忘位置。调用 mark()来设定 mark = postion。调用 reset()设定 position = mark。标记在设定前是未定义的( undefined)。

这四个属性之间总是遵循以下关系：

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

让我们来看看这些属性在实际应用中的一些例子。图 2-2 展示了一个新创建的容量为10的 ByteBuffer逻辑视图。

位置被设为 0，而且容量和上界被设为 10，刚好经过缓冲区能够容纳的最后一个字节。标记最初未定义。容量是固定的，但另外的三个属性可以在使用缓冲区时改变。

2.1.2 缓冲区 API

让我们来看一下可以如何使用一个缓冲区。以下是 Buffer 类的方法签名：

package java.nio;
public abstract class Buffer {
	public final int capacity();
	public final int position();
	public final Buffer position (int newPosition);
	public final int limit();
	public final Buffer limit (int newLimit);
	public final Buffer mark();
	public final Buffer reset();
	public final Buffer clear();
	public final Buffer flip();
	public final Buffer rewind();
	public final int remaining();
	public final boolean hasRemaining();
	public abstract boolean isReadOnly();
}

关于这个API有一点要注意的是，像clear()这类函数，您通常应当返回void，而不是Buffer引用。这些函数将引用返回到它们在(this)上被引用的对象。这是一个允许级联调用的类设计方法。级联调用允许这种类型的代码：

buffer.mark();
buffer.position(5);
buffer.reset();

被简写为：

buffer.mark().position(5).reset();

java.nio中的类被特意地设计为支持级联调用。您可能已经在StringBuffer类中看到了级联调用的使用。;

如果聪明地使用级联调用，就能产生简洁，优美，易读的代码。但如果滥用，就会使代码不知所云。当级联调用可以增加可读性并使让您的目标更加明确时使用它。如果使 用级联调用会使代码作用不够清晰，那么请不要使用它。请时刻保证您的代码易于他人阅读。

对于 API还要注意的一点是isReadOnly()函数。所有的缓冲区都是可读的，但并非所有都可写。每个具体的缓冲区类都通过执行isReadOnly()来标示其是否允许该缓存区的内容被修改。一些类型的缓冲区类可能未使其数据元素存储在一个数组中 。例如MappedByteBuffer的内容可能实际是一个只读文件。您也可以明确地创建一个只读视图缓冲区，来防止对内容的意外修改。对只读的缓冲区的修改尝试将会导致ReadOnlyBufferException抛出。但是我们要提前做好准备。

2.1.3 存取

让我们从起点开始。缓冲区管理着固定数目的数据元素。但在任何特定的时刻，我们可能只对缓冲区中的一部分元素感兴趣。换句话说，在我们想清空缓冲区之前，我们可能只使用了缓冲区的一部分。这时，我们需要能够追踪添加到缓冲区内的数据元素的数量，放入下一个元素的位置等等的方法。位置属性做到了这一点。它在调用put()时指出了下一个数据元素应该被插入的位置，或者当get()被调用时指出下一个元素应从何处检索。聪明的读者会注意到上文所列出的的 Buffer API 并没有包括get()或put()函数。每一个Buffer类都有这两个函数，但它们所采用的参数类型，以及它们返回的数据类型，对每个子类来说都是唯一的，所以它们不能在顶层Buffer类中被抽象地声明。它们的定义必须被特定类型的子类所遵从。对于这一讨论，我们将假设使用具有这里所给出的函数的 ByteBuffer类【get()和put()还有更多的形式，我们将在 2.1.10 小节中进行讨论】：

public abstract class ByteBuffer extends Buffer implements Comparable
{
// 这里是部分API列表
public abstract byte get();
public abstract byte get (int index);
public abstract ByteBuffer put (byte b);
public abstract ByteBuffer put (int index, byte b);
}

get和put可以是相对的或者是绝对的。在前面的程序列表中，相对方案是不带有索引参数的函数。当相对函数被调用时，位置在返回时前进一。如果位置前进过多，相对运算就会抛出异常。对于put()，如果运算会导致位置超出上界 ， 就会抛出BufferOverflowException异常。对于get()，如果位置不小于上界，就会抛出BufferUnderflowException异常。绝对存取不会影响缓冲区的位置属性，但是如果您所提供的索引超出范围(负数或不小于上界)，也将抛出IndexOutOfBoundsException异常。

2.1.4 填充

让我们看一个例子。我们将代表“Hello”字符串的 ASCII 码载入一个名为 buffer 的ByteBuffer对象中。当在图 2.2 所新建的缓冲区上执行以下代码后，缓冲区的结果状态如图 2.3 所示：

buffer.put((byte)'H').put((byte)'e').put((byte)'l').put((byte)'l').put((byte)'o');

注意本例中的每个字符都必须被强制转换为 byte。我们不能不经强制转换而这样操作：

buffer.put('H');

因为我们存放的是字节而不是字符。记住在 java 中，字符在内部以 Unicode 码表示，每个 Unicode 字符占 16 位。本章节的例子使用包含 ascii 字符集数值的字节。通过将char 强制转换为 byte，我们删除了前八位来建立一个八位字节值。这通常只适合于拉丁字符而不能适合所有可能的 Unicode 字符。为了让事情简化，我们暂时故意忽略字符集的映射问题。第六章中将详细涉及字符编码。

既然我们已经在 buffer 中存放了一些数据，如果我们想在不丢失位置的情况下进行一些更改该怎么办呢？put()的绝对方案可以达到这样的目的。假设我们想将缓冲区中的内容从“Hello”的 ASCII 码更改为“Mellow”。我们可以这样实现：

buffer.put(0,(byte)'M').put((byte)'w');

这里通过进行一次绝对方案的put将0位置的字节代替为十六进制数值0x4d，将0x77放入当前位置(当前位置不会受到绝对 put()的影响)的字节，并将位置属性加一。结果如图 2.4 所示。

2.1.5 翻转

我们已经写满了缓冲区，现在我们必须准备将其清空。我们想把这个缓冲区传递给一个通道，以使内容能被全部写出。但如果通道现在在缓冲区上执行get()，那么它将从我们刚刚插入的有用数据之外取出未定义数据。如果我们将位置值重新设为 0，通道就会从正确位置开始获取，但是它是怎样知道何时到达我们所插入数据末端的呢？这就是上界属性被引入的目的。上界属性指明了缓冲区有效内容的末端。我们需要将上界属性设置为当前位置，然后将位置重置为 0。我们可以人工用下面的代码实现：

buffer.limit(buffer.position()).position(0);

但这种从填充到释放状态的缓冲区翻转是 API 设计者预先设计好的，他们为我们提供了一个非常便利的函数：

Buffer.flip();

flip()函数将一个能够继续添加数据元素的填充状态的缓冲区翻转成一个准备读出元素的释放状态。在翻转之后，图 2.4 的缓冲区会变成图 2.5 中的样子。

rewind()函数与flip()相似，但不影响上界属性。它只是将位置值设回 0。您可以使用rewind()后退，重读已经被翻转的缓冲区中的数据。

如果将缓冲区翻转两次会怎样呢？它实际上会大小变为 0。按照图 2.5 的相同步骤对缓冲区进行操作；把上界设为位置的值，并把位置设为 0。上界和位置都变成 0。尝试对缓冲区上位置和上界都为 0 的 get()操作会导致BufferUnderflowException异常。而 put()则会导致 BufferOverflowException 异常。

2.1.6 释放

如果我们现在将图 2.5 中的缓冲区传入通道，它将取出我们存放在那里的数据，从位置开始直到上界结束。很简单，不是吗？

同样地，如果您接收到一个在别处被填满的缓冲区，您可能需要在检索内容之前将其翻转。例如，如果一个通道的read()操作完成，而您想要查看被通道放入缓冲区内的数据，那么您需要在调用get()之前翻转缓冲区。通道对象在缓冲区上调用put()增加数据；put()和read()可以随意混合使用。

布尔函数hasRemaining()会在释放缓冲区时告诉您是否已经达到缓冲区的上界。以下是一种将数据元素从缓冲区释放到一个数组的方法(在 2.1.10 小节中，我们将学到进行批量传输的更高效的方法)。

for (int i = 0; buffer.hasRemaining(), i++) {
	myByteArray [i] = buffer.get();
}

作为选择，remaining()函数将告知您从当前位置到上界还剩余的元素数目。您也可以通过下面的循环来释放图 2-5 所示的缓冲区。

int count = buffer.remaining();
for (int i = 0; i < count, i++) {
	myByteArray [i] = buffer.get();
}

如果您对缓冲区有专门的控制，这种方法会更高效，因为上界不会在每次循环重复时都被检查(这要求调用一个buffer样例程序)。上文中的第一个例子允许多线程同时从缓冲区释放元素。

缓冲区并不是多线程安全的。如果您想以多线程同时存取特定的缓冲区，您需要在存取缓冲区之前进行同步(例如对缓冲区对象进行跟踪)。

一旦缓冲区对象完成填充并释放，它就可以被重新使用了。clear()函数将缓冲区重置为空状态。它并不改变缓冲区中的任何数据元素，而是仅仅将上界设为容量的值，并把位置设回 0，如图 2.2 所示。这使得缓冲区可以被重新填入。参见示例 2.1。

例 2.1 填充和释放缓冲区

package com.ronsoft.books.nio.buffers;
import java.nio.CharBuffer;
/**
* Buffer fill/drain example. This code uses the simplest
* means of filling and draining a buffer: one element at
* a time.
* @author Ron Hitchens (ron@ronsoft.com)
*/
public class BufferFillDrain{

public static void main (String [] argv) throws Exception{
	CharBuffer buffer = CharBuffer.allocate (100);
	while (fillBuffer(buffer)) {
		buffer.flip();
		drainBuffer(buffer);
		buffer.clear();
	}
}

private static void drainBuffer (CharBuffer buffer){
	while (buffer.hasRemaining()) {
		System.out.print (buffer.get());
	}
	System.out.println ("");
}

private static boolean fillBuffer (CharBuffer buffer){
	if (index >= strings.length) {
		return (false);
	}
	String string = strings [index++];
	for (int i = 0; i < string.length(); i++) {
		buffer.put (string.charAt (i));
	}
	return true;
}

private static int index = 0;
private static String [] strings = {
	"A random string value",
	"The product of an infinite number of monkeys",
	"Hey hey we're the Monkees",
	"Opening act for the Monkees: Jimi Hendrix",
	"'Scuse me while I kiss this fly",  
	"Help Me! Help Me!",
	};
}

2.1.7 压缩

public abstract class ByteBuffer extends Buffer implements Comparable
{
// 这里仅列出部分API
public abstract ByteBuffer compact();
}

有时，您可能只想从缓冲区中释放一部分数据，而不是全部，然后重新填充。为了实现这一点，未读的数据元素需要下移以使第一个元素索引为 0。尽管重复这样做会效率低下，但这有时非常必要，而 API 对此为您提供了一个compact()函数。这一缓冲区工具在复制数据时要比您使用get()和put()函数高效得多。所以当您需要时，请使用compact()。图 2.6显示了一个我们已经释放了一些元素，并且现在我们想要对其进行压缩的缓冲区。

这样操作：

buffer.compact();

会导致缓冲区的状态如图 2-7 所示：

这里发生了几件事。您会看到数据元素 2-5 被复制到 0-3 位置。位置 4 和 5 不受影响，但现在正在或已经超出了当前位置，因此是“死的”。它们可以被之后的 put()调用重写。还要注意的是，位置已经被设为被复制的数据元素的数目。也就是说，缓冲区现在被定位在缓冲区中最后一个“存活”元素后插入数据的位置。最后，上界属性被设置为容量的值，因此缓冲区可以被再次填满。调用compact()的作用是丢弃已经释放的数据，保留未释放的数据，并使缓冲区对重新填充容量准备就绪。您可以用这种类似于先入先出(FIFO)队列的方式使用缓冲区。当然也存在更高效的算法(缓冲区移位并不是一个处理队列的非常高效的方法)。但是压缩对于使缓冲区与您从端口中读入的数据(包)逻辑块流的同步来说也许是一种便利的方法。

如果您想在压缩后释放数据，缓冲区会像之前所讨论的那样需要被翻转。无论您之后是否要向缓冲区中添加新的数据，这一点都是必要的。

2.1.8 标记

这本章节的开头，我们已经涉及了缓冲区四种属性中的三种。第四种，标记，使缓冲区能够记住一个位置并在之后将其返回。缓冲区的标记在mark()函数被调用之前是未定义的，调用时标记被设为当前位置的值。reset()函数将位置设为当前的标记值。如果标记值未定义，调用reset()将导致InvalidMarkException异常。一些缓冲区函数会抛弃已经设定的标记(rewind()，clear()，以及 flip()总是抛弃标记)。如果新设定的值比当前的标记小，调用limit()或 position()带有索引参数的版本会抛弃标记。

注意不要混淆 reset()和 clear()。clear()函数将清空缓冲区，而reset()位置返回到一个先前设定的标记。

让我们看看这是如何进行的。在图 2.5 的缓冲区上执行以下代码将会导致图 2-8 所显示的缓冲区状态。

buffer.position(2).mark().position(4);

如果这个缓冲区现在被传递给一个通道，两个字节(“ow”)将会被发送，而位置会前进到 6。如果我们此时调用reset()，位置将会被设为标记，如图 2-9 所示。再次将缓冲区传递给通道将导致四个字节(“llow”)被发送。

结果可能没什么意义(owllow 会被写入通道)，但您了解了概念。

2.1.9 比较

有时候比较两个缓冲区所包含的数据是很有必要的。所有的缓冲区都提供了一个常规的equals()函数用以测试两个缓冲区的是否相等，以及一个compareTo()函数用以比较缓冲区。

public abstract class ByteBuffer extends Buffer implements Comparable
{
// 这里仅列出部分API
public boolean equals (Object ob);
public int compareTo (Object ob);
}

两个缓冲区可用下面的代码来测试是否相等：

if (buffer1.equals (buffer2)) {
	doSomething();
}

如果每个缓冲区中剩余的内容相同，那么 equals()函数将返回true，否则返回false，因为这个测试是用于严格的相等而且是可换向的。前面的程序清单中的缓冲区名称可以颠倒，并会产生相同的结果。两个缓冲区被认为相等的充要条件是：

• 两个对象类型相同。包含不同数据类型的buffer永远不会相等，而且buffer绝不会等于非buffer对象。
• 两个对象都剩余同样数量的元素。Buffer的容量不需要相同，而且缓冲区中剩余数据的索引也不必相同。但每个缓冲区中剩余元素的数目(从位置到上界)必须相同。
• 在每个缓冲区中应被get()函数返回的剩余数据元素序列必须一致。

如果不满足以上任意条件，就会返回 false。

图 2-10 说明了两个属性不同的缓冲区也可以相等。

图 2-11 显示了两个相似的缓冲区，可能看起来是完全相同的缓冲区，但测试时会发现并不相等。

缓冲区也支持用compareTo()函数以词典顺序进行比较。这一函数在缓冲区参数小于，等于，或者大于引用compareTo()的对象实例时，分别返回一个负整数，0 和正整数。这些就是所有典型的缓冲区所实现的java.lang.Comparable接口语义。这意味着缓冲区数组可以通过调用 java.util.Arrays.sort()函数按照它们的内容进行排序。

与equals()相似，compareTo()不允许不同对象间进行比较。但compareTo()更为严格：如果您传递一个类型错误的对象，它会抛出ClassCastException异常，但equals()只会返回false。

比较是针对每个缓冲区内剩余数据进行的，与它们在equals()中的方式相同，直到不相等的元素被发现或者到达缓冲区的上界。如果一个缓冲区在不相等元素发现前已经被耗尽，较短的缓冲区被认为是小于较长的缓冲区。不像equals()，compareTo()不可交换：顺序问题。在本例中，一个小于零的结果表明 buffer2小于buffer1，而表达式的值就会是true：

if (buffer1.compareTo (buffer2) < 0) {
	doSomething();
}

如果前面的代码被应用到图 2-10 所示的缓冲区中，结果会是0，而 if 语句将毫无用处。被应用到图 2-11 的缓冲区的相同测试将会返回一个正数(表明 buffer2大于buffer1)，而这个表达式也会被判断为 false。

2.1.10 批量移动

缓冲区的涉及目的就是为了能够高效传输数据。一次移动一个数据元素，如例 2-1 所示的那样并不高效。如您在下面的程序清单中所看到的那样，buffer API 提供了向缓冲区内外批量移动数据元素的函数。

public abstract class CharBuffer extends Buffer implements CharSequence, Comparable
{
// This is a partial API listing
public CharBuffer get (char [] dst)
public CharBuffer get (char [] dst, int offset, int length)
public final CharBuffer put (char[] src)
public CharBuffer put (char [] src, int offset, int length)
public CharBuffer put (CharBuffer src)
public final CharBuffer put (String src)
public CharBuffer put (String src, int start, int end)
}

有两种形式的 get()可供从缓冲区到数组进行的数据复制使用。第一种形式只将一个数组作为参数，将一个缓冲区释放到给定的数组。第二种形式使用 offset 和 length 参数来指定目标数组的子区间。这些批量移动的合成效果与前文所讨论的循环是相同的，但是这些方法可能高效得多，因为这种缓冲区实现能够利用本地代码或其他的优化来移动数据。批量移动总是具有指定的长度。也就是说，您总是要求移动固定数量的数据元素。当参看程序签名时这一点还不明显，但是对get()的这一引用：

buffer.get(myArray);

等价于：

buffer.get(myArray,0,myArray.length);

如果您所要求的数量的数据不能被传送，那么不会有数据被传递，缓冲区的状态保持不变，同时抛出BufferUnderflowException异常。因此当您传入一个数组并且没有指定长

度，您就相当于要求整个数组被填充。如果缓冲区中的数据不够完全填满数组，您会得到一个异常。这意味着如果您想将一个小型缓冲区传入一个大型数组，您需要明确地指定缓冲区中剩余的数据长度。上面的第一个例子不会如您第一眼所推出的结论那样，将缓冲区内剩余的数据元素复制到数组的底部。要将一个缓冲区释放到一个大数组中，要这样做：

char [] bigArray = new char [1000];
// Get count of chars remaining in the buffer
int length = buffer.remaining();
// Buffer is known to contain < 1,000 chars
buffer.get (bigArrray, 0, length);
// Do something useful with the data
processData (bigArray, length);

记住在调用get()之前必须查询缓冲区中的元素数量(因为我们需要告知processData()被放置在bigArray中的字符个数)。调用get()会向前移动缓冲区的位置属性，所以之后调用remaining()会返回 0。get()的批量版本返回缓冲区的引用，而不是被传送的数据元素的计数，以减轻级联调用的困难。另一方面，如果缓冲区存有比数组能容纳的数量更多的数据，您可以重复利用如下文所示的程序块进行读取：

char [] smallArray = new char [10];
while (buffer.hasRemaining()) {
	int length = Math.min (buffer.remaining(), smallArray.length);
	buffer.get (smallArray, 0, length);
	processData (smallArray, length);
}

put()的批量版本工作方式相似，但以相反的方向移动数据，从数组移动到缓冲区。他们在传送数据的大小方面有着相同的语义：

buffer.put(myArray);

等价于：

buffer.put(myArray,0,myArray.length);

批量传输的大小总是固定的。省略长度意味着整个数组会被填满。

如果缓冲区有足够的空间接受数组中的数据(buffer.remaining()>myArray.length)，数据将会被复制到从当前位置开始的缓冲区，并且缓冲区位置会被提前所增加数据元素的数量。如果缓冲区中没有足够的空间，那么不会有数据被传递，同时抛出一个BufferOverflowException异常。

也可以通过调用带有一个缓冲区引用作为参数的put()来在两个缓冲区内进行批量传递。

buffer.put(srcBuffer);

这等价于(假设 dstBuffer 有足够的空间)：

while (srcBuffer.hasRemaining()) {
	dstBuffer.put (srcBuffer.get());
}

两个缓冲区的位置都会前进所传递的数据元素的数量。范围检查会像对数组一样进行。具体来说，如果srcBuffer.remaining()大于 dstBuffer.remaining()，那么数据不会被传递，同时抛出BufferOverflowException异常。如果您对将一个缓冲区传递给它自己，就会引发 java.lang.IllegalArgumentException 异常。

在这一章节中我一直使用 CharBuffer 为例，而且到目前为止，这一讨论也已经应用到了其他的典型缓冲区上，比如 FloatBuffer，LongBuffer，等等。但是在下面的 API 程序清单的最后两个函数中包含了两个只对CharBuffer适用的批量移动函数。

public abstract class CharBuffer extends Buffer implements CharSequence, Comparable
{
// 这里仅列出部分API
public final CharBuffer put (String src)
public CharBuffer put (String src, int start, int end)
}

这些函数使用 String 作为参数，而且与作用于 char 数组的批量移动函数相似。如所有的 java 程序员所知，String 不同于 char 数组。但 String 确实包含 char 字符串，而且我们人类确实倾向于将其在概念上认为是 char 数组(尤其是我们中曾经是或者现在还是 C 或C++程序员的那些人)。由于这些原因，CharBuffer 类提供了将 String 复制到CharBuffer 中的便利方法。

String 移动与 char 数组移动相似，除了在序列上是由 start 和 end+1 下标确定(与String.subString()类似)，而不是 start 下标和 length。所以：

buffer.put(myString);

等价于：

buffer.put(myString,0,myString.length);

而这就是您怎样复制字符 5-8，总共四个字符，从 myString 复制到 buffer。

buffer.put(myString,5,9);

String 批量移动等效于下面的代码：

for (int i = start; i < end; i++) {
	buffer.put (myString.charAt (i));
}

对String要进行与char数组相同的范围检查。如果所有的字符都不适合缓冲区，将会抛出BufferOverflowException异常。

Java nio入门教程详解(五)