Java NIO 缓冲区

2019独角兽企业重金招聘Python工程师标准>>>

第二章 缓冲区

一切都是相对的。
——伟大的阿尔伯特·爱因斯坦
我们以 Buffer 类开始我们对 java.nio 软件包的浏览历程。这些类是 java.nio 的构
造基础。在本章中，我们将深入研究缓冲区，了解各种不同的类型，并学会怎样使用。到那时
我们将明了 java.nio 缓冲区是如何与 java.nio.channels 这一通道类相联系的。
一个Buffer对象是固定数量的数据的容器。其作用是一个存储器，或者分段运输区，在
这里数据可被存储并在之后用于检索。缓冲区如我们在第一章所讨论的那样被写满和释放。对
于每个非布尔原始数据类型都有一个缓冲区类。尽管缓冲区作用于它们存储的原始数据类型，
但缓冲区十分倾向于处理字节。非字节缓冲区可以在后台执行从字节或到字节的转换，这取决
于缓冲区是如何创建的 2
。我们将在本章节后面的部分检查缓冲区数据存储的含义。
缓冲区的工作与通道紧密联系。通道是 I/O 传输发生时通过的入口，而缓冲区是这些数
据传输的来源或目标。对于离开缓冲区的传输，您想传递出去的数据被置于一个缓冲区，被传
送到通道。对于传回缓冲区的传输，一个通道将数据放置在您所提供的缓冲区中。这种在协同
对象（通常是您所写的对象以及一到多个 Channel 对象）之间进行的缓冲区数据传递是高效
数据处理的关键。通道将在第三章被详细涉及。
图 2-1 是 Buffer 的类层次图。在顶部是通用 Buffer 类。Buffer 定义所有缓冲区类
型共有的操作，无论是它们所包含的数据类型还是可能具有的特定行为。这一共同点将会成为
我们的出发点。
图 2-1. 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 newPositio
 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 
{ 
 // This is a partial API listing 
 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", // Sorry Jimi ;-) 
 "Help Me! Help Me!", 
 }; 
} 

 

 

2.1.7 压缩

public abstract class ByteBuffer 
 extends Buffer implements Comparable 
{ 
 // This is a partial API listing 
 public abstract ByteBuffer compact( ); 
}

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

这里发生了几件事。您会看到数据元素 2-5 被复制到 0-3 位置。位置 4 和 5 不受影响，但现在正在或已经超出了当前位置，因此是“死的”。它们可以被之后的 put()调用重写。还要注意的是，位置已经被设为被复制的数据元素的数目。也就是说，缓冲区现在被定位在缓冲区中最后一个“存活”元素后插入数据的位置。最后，上界属性被设置为容量的值，因此缓冲区可以被再次填满。调用 compact()的作用是丢弃已经释放的数据，保留未释放的数据，并使缓冲区对重新填充容量准备就绪

您可以用这种类似于先入先出（FIFO）队列的方式使用缓冲区。当然也存在更高效的算法（缓冲区移位并不是一个处理队列的非常高效的方法）。但是压缩对于使缓冲区与您从端口中读入的数据（包）逻辑块流的同步来说也许是一种便利的方法。

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

2.1.8 标记

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

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

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

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

2.1.9 比较

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

public abstract class ByteBuffer 
 extends Buffer implements Comparable 
{ 
 // This is a partial API listing 
 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 显示了两个相似的缓冲区，可能看起来是完全相同的缓冲区，但测试时会发现并不相等

图 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 
{ 
 // This is a partial API listing 
 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 异常。

2.2 创建缓冲区

就像我们在图 2-1 所看到的那样，有七种主要的缓冲区类，每一种都具有一种 Java 语言中的非布尔类型的原始类型数据。（第 8 种也在图中显示出来，MappedByteBuffer，是ByteBuffer 专门用于内存映射文件的一种特例。我们将会在第三章讨论内存映射）。这些类没有一种能够直接实例化。它们都是抽象类，但是都包含静态工厂方法用来创建相应类的新实例。

对于这一讨论，我们将以 CharBuffer 类为例，但是对于其它六种主要的缓冲区类也是适用的：IntBuffer，DoubleBuffer，ShortBuffer，LongBuffer，FloatBuffer，和 ByteBuffer。下面是创建一个缓冲区的关键函数，对所有的缓冲区类通用（要按照需要替换类名）：

public abstract class CharBuffer 
 extends Buffer implements CharSequence, Comparable 
{ 
 // This is a partial API listing 
 public static CharBuffer allocate (int capacity) 
 public static CharBuffer wrap (char [] array) 
 public static CharBuffer wrap (char [] array, int offset, 
 int length) 
 public final boolean hasArray( ) 
 public final char [] array( ) 
 public final int arrayOffset( ) 
}

新的缓冲区是由分配或包装操作创建的。分配操作创建一个缓冲区对象并分配一个私有的空间来储存容量大小的数据元素。包装操作创建一个缓冲区对象但是不分配任何空间来储存数据元素。它使用您所提供的数组作为存储空间来储存缓冲区中的数据元素。

要分配一个容量为 100 个 char 变量的 Charbuffer:

CharBuffer charBuffer = CharBuffer.allocate (100);

这段代码隐含地从堆空间中分配了一个 char 型数组作为备份存储器来储存 100 个 char变量

如果您想提供您自己的数组用做缓冲区的备份存储器，请调用 wrap()函数：
char [] myArray = new char [100];
CharBuffer charbuffer = CharBuffer.wrap (myArray);

这段代码构造了一个新的缓冲区对象，但数据元素会存在于数组中。这意味着通过调用put()函数造成的对缓冲区的改动会直接影响这个数组，而且对这个数组的任何改动也会对这个缓冲区对象可见。带有 offset 和 length 作为参数的 wrap()函数版本则会构造一个按照您提供的 offset 和 length 参数值初始化位置和上界的缓冲区。这样做：

CharBuffer charbuffer = CharBuffer.wrap (myArray, 12, 42);

创建了一个 position 值为 12，limit 值为 54，容量为 myArray.length 的缓冲区。

这个函数并不像您可能认为的那样，创建了一个只占用了一个数组子集的缓冲区。这个缓冲区可以存取这个数组的全部范围；offset 和 length 参数只是设置了初始的状态。调用使用上面代码中的方法创建的缓冲区中的 clear()函数，然后对其进行填充，直到超过上界值，这将会重写数组中的所有元素。Slice()函数（2.3 节将会讨论）可以提供一个只占用备份数组一部分的缓冲区

通过 allocate()或者 wrap()函数创建的缓冲区通常都是间接的（直接缓冲区会在2.4.2 节讨论）。间接的缓冲区使用备份数组，像我们之前讨论的，您可以通过上面列出的API 函数获得对这些数组的存取权。Boolean 型函数 hasArray()告诉您这个缓冲区是否有一个可存取的备份数组。如果这个函数的返回 true，array()函数会返回这个缓冲区对象所使用的数组存储空间的引用。

如果 hasArray()函数返回 false，不要调用 array()函数或者 arrayOffset()函数。如果您这样做了您会得到一个 UnsupportedOperationException 异常。如果一个缓冲区是只读的，它的备份数组将会是超出上界的，即使一个数组对象被提供给 wrap()函数。调用 array()函数或者 arrayOffset()会抛出一个 ReadOnlyBufferException 异常，来阻止您得到存取权来修改只读缓冲区的内容。如果您通过其它的方式获得了对备份数组的存取权限，对这个数组的修改也会直接影响到这个只读缓冲区。只读缓冲区将会在 2.3 节讨论。

最后一个函数，arrayOffset()，返回缓冲区数据在数组中存储的开始位置的偏移量（从数组头 0 开始计算）。如果您使用了带有三个参数的版本的 wrap()函数来创建一个缓冲区，对于这个缓冲区，arrayOffset()会一直返回 0，像我们之前讨论的那样。然而，如果您切分了由一个数组提供存储的缓冲区，得到的缓冲区可能会有一个非 0 的数组偏移量。这个数组偏移量和缓冲区容量值会告诉您数组中哪些元素是被缓冲区使用的。缓冲区的切分会在2.3 节讨论。
到现在为止，这一节所进行的讨论已经针对了所有的缓冲区类型。我们用来做例子的CharBuffer 提供了一对其它缓冲区类没有的有用的便捷的函数：

public abstract class CharBuffer 
 extends Buffer implements CharSequence, Comparable 
{ 
 // This is a partial API listing 
38
 public static CharBuffer wrap (CharSequence csq) 
 public static CharBuffer wrap (CharSequence csq, int start, 
 int end) 
}

Wrap()函数创建一个只读的备份存储区是 CharSequence 接口或者其实现的的缓冲区对象。（CharSequence 对象将在第五章讨论）。Charsequence 描述了一个可读的字符流。像 JDK1.4 中，三个标准的实现了 Charsequence 接口的类： String ，StringBuffer，和 CharBuffer。Wrap()函数可以很实用地“缓冲”一个已有的字符数据，通过缓冲区的 API 来存取其中的内容。对于字符集解码（第六章）和正则表达式处理（第五章）这将是非常方便的。

CharBuffer charBuffer = CharBuffer.wrap ("Hello World");
三个参数的 wrap()函数版本使用 start 和 end 下标参数来描述传入的 CharSequence对象的子序列。这是一个方便的类似于调用了 CharSequence.subsequence()函数的转换。Start 参数是序列中使用的第一个字符，end 是最后一个字符的下标值加 1。

2.4 字节缓冲区

在本章节中，我们将进一步观察字节缓冲区。所有的基本数据类型都有相应的缓冲区类（布尔型除外），但字节缓冲区有自己的独特之处。字节是操作系统及其 I/O 设备使用的基本数据类型。当在 JVM 和操作系统间传递数据时，将其他的数据类型拆分成构成它们的字节是十分必要的。如我们在后面的章节中将要看到的那样，系统层次的 I/O 面向字节的性质可以在整个缓冲区的设计以及它们互相配合的服务中感受到

为了提供参考，以下是 ByteBuffer 的完整 API。这些函数有些已经在前面的章节中讨论，并且仅仅是针对具体类型的版本。新的函数将在本节以及后面的章节中涉及。

package java.nio; 
public abstract class ByteBuffer extends Buffer 
 implements Comparable 
{ 
 public static ByteBuffer allocate (int capacity) 
 public static ByteBuffer allocateDirect (int capacity) 
 public abstract boolean isDirect( ); 
 public static ByteBuffer wrap (byte[] array, int offset, int length) 
 public static ByteBuffer wrap (byte[] array) 
 public abstract ByteBuffer duplicate( ); 
41
 public abstract ByteBuffer asReadOnlyBuffer( ); 
 public abstract ByteBuffer slice( ); 
 public final boolean hasArray( ) 
 public final byte [] array( ) 
 public final int arrayOffset( ) 
 public abstract byte get( ); 
 public abstract byte get (int index); 
 public ByteBuffer get (byte[] dst, int offset, int length) 
 public ByteBuffer get (byte[] dst, int offset, int length) 
 public abstract ByteBuffer put (byte b); 
 public abstract ByteBuffer put (int index, byte b); 
 public ByteBuffer put (ByteBuffer src) 
 public ByteBuffer put (byte[] src, int offset, int length) 
 public final ByteBuffer put (byte[] src) 
 public final ByteOrder order( ) 
 public final ByteBuffer order (ByteOrder bo)
 public abstract CharBuffer asCharBuffer( ); 
 public abstract ShortBuffer asShortBuffer( ); 
 public abstract IntBuffer asIntBuffer( ); 
 public abstract LongBuffer asLongBuffer( ); 
 public abstract FloatBuffer asFloatBuffer( ); 
 public abstract DoubleBuffer asDoubleBuffer( ); 
 public abstract char getChar( ); 
 public abstract char getChar (int index); 
 public abstract ByteBuffer putChar (char value); 
 public abstract ByteBuffer putChar (int index, char value); 
 public abstract short getShort( ); 
 public abstract short getShort (int index); 
 public abstract ByteBuffer putShort (short value); 
 public abstract ByteBuffer putShort (int index, short value); 
 public abstract int getInt( ); 
 public abstract int getInt (int index); 
 public abstract ByteBuffer putInt (int value); 
 public abstract ByteBuffer putInt (int index, int value);
 public abstract long getLong( ); 
 public abstract long getLong (int index); 
 public abstract ByteBuffer putLong (long value); 
 public abstract ByteBuffer putLong (int index, long value);
public abstract float getFloat( ); 
public abstract float getFloat (int index); 
public abstract ByteBuffer putFloat (float value); 
 public abstract ByteBuffer putFloat (int index, float value); 
 
public abstract double getDouble( ); 
 public abstract double getDouble (int index); 
 public abstract ByteBuffer putDouble (double value); 
 public abstract ByteBuffer putDouble (int index, double value); 
 
public abstract ByteBuffer compact( ); 
 public boolean equals (Object ob) { 
 public int compareTo (Object ob) { 
 public String toString( ) 
 public int hashCode( )
}

2.4.1 字节顺序
非字节类型的基本类型，除了布尔型 都是由组合在一起的几个字节组成的。这些数据类型及其大小总结在表 2-1 中。

每个基本数据类型都是以连续字节序列的形式存储在内存中。例如，32 位的 int 值0x037fb4c7（十进制的 58,700,999）可能会如图 2-14 所显示的那样被塞入内存字节中（内存地址从左往右增加）。注意前一个句子中的“可能”一词。尽管字节大小已经被确定，但字节顺序问题一直没有被广泛认同。表示一个整型值的字节可能在内存中仅仅如图 2-15 所示的那样被简单地排列

多字节数值被存储在内存中的方式一般被称为 endian-ness（字节顺序）。如果数字数值的最高字节——big end（大端），位于低位地址，那么系统就是大端字节顺序（如图 2-14 所示）。如果最低字节最先保存在内存中，那么小端字节顺序（如图 2-15 所示）。字节顺序很少由软件设计者决定；它通常取决于硬件设计。字节顺序的两种类型有时被称为字节性别，在当今被广泛使用。两种方式都具有自身的优势。Intel 处理器使用小端字节顺序涉及。摩托罗拉的 CPU 系列、SUN 的 Sparc 工作站，以及 PowerPC 的 CPU 架构都采用大端字节顺序。
字节顺序的问题甚至胜过CPU硬件设计。当Internet的设计者为互联各种类型的计算机而设计网际协议（IP）时，他们意识到了在具有不同内部字节顺序的系统间传递数值数据的问题。因此，IP协议规定了使用大端的网络字节顺序概念 4。所有在IP分组报文的协议部分中使用的多字节数值必须先在本地主机字节顺序和通用的网络字节顺序之间进行转换

在 java.nio 中，字节顺序由 ByteOrder 类封装。

package java.nio; 
public final class ByteOrder 
{ 
 public static final ByteOrder BIG_ENDIAN 
 public static final ByteOrder LITTLE_ENDIAN 
 public static ByteOrder nativeOrder( ) 
 public String toString( ) 
}

ByteOrder 类定义了决定从缓冲区中存储或检索多字节数值时使用哪一字节顺序的常量。这个类的作用就像一个类型安全的枚举。它定义了以其本身实例预初始化的两个 public区域。只有这两个 ByteOrder 实例总是存在于 JVM 中，因此它们可以通过使用--操作符进行比较。如果您需要知道 JVM 运行的硬件平台的固有字节顺序，请调用静态类函数nativeOrder()。它将返回两个已确定常量中的一个。调用 toString()将返回一个包含两个文字字符串 BIG_ENDIAN 或者 LITTLE_ENDIAN 之一的 String。
每个缓冲区类都具有一个能够通过调用 order()查询的当前字节顺序设定

public abstract class CharBuffer extends Buffer 
 implements Comparable, CharSequence 
{ 
 // This is a partial API listing 
 public final ByteOrder order( ) 
}

这个函数从 ByteOrder 返回两个常量之一。对于除了 ByteOrder 之外的其他缓冲区类，字节顺序是一个只读属性，并且可能根据缓冲区的建立方式而采用不同的值。除了ByteBuffer，其他通过分配或包装一个数组所创建的缓冲区将从 order()返回与ByteOrder.nativeOrder()相同的数值。这使因为包含在缓冲区中的元素在 JVM 中将会被作为基本数据直接存取

ByteBuffer 类有所不同：默认字节顺序总是 ByteBuffer.BIG_ENDIAN，无论系统的固有字节顺序是什么。Java 的默认字节顺序是大端字节顺序，这允许类文件等以及串行化的对象可以在任何 JVM 中工作。如果固有硬件字节顺序是小端，这会有性能隐患。在使用固有硬件字节顺序时，将 ByteBuffer 的内容当作其他数据类型存取（很快就会讨论到）很可能高效得多。
很可能您会对为什么 ByteBuffer 类需要一个字节顺序设定这一问题感到困惑。字节就是字节，对吗？当然，但是如您不久将在 2.4.4 节所看到的那样，ByteBuffer 对象像其他基本数据类型一样，具有大量便利的函数用于获取和存放缓冲区内容。这些函数对字节进行编码或解码的方式取决于 ByteBuffer 当前字节顺序的设定。

ByteBuffer 的字符顺序设定可以随时通过调用以 ByteOrder.BIG_ENDIAN 或
ByteOrder.LITTL_ENDIAN 为参数的 order()函数来改变。

public abstract class ByteBuffer extends Buffer 
 implements Comparable 
{ 
 // This is a partial API listing 
 public final ByteOrder order( ) 
 public final ByteBuffer order (ByteOrder bo) 
}

如果一个缓冲区被创建为一个 ByteBuffer 对象的视图（参见 2.4.3 节），那么order()返回的数值就是视图被创建时其创建源头的 ByteBuffer 的字节顺序设定。视图的字节顺序设定在创建后不能被改变，而且如果原始的字节缓冲区的字节顺序在之后被改变，它也不会受到影响。

 

 

 

 

 

 

 

 

 

 

 

转载于:https://my.oschina.net/LucasZhu/blog/1606755