ByteBuffer

allocate

ByteBuffer allocate (int capacity)

分配一个新的字节缓冲区。

新的缓冲区的位置将为零，其限制将是其容量，其标记将是未定义的，并且其每个元素将被初始化为零。 它将有一个 backing array ，其 array offset将为零。

allocateDirect

ByteBuffer allocateDirect (int capacity)

分配新的直接字节缓冲区。

新的缓冲区的位置将为零，其限制将是其容量，其标记将是未定义的，并且其每个元素将被初始化为零。 是否具有 backing array未指定。

array

byte[] array ()

返回支持此缓冲区的字节数组 （可选操作） 。

修改此缓冲区的内容将导致返回的数组内容被修改，反之亦然。

在调用此方法之前调用 hasArray方法，以确保此缓冲区具有可访问的后备数组。

arrayOffset

int arrayOffset ()

返回缓冲区第一个元素 （可选操作）的此缓冲区的后备数组内的偏移量。

如果此缓冲区由数组支持，则缓冲区位置 p对应于数组索引 p + arrayOffset() 。

在调用此方法之前调用 hasArray方法，以确保此缓冲区具有可访问的后备数组。

asCharBuffer

CharBuffer asCharBuffer ()

创建该字节缓冲区的视图作为字符缓冲区。

新缓冲区的内容将从此缓冲区的当前位置开始。 这个缓冲区内容的改变将在新缓冲区中可见，反之亦然; 两个缓冲区的位置，限制和标记值将是独立的。

新缓冲区的位置将为零，其容量和限制将是此缓冲区中剩余的字节数除以2，其标记将是未定义的。 当且仅当此缓冲区是直接的时，新缓冲区才是直接的，并且只有在此缓冲区是只读的情况下，它才会是只读的。

asDoubleBuffer

DoubleBuffer asDoubleBuffer ()

创建该字节缓冲区的视图为双缓冲区。

新缓冲区的内容将从此缓冲区的当前位置开始。 这个缓冲区内容的改变将在新缓冲区中可见，反之亦然; 两个缓冲区的位置，限制和标记值将是独立的。

新缓冲区的位置将为零，其容量和限制将是该缓冲区中剩余的字节数除以8，其标记将是未定义的。 当且仅当此缓冲区是直接的时，新缓冲区才是直接的，并且只有在此缓冲区是只读的情况下，它才会是只读的。

asFloatBuffer

FloatBuffer asFloatBuffer ()

以浮点缓冲区的形式创建此字节缓冲区的视图。

新缓冲区的内容将从此缓冲区的当前位置开始。 这个缓冲区内容的改变将在新缓冲区中可见，反之亦然; 两个缓冲区的位置，限制和标记值将是独立的。

新缓冲区的位置将为零，其容量和限制将是此缓冲区中剩余的字节数除以4，其标记将是未定义的。 当且仅当此缓冲区是直接的时，新缓冲区才是直接的，并且只有在此缓冲区是只读的情况下，它才会是只读的。

asIntBuffer

IntBuffer asIntBuffer ()

以int缓冲区的形式创建该字节缓冲区的视图。

新缓冲区的内容将从此缓冲区的当前位置开始。 这个缓冲区内容的改变将在新缓冲区中可见，反之亦然; 两个缓冲区的位置，限制和标记值将是独立的。

新缓冲区的位置将为零，其容量和限制将是此缓冲区中剩余的字节数除以4，其标记将是未定义的。 当且仅当此缓冲区是直接的时，新缓冲区才是直接的，并且只有在此缓冲区是只读的情况下，它才会是只读的。

asLongBuffer

LongBuffer asLongBuffer ()

将该字节缓冲区的视图创建为长缓冲区。

新缓冲区的内容将从此缓冲区的当前位置开始。 这个缓冲区内容的改变将在新缓冲区中可见，反之亦然; 两个缓冲区的位置，限制和标记值将是独立的。

The new buffer's position will be zero, its capacity and its limit will be the number of bytes remaining in this buffer divided by eight, and its mark will be undefined. The new buffer will be direct if, and only if, this buffer is direct, and it will be read-only if, and only if, this buffer is read-only.

asReadOnlyBuffer

ByteBuffer asReadOnlyBuffer ()

创建一个共享此缓冲区内容的新的只读字节缓冲区。

新缓冲区的内容将是该缓冲区的内容。 此缓冲区内容的更改将在新缓冲区中可见; 但是新的缓冲区本身将是只读的，并且不允许修改共享内容。 两个缓冲区的位置，限制和标记值将是独立的。

新缓冲区的容量，限制，位置和标记值将与该缓冲区的相同。

如果此缓冲区本身是只读的，则此方法的行为方式与 duplicate方法完全相同。

asShortBuffer

ShortBuffer asShortBuffer ()

将此字节缓冲区的视图创建为短缓冲区。

新缓冲区的内容将从此缓冲区的当前位置开始。 这个缓冲区内容的改变将在新缓冲区中可见，反之亦然; 两个缓冲区的位置，限制和标记值将是独立的。

新缓冲区的位置将为零，其容量和限制将是此缓冲区中剩余的字节数除以2，其标记将是未定义的。 当且仅当此缓冲区是直接的时，新缓冲区才是直接的，并且只有在此缓冲区是只读的情况下，它才会是只读的。

compact

ByteBuffer compact ()

压缩此缓冲区 （可选操作） 。

缓冲区当前位置与其限制之间的字节（如果有）将被复制到缓冲区的开始处。 即，在索引p = position()复制到索引零字节，在索引p + 1的字节被复制到索引1，依此类推，直到在索引limit()字节- 1被复制到索引n = limit() - 1 - p 。 然后将缓冲区的位置设置为n + 1，并将其限制设置为其容量。 标记（如果已定义）将被丢弃。

缓冲区的位置设置为复制的字节数，而不是零，因此可以立即调用另一个相对 放置方法来调用此方法。

在写入数据不完整时从缓冲区写入数据后调用此方法。 例如，以下循环通过缓冲区buf将字节从一个通道复制到另一个通道：

 buf.clear();          // Prepare buffer for use
 while (in.read(buf) >= 0 || buf.position != 0) {
     buf.flip();
     out.write(buf);
     buf.compact();    // In case of partial write
 }

compareTo

int compareTo (ByteBuffer that)

将此缓冲区与另一个进行比较。

通过按照字典顺序比较剩余元素的序列来比较两个字节的缓冲区，而不考虑每个序列在其相应缓冲区内的开始位置。 对byte元素进行比较，就好像调用compare(byte, byte) 。

字节缓冲区不能与任何其他类型的对象相比较。

duplicate

ByteBuffer duplicate ()

创建一个共享此缓冲区内容的新字节缓冲区。

新缓冲区的内容将是该缓冲区的内容。 这个缓冲区内容的改变将在新缓冲区中可见，反之亦然; 两个缓冲区的位置，限制和标记值将是独立的。

新缓冲区的容量，限制，位置和标记值将与该缓冲区的相同。 当且仅当此缓冲区是直接的时，新缓冲区才是直接的，并且只有在此缓冲区是只读的情况下，它才会是只读的。

equals

boolean equals (Object ob)

告诉这个缓冲区是否等于另一个对象。

Two byte buffers are equal if, and only if,

1. 它们具有相同的元素类型，

2. 他们有相同数量的剩余元素，并且

3. 独立于其起始位置考虑的剩余元素的两个序列是逐点相等的。

A byte buffer is not equal to any other type of object.

get

byte get ()

相对获得方法。 在此缓冲区的当前位置读取该字节，然后递增该位置。

get

ByteBuffer get (byte[] dst, 
                int offset, 
                int length)

相对批量 获取方法。

此方法将来自此缓冲区的字节传输到给定的目标数组中。 如果缓冲区中剩余的字节数少于满足请求所需的字节数，即length > remaining() ，则不传输字节并引发BufferUnderflowException 。

否则，此方法将此缓冲区中的length个字节复制到给定数组中，从此缓冲区的当前位置开始，并位于数组中给定的偏移位置。 此缓冲区的位置然后递增length 。

换句话说，调用表单 src.get(dst, off, len)的这种方法与 循环具有完全相同的效果

     for (int i = off; i < off + len; i++)
         dst[i] = src.get(); 

get

byte get (int index)

绝对get方法。 读取给定索引处的字节。

get

ByteBuffer get (byte[] dst)

相对批量 获取方法。

此方法将来自此缓冲区的字节传输到给定的目标数组中。 表单src.get(a)的此方法的调用的行为与调用完全相同

     src.get(a, 0, a.length) 

getChar

char getChar ()

读取char值的相对 get方法。

读取此缓冲区当前位置的下两个字节，根据当前字节顺序将它们组合为char值，然后将位置增加2。

getChar

char getChar (int index)

用于读取char值的绝对 get方法。

读取给定索引处的两个字节，根据当前字节顺序将它们组成char值。

getDouble

double getDouble (int index)

读取double值的绝对 get方法。

读取给定索引处的八个字节，根据当前字节顺序将它们组合为一个double值。

getDouble

double getDouble ()

读取double值的相对 get方法。

读取此缓冲区当前位置的后八个字节，根据当前字节顺序将它们组合为一个double值，然后将该位置增加八。

getFloat

float getFloat ()

读取float值的相对 get方法。

读取此缓冲区当前位置的下四个字节，根据当前字节顺序将它们组合为浮点值，然后将位置增加4。

getFloat

float getFloat (int index)

用于读取浮点值的绝对 get方法。

在给定索引处读取四个字节，根据当前字节顺序将它们组成浮点值。

getInt

int getInt (int index)

读取int值的绝对 get方法。

在给定索引处读取四个字节，根据当前字节顺序将它们组成一个int值。

getInt

int getInt ()

读取int值的相对 get方法。

读取此缓冲区当前位置的下四个字节，根据当前字节顺序将它们组合为int值，然后将位置增加4。

getLong

long getLong (int index)

绝对 get方法读取长整型值。

根据当前字节顺序在给定索引处读取八个字节，将它们组合为一个长整型值。

getLong

long getLong ()

读取长整型值的相对 获取方法。

读取此缓冲区当前位置的下8个字节，根据当前字节顺序将它们组合为长值，然后将位置增加8。

getShort

short getShort (int index)

读取短值的绝对 获取方法。

读取给定索引处的两个字节，根据当前字节顺序将它们组成短值。

getShort

short getShort ()

读取短值的相对 获取方法。

在此缓冲区的当前位置读取接下来的两个字节，根据当前字节顺序将它们组成短值，然后将位置增加2。

hasArray

boolean hasArray ()

告诉这个缓冲区是否由可访问的字节数组支持。

如果此方法返回 true，则可以安全地调用 array和 arrayOffset方法。

hashCode

int hashCode ()

返回此缓冲区的当前哈希码。

字节缓冲区的哈希码仅依赖于其余的元素; 也就是说，从position()到limit() - 1处的元素（包括元素）。

由于缓冲区散列码与内容相关，因此除非知道其内容不会改变，否则在散列映射或类似数据结构中使用缓冲区作为键是不可取的。

isDirect

boolean isDirect ()

告诉这个字节缓冲区是否是直接的。

order

ByteOrder order ()

检索此缓冲区的字节顺序。

读取或写入多字节值时以及创建缓冲区时，将使用字节顺序来查看此字节缓冲区。 新创建的字节缓冲区的顺序始终为BIG_ENDIAN 。

order

ByteBuffer order (ByteOrder bo)

Modifies this buffer's byte order.

put

ByteBuffer put (byte[] src)

相对批量 放置方法 （可选操作） 。

此方法将给定源字节数组的全部内容传输到此缓冲区。 表单dst.put(a)的这种方法的调用的行为与调用完全相同

     dst.put(a, 0, a.length) 

put

ByteBuffer put (byte b)

相对 放置方法 （可选操作） 。

将给定的字节写入当前位置的缓冲区，然后增加位置。

put

ByteBuffer put (byte[] src, 
                int offset, 
                int length)

相对批量 放置方法 （可选操作） 。

该方法将字节从给定的源数组传输到此缓冲区。 如果从阵列中复制的字节数多于保留在此缓冲区中的字节数，也就是说，如果length > remaining() ，则不传输字节并且引发BufferOverflowException 。

否则，此方法将length字节从给定数组复制到此缓冲区，从数组中给定的偏移量开始，并在此缓冲区的当前位置处开始。 此缓冲区的位置然后增加length 。

换句话说，调用这种形式为 dst.put(src, off, len)的方法与 循环具有完全相同的效果

     for (int i = off; i < off + len; i++)
         dst.put(a[i]); 

put

ByteBuffer put (int index, 
                byte b)

绝对 放置方法 （可选操作） 。

将给定的字节写入该缓冲区中给定的索引处。

put

ByteBuffer put (ByteBuffer src)

相对批量 放置方法 （可选操作） 。

此方法将给定源缓冲区中剩余的字节传输到此缓冲区。 如果源缓冲区中剩余的字节数多于此缓冲区中的字节数，也就是说，如果src.remaining() > remaining() ，则不传送字节并且引发BufferOverflowException 。

否则，该方法将n = src.remaining()字节从给定缓冲区复制到此缓冲区，从每个缓冲区的当前位置开始。 然后两个缓冲器的位置增加n 。

换句话说，调用这种形式为 dst.put(src)的方法与 循环具有完全相同的效果

     while (src.hasRemaining())
         dst.put(src.get()); 

putChar

ByteBuffer putChar (int index, 
                char value)

写入char值的绝对 put方法 （可选操作） 。

将包含给定char值的两个字节按当前字节顺序写入此缓冲区中给定索引处。

putChar

ByteBuffer putChar (char value)

写入char值的相对 put方法 （可选操作） 。

将包含给定char值的两个字节以当前字节顺序写入当前位置的缓冲区，然后将位置增加2。

putDouble

ByteBuffer putDouble (double value)

写入double值的相对 put方法 （可选操作） 。

将包含给定double值的八个字节以当前字节顺序写入当前位置的缓冲区，然后将该位置增加八。

putDouble

ByteBuffer putDouble (int index, 
                double value)

写入double值的绝对 put方法 （可选操作） 。

将包含给定double值的八个字节按当前字节顺序写入给定索引处的此缓冲区。

putFloat

ByteBuffer putFloat (int index, 
                float value)

写入浮点值的绝对 put方法 （可选操作） 。

将包含给定float值的四个字节按当前字节顺序写入给定索引处的此缓冲区中。

putFloat

ByteBuffer putFloat (float value)

写入浮点值的相对 put方法 （可选操作） 。

将包含给定float值的四个字节按当前字节顺序写入当前位置的缓冲区中，然后将位置增加四。

putInt

ByteBuffer putInt (int index, 
                int value)

写入int值的绝对 put方法 （可选操作） 。

将包含给定int值的四个字节以当前字节顺序写入给定索引处的此缓冲区。

putInt

ByteBuffer putInt (int value)

写入int值的相对 put方法 （可选操作） 。

将包含给定int值的四个字节按当前字节顺序写入当前位置的此缓冲区，然后将位置增加四。

putLong

ByteBuffer putLong (long value)

写入长整型值的相对 put方法 （可选操作） 。

将包含给定long值的八个字节按当前字节顺序写入当前位置的缓冲区，然后将位置增加八。

putLong

ByteBuffer putLong (int index, 
                long value)

写入长整型值的绝对 put方法 （可选操作） 。

将包含给定long值的八个字节以当前字节顺序写入给定索引处的此缓冲区。

putShort

ByteBuffer putShort (short value)

写入短数值的相对 放入方法 （可选操作） 。

将包含给定short值的两个字节按当前字节顺序写入当前位置的缓冲区，然后将位置增加2。

putShort

ByteBuffer putShort (int index, 
                short value)

写入短暂值的绝对 put方法 （可选操作） 。

将包含给定short值的两个字节以当前字节顺序写入给定索引处的此缓冲区中。

slice

ByteBuffer slice ()

创建一个新的字节缓冲区，其内容是此缓冲区内容的共享子序列。

新缓冲区的内容将从此缓冲区的当前位置开始。 这个缓冲区内容的改变将在新缓冲区中可见，反之亦然; 两个缓冲区的位置，限制和标记值将是独立的。

新缓冲区的位置将为零，其容量和限制将是剩余在此缓冲区中的字节数，并且其标记将是未定义的。 当且仅当此缓冲区是直接的时，新缓冲区才是直接的，并且只有在此缓冲区是只读的情况下，它才会是只读的。

toString

String toString ()

返回汇总此缓冲区状态的字符串。

wrap

ByteBuffer wrap (byte[] array)

将一个字节数组包装到缓冲区中。

新缓冲区将由给定的字节数组支持; 也就是说，修改缓冲区将导致数组被修改，反之亦然。 新缓冲区的容量和限制将为array.length ，其位置将为零，并且其标记将不确定。 其 backing array将是给定的阵列，其 array offset将为零。

wrap

ByteBuffer wrap (byte[] array, 
                int offset, 
                int length)

将一个字节数组包装到缓冲区中。

新缓冲区将由给定的字节数组支持; 也就是说，修改缓冲区将导致数组被修改，反之亦然。 新缓冲区容量为array.length ，位置为offset ，限制为offset + length ，其标记未定义。 它的 backing array将是给定的数组，其 array offset将为零。