java.lang.Object

java.nio.Buffer

java.nio.ByteBuffer

所有已实现的接口:: Comparable<ByteBuffer>

直接已知的子类:: MappedByteBuffer

public abstract sealed class ByteBuffer extends Buffer implements Comparable<ByteBuffer> permits MappedByteBuffer (not exhaustive)

一个字节缓冲区。

该类定义了对字节缓冲区进行的六类操作：

读取和写入单个字节的绝对和相对get和put方法；
将连续的字节序列从该缓冲区传输到数组的绝对和相对批量获取方法；
将来自字节数组或其他字节缓冲区的连续字节序列传输到该缓冲区的绝对和相对批量放置方法；
读取和写入其他原始类型值的绝对和相对get和put方法，将它们转换为特定字节顺序中的字节序列；
用于创建视图缓冲区的方法，允许将字节缓冲区视为包含某种其他原始类型值的缓冲区；以及
用于压缩字节缓冲区的方法。

字节缓冲区可以通过分配（为缓冲区内容分配空间）或通过包装现有字节数组到缓冲区来创建。

直接 vs. 非直接缓冲区

字节缓冲区可以是直接或非直接的。对于直接字节缓冲区，Java虚拟机将尽最大努力直接执行本机I/O操作。也就是说，在调用底层操作系统的本机I/O操作之前（或之后），它将尝试避免将缓冲区内容复制到（或从）中间缓冲区。

可以通过调用该类的allocateDirect工厂方法来创建直接字节缓冲区。该方法返回的缓冲区通常具有比非直接缓冲区更高的分配和释放成本。直接缓冲区的内容可能驻留在正常的垃圾收集堆之外，因此它们对应用程序的内存占用可能不明显。因此，建议主要为长时间存在且受底层系统本机I/O操作影响的大型缓冲区分配直接缓冲区。通常最好仅在分配直接缓冲区会带来可衡量的程序性能提升时才分配直接缓冲区。

也可以通过映射文件的区域直接将直接字节缓冲区创建到内存中。Java平台的实现可以选择支持通过JNI从本机代码创建直接字节缓冲区。如果这些缓冲区中的某种类型引用了无法访问的内存区域，则尝试访问该区域将不会更改缓冲区的内容，并将在访问时或稍后引发未指定的异常。

可以通过调用其isDirect方法来确定字节缓冲区是直接的还是非直接的。提供此方法是为了在性能关键代码中进行显式缓冲区管理。

访问二进制数据

该类定义了用于读取和写入除boolean之外的所有其他原始类型值的方法。原始值根据缓冲区的当前字节顺序转换为（或从）字节序列，可以通过order方法检索和修改字节顺序。特定的字节顺序由ByteOrder类的实例表示。字节缓冲区的初始顺序始终为BIG_ENDIAN。

对于异构二进制数据的访问，即不同类型值的序列，该类为每种类型定义了一组绝对和相对的get和put方法。例如，对于32位浮点值，该类定义了：

    float      getFloat()
    float      getFloat(int index)
    ByteBuffer putFloat(float f)
    ByteBuffer putFloat(int index, float f)

对于类型char, short, int, long和double，定义了相应的方法。绝对get和put方法的索引参数是以字节而不是要读取或写入的类型为单位的。

对于同类二进制数据的访问，即相同类型值的序列，该类定义了可以创建视图的方法。一个视图缓冲区只是另一个其内容由字节缓冲区支持的缓冲区。对字节缓冲区内容的更改将在视图缓冲区中可见，反之亦然；两个缓冲区的位置、限制和标记值是独立的。例如，asFloatBuffer方法创建一个由调用该方法的字节缓冲区支持的FloatBuffer类的实例。为char, short, int, long和double类型定义了相应的视图创建方法。

视图缓冲区相对于上述特定类型的get和put方法具有三个重要优势：

视图缓冲区的索引不是以字节为单位，而是以其值的特定类型大小为单位；
视图缓冲区提供相对批量get和put方法，可以在缓冲区和相同类型的数组或其他缓冲区之间传输连续的值序列；以及
如果其支持字节缓冲区是直接的，则视图缓冲区可能更有效，因为只有在其支持字节缓冲区是直接的情况下才会直接。

视图缓冲区的字节顺序在创建视图时固定为其字节缓冲区的字节顺序。

调用链接

该类中没有其他返回值的方法被指定为在调用时返回其所调用的缓冲区。这允许方法调用链接。例如，以下语句序列

    bb.putInt(0xCAFEBABE);
    bb.putShort(3);
    bb.putShort(45);

可以被单个语句替换为

    bb.putInt(0xCAFEBABE).putShort(3).putShort(45);

可选操作

当被指定为可选操作的方法在只读字节缓冲区上调用时，会抛出ReadOnlyBufferException。如果字节缓冲区不是由可访问的字节数组支持的，则array和arrayOffset方法会抛出UnsupportedOperationException（无论字节缓冲区是否为只读）。

自版本:: 1.4

Method Summary

Modifier and Type

Method

Description

final ByteBuffer

alignedSlice(int unitSize)

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

final int

alignmentOffset(int index, int unitSize)

返回内存地址，指向给定索引处的字节，取模给定的单位大小。

static ByteBuffer

allocate(int capacity)

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

static ByteBuffer

allocateDirect(int capacity)

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

final byte[]

array()

返回支持该缓冲区的字节数组  (可选操作)。

final int

arrayOffset()

返回该缓冲区的支持数组中第一个元素的偏移量  (可选操作)。

abstract CharBuffer

asCharBuffer()

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

abstract DoubleBuffer

asDoubleBuffer()

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

abstract FloatBuffer

asFloatBuffer()

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

abstract IntBuffer

asIntBuffer()

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

abstract LongBuffer

asLongBuffer()

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

abstract ByteBuffer

asReadOnlyBuffer()

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

abstract ShortBuffer

asShortBuffer()

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

ByteBuffer

clear()

清除该缓冲区。

abstract ByteBuffer

compact()

压缩该缓冲区  (可选操作)。

int

compareTo(ByteBuffer that)

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

abstract ByteBuffer

duplicate()

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

boolean

equals(Object ob)

判断该缓冲区是否等于另一个对象。

ByteBuffer

flip()

翻转该缓冲区。

abstract byte

get()

相对get方法。

ByteBuffer

get(byte[] dst)

相对批量get方法。

ByteBuffer

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

相对批量get方法。

abstract byte

get(int index)

绝对get方法。

ByteBuffer

get(int index, byte[] dst)

绝对批量get方法。

ByteBuffer

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

绝对批量get方法。

abstract char

getChar()

读取char值的相对get方法。

abstract char

getChar(int index)

读取char值的绝对get方法。

abstract double

getDouble()

读取double值的相对get方法。

abstract double

getDouble(int index)

读取double值的绝对get方法。

abstract float

getFloat()

读取float值的相对get方法。

abstract float

getFloat(int index)

读取float值的绝对get方法。

abstract int

getInt()

读取int值的相对get方法。

abstract int

getInt(int index)

读取int值的绝对get方法。

abstract long

getLong()

读取long值的相对get方法。

abstract long

getLong(int index)

读取long值的绝对get方法。

abstract short

getShort()

读取short值的相对get方法。

abstract short

getShort(int index)

读取short值的绝对get方法。

final boolean

hasArray()

判断此缓冲区是否由可访问的字节数组支持。

int

hashCode()

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

abstract boolean

isDirect()

判断此字节缓冲区是否为直接缓冲区。

ByteBuffer

limit(int newLimit)

设置此缓冲区的限制。

ByteBuffer

mark()

在其位置设置此缓冲区的标记。

int

mismatch(ByteBuffer that)

查找并返回此缓冲区与给定缓冲区之间第一个不匹配的相对索引。

final ByteOrder

order()

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

final ByteBuffer

order(ByteOrder bo)

修改此缓冲区的字节顺序。

ByteBuffer

position(int newPosition)

设置此缓冲区的位置。

abstract ByteBuffer

put(byte b)

相对put方法  (可选操作)。

final ByteBuffer

put(byte[] src)

相对批量put方法  (可选操作)。

ByteBuffer

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

相对批量put方法  (可选操作)。

abstract ByteBuffer

put(int index, byte b)

绝对put方法  (可选操作)。

ByteBuffer

put(int index, byte[] src)

绝对批量put方法  (可选操作)。

ByteBuffer

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

绝对批量put方法  (可选操作)。

ByteBuffer

put(int index, ByteBuffer src, int offset, int length)

绝对批量put方法  (可选操作)。

ByteBuffer

put(ByteBuffer src)

相对批量put方法  (可选操作)。

abstract ByteBuffer

putChar(char value)

写入char值的相对put方法  (可选操作)。

abstract ByteBuffer

putChar(int index, char value)

写入char值的绝对put方法  (可选操作)。

abstract ByteBuffer

putDouble(double value)

写入double值的相对put方法  (可选操作)。

abstract ByteBuffer

putDouble(int index, double value)

写入double值的绝对put方法  (可选操作)。

abstract ByteBuffer

putFloat(float value)

写入float值的相对put方法  (可选操作)。

abstract ByteBuffer

putFloat(int index, float value)

写入float值的绝对put方法  (可选操作)。

abstract ByteBuffer

putInt(int value)

写入int值的相对put方法  (可选操作)。

abstract ByteBuffer

putInt(int index, int value)

写入int值的绝对put方法  (可选操作)。

abstract ByteBuffer

putLong(int index, long value)

写入long值的绝对put方法  (可选操作)。

abstract ByteBuffer

putLong(long value)

写入long值的相对put方法  (可选操作)。

abstract ByteBuffer

putShort(int index, short value)

写入short值的绝对put方法  (可选操作)。

abstract ByteBuffer

putShort(short value)

写入short值的相对put方法  (可选操作)。

ByteBuffer

reset()

将此缓冲区的位置重置为先前标记的位置。

ByteBuffer

rewind()

倒带此缓冲区。

abstract ByteBuffer

slice()

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

abstract ByteBuffer

slice(int index, int length)

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

String

toString()

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

static ByteBuffer

wrap(byte[] array)

将字节数组包装成缓冲区。

static ByteBuffer

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

将字节数组包装成缓冲区。

Methods declared in class java.nio.Buffer
capacity, hasRemaining, isReadOnly, limit, position, remaining

Methods declared in class java.lang.Object
clone, finalize, getClass, notify, notifyAll, wait, wait, wait

Method Details
- allocateDirect
  
  public static ByteBuffer allocateDirect(int capacity)
  
  分配一个新的直接字节缓冲区。
  新缓冲区的位置将为零，限制将为其容量，标记将未定义，每个元素将初始化为零，并且字节顺序将为BIG_ENDIAN。是否具有支持数组未指定。
  
  参数:
  
  capacity - 新缓冲区的容量，以字节为单位
  
  返回:
  
  新的字节缓冲区
  
  抛出:
  
  IllegalArgumentException - 如果capacity为负整数
- allocate
  
  public static ByteBuffer allocate(int capacity)
  
  分配一个新的字节缓冲区。
  新缓冲区的位置将为零，限制将为其容量，标记将未定义，每个元素将初始化为零，并且字节顺序将为BIG_ENDIAN。它将具有支持数组，其数组偏移将为零。
  
  参数:
  
  capacity - 新缓冲区的容量，以字节为单位
  
  返回:
  
  新的字节缓冲区
  
  抛出:
  
  IllegalArgumentException - 如果capacity为负整数
- wrap
  
  public static ByteBuffer wrap(byte[] array, int offset, int length)
  
  将字节数组包装成缓冲区。
  新缓冲区将由给定的字节数组支持；即，对缓冲区的修改将导致数组被修改，反之亦然。新缓冲区的容量将为array.length，其位置将为offset，其限制将为offset + length，其标记将未定义，其字节顺序将为BIG_ENDIAN。其支持数组将为给定数组，其数组偏移将为零。
  
  参数:
  
  array - 将支持新缓冲区的数组
  
  offset - 要使用的子数组的偏移量；必须为非负且不大于array.length。新缓冲区的位置将设置为此值。
  
  length - 要使用的子数组的长度；必须为非负且不大于array.length - offset。新缓冲区的限制将设置为offset + length。
  
  返回:
  
  新的字节缓冲区
  
  抛出:
  
  IndexOutOfBoundsException - 如果offset和length参数的前提条件不成立
- wrap
  
  public static ByteBuffer wrap(byte[] array)
  
  将字节数组包装成缓冲区。
  新缓冲区将由给定的字节数组支持；即，对缓冲区的修改将导致数组被修改，反之亦然。新缓冲区的容量和限制将为array.length，其位置将为零，其标记将未定义，其字节顺序将为BIG_ENDIAN。其支持数组将为给定数组，其数组偏移将为零。
  
  参数:
  
  array - 将支持此缓冲区的数组
  
  返回:
  
  新的字节缓冲区
- slice
  
  public abstract ByteBuffer slice()
  
  创建一个新的字节缓冲区，其内容是此缓冲区内容的共享子序列。
  新缓冲区的内容将从此缓冲区的当前位置开始。对此缓冲区内容的更改将在新缓冲区中可见，反之亦然；两个缓冲区的位置、限制和标记值将是独立的。
  
  新缓冲区的位置将为零，其容量和限制将为此缓冲区中剩余的字节数，其标记将未定义，其字节顺序将为BIG_ENDIAN。如果此缓冲区是直接的，则新缓冲区也将是直接的，如果此缓冲区是只读的，则新缓冲区也将是只读的。
  指定者:
  
  slice 在类 Buffer中
  
  返回:
  
  新的字节缓冲区
  
  参见:
  
  alignedSlice(int)
- slice
  
  public abstract ByteBuffer slice(int index, int length)
  
  创建一个新的字节缓冲区，其内容是此缓冲区内容的共享子序列。
  新缓冲区的内容将从此缓冲区的位置index开始，并包含length个元素。对此缓冲区内容的更改将在新缓冲区中可见，反之亦然；两个缓冲区的位置、限制和标记值将是独立的。
  
  新缓冲区的位置将为零，其容量和限制将为length，其标记将未定义，其字节顺序将为BIG_ENDIAN。如果此缓冲区是直接的，则新缓冲区也将是直接的，如果此缓冲区是只读的，则新缓冲区也将是只读的。
  
  指定者:
  
  slice 在类 Buffer中
  
  参数:
  
  index - 新缓冲区内容将从此缓冲区中的位置开始；必须为非负且不大于limit()
  
  length - 新缓冲区将包含的元素数量；必须为非负且不大于limit() - index
  
  返回:
  
  新缓冲区
  
  抛出:
  
  IndexOutOfBoundsException - 如果index为负或大于limit()，length为负，或length > limit() - index
  
  自:
  
  13
- duplicate
  
  public abstract ByteBuffer duplicate()
  
  创建一个共享此缓冲区内容的新字节缓冲区。
  新缓冲区的内容将是此缓冲区的内容。对此缓冲区内容的更改将在新缓冲区中可见，反之亦然；两个缓冲区的位置、限制和标记值将是独立的。
  
  新缓冲区的容量、限制、位置和标记值将与此缓冲区相同，并且其字节顺序将为BIG_ENDIAN。如果此缓冲区是直接的，则新缓冲区也将是直接的，如果此缓冲区是只读的，则新缓冲区也将是只读的。
  
  指定者:
  
  duplicate 在类 Buffer中
  
  返回:
  
  新的字节缓冲区
- asReadOnlyBuffer
  
  public abstract ByteBuffer asReadOnlyBuffer()
  
  创建一个新的只读字节缓冲区，共享该缓冲区的内容。
  新缓冲区的内容将与此缓冲区相同。对此缓冲区内容的更改将在新缓冲区中可见；但新缓冲区本身将是只读的，不允许修改共享内容。两个缓冲区的位置、限制和标记值将是独立的。
  
  新缓冲区的容量、限制、位置和标记值将与此缓冲区相同，并且其字节顺序将是BIG_ENDIAN。
  
  如果此缓冲区本身是只读的，则此方法的行为与duplicate方法完全相同。
  
  返回：
  
  新的只读字节缓冲区
- get
  
  public abstract byte get()
  
  相对 get 方法。读取此缓冲区当前位置的字节，然后递增位置。
  
  返回：
  
  缓冲区当前位置的字节
  
  抛出：
  
  BufferUnderflowException - 如果缓冲区当前位置不小于其限制
- put
  
  public abstract ByteBuffer put(byte b)
  
  相对 put 方法 (可选操作)。
  将给定的字节写入此缓冲区的当前位置，然后递增位置。
  
  参数：
  
  b - 要写入的字节
  
  返回：
  
  此缓冲区
  
  抛出：
  
  BufferOverflowException - 如果此缓冲区的当前位置不小于其限制
  
  ReadOnlyBufferException - 如果此缓冲区是只读的
- get
  
  public abstract byte get(int index)
  
  绝对 get 方法。读取给定索引处的字节。
  
  参数：
  
  index - 将读取字节的索引
  
  返回：
  
  给定索引处的字节
  
  抛出：
  
  IndexOutOfBoundsException - 如果index为负数或不小于缓冲区的限制
- put
  
  public abstract ByteBuffer put(int index, byte b)
  
  绝对 put 方法 (可选操作)。
  将给定的字节写入此缓冲区的给定索引处。
  
  参数：
  
  index - 将写入字节的索引
  
  b - 要写入的字节值
  
  返回：
  
  此缓冲区
  
  抛出：
  
  IndexOutOfBoundsException - 如果index为负数或不小于缓冲区的限制
  
  ReadOnlyBufferException - 如果此缓冲区是只读的
- get
  
  public ByteBuffer get(byte[] dst, int offset, int length)
  相对批量 get 方法。
  此方法将字节从此缓冲区传输到给定的目标数组。如果缓冲区中剩余的字节数少于请求所需的字节数，即length > remaining()，则不会传输任何字节，并抛出BufferUnderflowException。
  
  否则，此方法将从此缓冲区复制length字节到给定数组中，从此缓冲区的当前位置和数组中的给定偏移量开始。然后，此缓冲区的位置递增length。
  
  换句话说，形式为src.get(dst, off, len)的此方法调用与循环
  
  for (int i = off; i < off + len; i++) dst[i] = src.get();
  
  具有相同效果，只是它首先检查此缓冲区中是否有足够的字节，并且可能更有效。
  参数：
  
  dst - 要写入字节的数组
  
  offset - 要写入的第一个字节在数组中的偏移量；必须是非负数且不大于dst.length
  
  length - 要写入给定数组的最大字节数；必须是非负数且不大于dst.length - offset
  
  返回：
  
  此缓冲区
  
  抛出：
  
  BufferUnderflowException - 如果此缓冲区中剩余的字节数少于length
  
  IndexOutOfBoundsException - 如果offset和length参数的前提条件不成立
- get
  
  public ByteBuffer get(byte[] dst)
  相对批量 get 方法。
  此方法将字节从此缓冲区传输到给定的目标数组。形式为src.get(a)的此方法调用的行为与调用
  
  src.get(a, 0, a.length)
  
  相同。
  参数：
  
  dst - 目标数组
  
  返回：
  
  此缓冲区
  
  抛出：
  
  BufferUnderflowException - 如果此缓冲区中剩余的字节数少于length
- get
  
  public ByteBuffer get(int index, byte[] dst, int offset, int length)
  绝对批量 get 方法。
  此方法将length字节从此缓冲区传输到给定数组中，从此缓冲区中的给定索引和数组中的给定偏移量开始。此缓冲区的位置不变。
  
  形式为src.get(index, dst, offset, length)的此方法调用具有与以下循环相同的效果，只是它首先检查所提供参数的一致性，并且可能更有效：
  
  for (int i = offset, j = index; i < offset + length; i++, j++) dst[i] = src.get(j);
  参数：
  
  index - 将读取第一个字节的此缓冲区中的索引；必须是非负数且小于limit()
  
  dst - 目标数组
  
  offset - 要写入的第一个字节在数组中的偏移量；必须是非负数且小于dst.length
  
  length - 要写入给定数组的字节数；必须是非负数且不大于limit() - index和dst.length - offset中较小的值
  
  返回：
  
  此缓冲区
  
  抛出：
  
  IndexOutOfBoundsException - 如果index、offset和length参数的前提条件不成立
  
  自：
  
  13
- get
  
  public ByteBuffer get(int index, byte[] dst)
  绝对批量 get 方法。
  此方法将字节从此缓冲区传输到给定目标数组中。此缓冲区的位置不变。形式为src.get(index, dst)的此方法调用的行为与调用相同：
  
  src.get(index, dst, 0, dst.length)
  参数：
  
  index - 将读取第一个字节的此缓冲区中的索引；必须是非负数且小于limit()
  
  dst - 目标数组
  
  返回：
  
  此缓冲区
  
  抛出：
  
  IndexOutOfBoundsException - 如果index为负数、不小于limit()或limit() - index < dst.length
  
  自：
  
  13
- put
  
  public ByteBuffer put(ByteBuffer src)
  相对批量 put 方法 (可选操作)。
  此方法将给定源缓冲区中剩余的字节传输到此缓冲区。如果源缓冲区中剩余的字节数多于此缓冲区中的字节数，即src.remaining() > remaining()，则不会传输任何字节，并抛出BufferOverflowException。
  
  否则，此方法将从给定缓冲区复制n = src.remaining()字节到此缓冲区中，从每个缓冲区的当前位置开始。然后，两个缓冲区的位置都递增n。
  
  换句话说，形式为dst.put(src)的此方法调用与循环
  
  while (src.hasRemaining()) dst.put(src.get());
  
  具有相同效果，只是它首先检查此缓冲区中是否有足够的空间，并且可能更有效。如果此缓冲区和源缓冲区共享相同的后备数组或内存，则结果将是先将源元素复制到中间位置，然后写入此缓冲区。
  参数:
  
  src - 要读取字节的源缓冲区；不能是此缓冲区
  
  返回:
  
  此缓冲区
  
  抛出:
  
  BufferOverflowException - 如果此缓冲区中没有足够的空间来容纳源缓冲区中剩余的字节
  
  IllegalArgumentException - 如果源缓冲区是此缓冲区
  
  ReadOnlyBufferException - 如果此缓冲区是只读的
- put
  
  public ByteBuffer put(int index, ByteBuffer src, int offset, int length)
  绝对批量 put 方法 (可选操作)。
  此方法从给定的源缓冲区传输length字节到此缓冲区，从源缓冲区中的给定offset和此缓冲区中的给定index开始。两个缓冲区的位置保持不变。
  
  换句话说，形式为dst.put(index, src, offset, length)的此方法的调用与以下循环具有完全相同的效果
  
  for (int i = offset, j = index; i < offset + length; i++, j++) dst.put(j, src.get(i));
  
  只是它首先检查所提供参数的一致性，而且可能更有效。如果此缓冲区和源缓冲区共享相同的后备数组或内存，则结果将是源元素首先被复制到中间位置，然后写入此缓冲区。
  参数:
  
  index - 将写入第一个字节的此缓冲区中的索引；必须是非负数且小于limit()
  
  src - 要读取字节的缓冲区
  
  offset - 要读取的第一个字节在源缓冲区中的索引；必须是非负数且小于src.limit()
  
  length - 要从给定缓冲区读取的字节数；必须是非负数且不大于limit() - index和src.limit() - offset中较小的值
  
  返回:
  
  此缓冲区
  
  抛出:
  
  IndexOutOfBoundsException - 如果index、offset和length参数的前提条件不成立
  
  ReadOnlyBufferException - 如果此缓冲区是只读的
  
  自:
  
  16
- put
  
  public ByteBuffer put(byte[] src, int offset, int length)
  相对批量 put 方法 (可选操作)。
  此方法从给定源数组向此缓冲区传输字节。如果要从数组复制的字节数多于此缓冲区中剩余的字节数，即length > remaining()，则不会传输任何字节，并抛出BufferOverflowException。
  
  否则，此方法将从给定数组中的给定偏移量开始，从当前位置的此缓冲区中复制length字节到此缓冲区。然后，此缓冲区的位置将增加length。
  
  换句话说，形式为dst.put(src, off, len)的此方法的调用与以下循环具有完全相同的效果
  
  for (int i = off; i < off + len; i++) dst.put(src[i]);
  
  只是它首先检查此缓冲区中是否有足够的空间，而且可能更有效。
  参数:
  
  src - 要读取字节的数组
  
  offset - 要读取的第一个字节在数组中的偏移量；必须是非负数且不大于src.length
  
  length - 要从给定数组读取的字节数；必须是非负数且不大于src.length - offset
  
  返回:
  
  此缓冲区
  
  抛出:
  
  BufferOverflowException - 如果此缓冲区中没有足够的空间
  
  IndexOutOfBoundsException - 如果offset和length参数的前提条件不成立
  
  ReadOnlyBufferException - 如果此缓冲区是只读的
- put
  
  public final ByteBuffer put(byte[] src)
  相对批量 put 方法 (可选操作)。
  此方法将给定源字节数组的整个内容传输到此缓冲区。形式为dst.put(a)的此方法的调用行为与以下调用完全相同
  
  dst.put(a, 0, a.length)
  参数:
  
  src - 源数组
  
  返回:
  
  此缓冲区
  
  抛出:
  
  BufferOverflowException - 如果此缓冲区中没有足够的空间
  
  ReadOnlyBufferException - 如果此缓冲区是只读的
- put
  
  public ByteBuffer put(int index, byte[] src, int offset, int length)
  绝对批量 put 方法 (可选操作)。
  此方法从给定数组中传输length字节，从数组中的给定偏移量开始，并在此缓冲区中的给定索引处开始。此缓冲区的位置保持不变。
  
  形式为dst.put(index, src, offset, length)的此方法的调用与以下循环具有完全相同的效果，只是它首先检查所提供参数的一致性，而且可能更有效：
  
  for (int i = offset, j = index; i < offset + length; i++, j++) dst.put(j, src[i]);
  参数:
  
  index - 将写入第一个字节的此缓冲区中的索引；必须是非负数且小于limit()
  
  src - 要读取字节的数组
  
  offset - 数组中要读取的第一个字节的偏移量；必须是非负数且小于src.length
  
  length - 要从给定数组读取的字节数；必须是非负数且不大于limit() - index和src.length - offset中较小的值
  
  返回:
  
  此缓冲区
  
  抛出:
  
  IndexOutOfBoundsException - 如果index、offset和length参数的前提条件不成立
  
  ReadOnlyBufferException - 如果此缓冲区是只读的
  
  自:
  
  13
- put
  
  public ByteBuffer put(int index, byte[] src)
  绝对批量 put 方法 (可选操作)。
  此方法从给定源数组复制字节到此缓冲区。此缓冲区的位置保持不变。形式为dst.put(index, src)的此方法的调用行为与以下调用完全相同：
  
  dst.put(index, src, 0, src.length);
  参数:
  
  index - 将写入第一个字节的此缓冲区中的索引；必须是非负数且小于limit()
  
  src - 要读取字节的数组
  
  返回:
  
  此缓冲区
  
  抛出:
  
  IndexOutOfBoundsException - 如果index为负数，不小于limit()，或limit() - index < src.length
  
  ReadOnlyBufferException - 如果此缓冲区是只读的
  
  自:
  
  13
- hasArray
  
  public final boolean hasArray()
  
  告诉此缓冲区是否由可访问的字节数组支持。
  如果此方法返回true，则可以安全地调用array和arrayOffset方法。
  
  指定者:
  
  hasArray 在类 Buffer中
  
  返回:
  
  如果此缓冲区由数组支持且不是只读，则返回true
- array
  
  public final byte[] array()
  
  返回支持此缓冲区的字节数组 (可选操作)。
  修改此缓冲区的内容将导致返回的数组的内容被修改，反之亦然。
  
  在调用此方法之前调用hasArray方法，以确保此缓冲区具有可访问的后备数组。
  
  指定由:
  
  array 在类 Buffer中
  
  返回:
  
  支持此缓冲区的数组
  
  抛出:
  
  ReadOnlyBufferException - 如果此缓冲区由数组支持但是只读的
  
  UnsupportedOperationException - 如果此缓冲区没有可访问的数组支持
- arrayOffset
  
  public final int arrayOffset()
  
  返回此缓冲区的支持数组中第一个元素的偏移量 (可选操作)。
  如果此缓冲区由数组支持，则缓冲区位置 p 对应于数组索引 p + arrayOffset()。
  
  在调用此方法之前，请调用hasArray方法，以确保此缓冲区具有可访问的支持数组。
  
  指定由:
  
  arrayOffset 在类 Buffer中
  
  返回:
  
  缓冲区数组中第一个元素的偏移量
  
  抛出:
  
  ReadOnlyBufferException - 如果此缓冲区由数组支持但是只读的
  
  UnsupportedOperationException - 如果此缓冲区没有可访问的数组支持
- position
  
  public ByteBuffer position(int newPosition)
  
  设置此缓冲区的位置。如果标记已定义且大于新位置，则将其丢弃。
  
  覆盖:
  
  position 在类 Buffer中
  
  参数:
  
  newPosition - 新的位置值；必须是非负且不大于当前限制
  
  返回:
  
  此缓冲区
  
  自:
  
  9
- limit
  
  public ByteBuffer limit(int newLimit)
  
  设置此缓冲区的限制。如果位置大于新限制，则将其设置为新限制。如果标记已定义且大于新限制，则将其丢弃。
  
  覆盖:
  
  limit 在类 Buffer中
  
  参数:
  
  newLimit - 新的限制值；必须是非负且不大于此缓冲区的容量
  
  返回:
  
  此缓冲区
  
  自:
  
  9
- mark
  
  public ByteBuffer mark()
  
  在其位置设置此缓冲区的标记。
  
  覆盖:
  
  mark 在类 Buffer中
  
  返回:
  
  此缓冲区
  
  自:
  
  9
- reset
  
  public ByteBuffer reset()
  
  将此缓冲区的位置重置为先前标记的位置。
  调用此方法既不更改也不丢弃标记的值。
  
  覆盖:
  
  reset 在类 Buffer
  
  返回:
  
  此缓冲区
  
  自:
  
  9
- clear
  
  public ByteBuffer clear()
  清除此缓冲区。位置设置为零，限制设置为容量，并丢弃标记。
  在使用一系列通道读取或 put 操作填充此缓冲区之前调用此方法。例如：
  
  buf.clear(); // 准备缓冲区以供读取 in.read(buf); // 读取数据
  
  此方法实际上不会擦除缓冲区中的数据，但它的命名方式表明它可能会在那种情况下使用。
  覆盖:
  
  clear 在类 Buffer中
  
  返回:
  
  此缓冲区
  
  自:
  
  9
- flip
  
  public ByteBuffer flip()
  翻转此缓冲区。限制设置为当前位置，然后位置设置为零。如果标记已定义，则将其丢弃。
  在一系列通道读取或 put 操作之后，调用此方法以准备进行一系列通道写入或相对 get 操作。例如：
  
  buf.put(magic); // 在头部添加 in.read(buf); // 将数据读入缓冲区的其余部分 buf.flip(); // 翻转缓冲区 out.write(buf); // 将头部 + 数据写入通道
  
  此方法通常与 compact 方法一起在将数据从一个地方传输到另一个地方时使用。
  覆盖:
  
  flip 在类 Buffer
  
  返回:
  
  此缓冲区
  
  自:
  
  9
- rewind
  
  public ByteBuffer rewind()
  倒带此缓冲区。位置设置为零，标记被丢弃。
  在一系列通道写入或 get 操作之前调用此方法，假设限制已经适当设置。例如：
  
  out.write(buf); // 写入剩余数据 buf.rewind(); // 倒带缓冲区 buf.get(array); // 将数据复制到数组中
  覆盖:
  
  rewind 在类 Buffer
  
  返回:
  
  此缓冲区
  
  自:
  
  9
- compact
  
  public abstract ByteBuffer compact()
  压缩此缓冲区 (可选操作)。
  缓冲区当前位置和其限制之间（如果有）的字节将被复制到缓冲区的开头。也就是说，索引 p = position() 处的字节将被复制到索引零处，索引 p + 1 处的字节将被复制到索引一处，依此类推，直到索引 limit() - 1 处的字节被复制到索引 n = limit() - 1 - p 处。然后，缓冲区的位置设置为 n+1，其限制设置为其容量。如果已定义标记，则将其丢弃。
  
  缓冲区的位置设置为复制的字节数，而不是零，以便可以立即调用另一个相对 put 方法。
  
  在从缓冲区写入数据后调用此方法，以防写入不完整。例如，以下循环通过缓冲区 buf 从一个通道复制字节到另一个通道：
  
  buf.clear(); // 准备缓冲区以供使用 while (in.read(buf) >= 0 || buf.position != 0) { buf.flip(); out.write(buf); buf.compact(); // 部分写入时使用 }
  返回:
  
  此缓冲区
  
  抛出:
  
  ReadOnlyBufferException - 如果此缓冲区是只读的
- isDirect
  
  public abstract boolean isDirect()
  
  告诉此字节缓冲区是否是直接缓冲区。
  
  指定由:
  
  isDirect 在类 Buffer
  
  返回:
  
  如果此缓冲区是直接缓冲区，则返回true
- toString
  
  public String toString()
  
  返回总结此缓冲区状态的字符串。
  
  覆盖:
  
  toString 在类 Object
  
  返回:
  
  摘要字符串
- hashCode
  
  public int hashCode()
  
  返回此缓冲区的当前哈希码。
  字节缓冲区的哈希码仅取决于其剩余元素；也就是说，取决于从 position() 处到 limit() - 1 处的元素。
  
  由于缓冲区哈希码是内容相关的，因此不建议将缓冲区用作哈希映射或类似数据结构中的键，除非知道它们的内容不会更改。
  覆盖:
  
  hashCode 在类 Object
  
  返回:
  
  此缓冲区的当前哈希码
  
  参见:
  
  Object.equals(java.lang.Object)
  
  System.identityHashCode(java.lang.Object)
- equals
  
  public boolean equals(Object ob)
  告诉此缓冲区是否等于另一个对象。
  仅当两个字节缓冲区
  
  具有相同的元素类型，
  
  具有相同数量的剩余元素，并且
  
  两个剩余元素序列，独立于其起始位置，是逐点相等的。
  
  字节缓冲区不等于任何其他类型的对象。
  覆盖:
  
  equals 在类 Object中
  
  参数:
  
  ob - 要与此缓冲区进行比较的对象
  
  返回:
  
  如果此缓冲区等于给定对象，则返回true
  
  另请参阅:
  
  Object.hashCode()
  
  HashMap
- compareTo
  
  public int compareTo(ByteBuffer that)
  
  将此缓冲区与另一个进行比较。
  通过按字典顺序比较剩余元素的序列来比较两个字节缓冲区，而不考虑每个序列在相应缓冲区内的起始位置。对byte元素对进行比较，就好像调用Byte.compare(byte,byte)一样。
  
  字节缓冲区无法与任何其他类型的对象进行比较。
  
  指定者:
  
  compareTo 在接口 Comparable<ByteBuffer>中
  
  参数:
  
  that - 要比较的对象
  
  返回:
  
  如果此缓冲区小于、等于或大于给定缓冲区，则返回负整数、零或正整数
- mismatch
  
  public int mismatch(ByteBuffer that)
  
  查找并返回此缓冲区与给定缓冲区之间第一个不匹配的相对索引。该索引是相对于每个缓冲区的position，并且将在0（包括）到每个缓冲区中剩余元素的较小值（不包括）的范围内。
  如果两个缓冲区共享一个公共前缀，则返回的索引是公共前缀的长度，因此在各自缓冲区中的该索引处存在不匹配。如果一个缓冲区是另一个缓冲区的正确前缀，则返回的索引是每个缓冲区中剩余元素的较小值，因此该索引仅对具有较大剩余元素数量的缓冲区有效。否则，没有不匹配。
  
  参数:
  
  that - 要与此缓冲区进行不匹配测试的字节缓冲区
  
  返回:
  
  此缓冲区与给定缓冲区之间第一个不匹配的相对索引，否则如果没有不匹配则返回-1。
  
  自:
  
  11
- order
  
  public final ByteOrder order()
  
  检索此缓冲区的字节顺序。
  在读取或写入多字节值以及创建作为此字节缓冲区视图的缓冲区时使用字节顺序。新创建的字节缓冲区的顺序始终为BIG_ENDIAN。
  
  返回:
  
  此缓冲区的字节顺序
- order
  
  public final ByteBuffer order(ByteOrder bo)
  
  修改此缓冲区的字节顺序。
  
  参数:
  
  bo - 新的字节顺序，可以是BIG_ENDIAN或LITTLE_ENDIAN
  
  返回:
  
  此缓冲区
- alignmentOffset
  
  public final int alignmentOffset(int index, int unitSize)
  返回指向给定索引处的字节的内存地址，取模给定的单位大小。
  返回值在0（包括）到unitSize（不包括）的范围内为非负数，其中零表示索引处的字节地址对于单位大小是对齐的，正值表示地址对于单位大小是不对齐的。如果索引处的字节地址不对齐，则返回值表示应如何调整索引以定位到对齐地址的字节。具体来说，如果后者不大于index，则索引应减去返回值；否则，应增加单位大小减去返回值。因此，给定
  
  int value = alignmentOffset(index, unitSize)
  
  则恒等式
  
  alignmentOffset(index - value, unitSize) == 0, value <= index
  
  和
  
  alignmentOffset(index + (unitSize - value), unitSize) == 0
  
  必须成立。
  API 注意:
  
  如果本地平台支持，此方法可用于确定是否可以原子方式访问从索引开始的单位大小字节。
  
  实现注意:
  
  当给定的单位大小大于8时，此实现对非直接缓冲区抛出UnsupportedOperationException。
  
  参数:
  
  index - 要查询对齐偏移量的索引，必须为非负数，不执行上限检查
  
  unitSize - 字节单位大小，必须是2的幂
  
  返回:
  
  索引字节的内存地址对单位大小取模
  
  抛出:
  
  IllegalArgumentException - 如果索引为负数或单位大小不是2的幂
  
  UnsupportedOperationException - 如果本地平台在管理与此缓冲区相同类型的缓冲区的内存区域时不保证给定单位大小的稳定对齐偏移值。例如，如果垃圾回收导致非直接缓冲区覆盖的内存区域从一个位置移动到另一个位置，并且两个位置具有不同的对齐特性。
  
  自:
  
  9
  
  另请参阅:
  
  alignedSlice(int)
- alignedSlice
  
  public final ByteBuffer alignedSlice(int unitSize)
  创建一个新的字节缓冲区，其内容是此缓冲区内容的共享和对齐子序列。
  新缓冲区的内容将从此缓冲区的当前位置开始，向上舍入到给定单位大小的最接近对齐字节的索引，并在此缓冲区的限制向下舍入到给定单位大小的最接近对齐字节的索引结束。如果舍入导致超出边界值，则新缓冲区的容量和限制将为零。如果舍入在边界内，则对于新缓冲区nb和单位大小unitSize，以下表达式将为真：
  
  nb.alignmentOffset(0, unitSize) == 0 nb.alignmentOffset(nb.limit(), unitSize) == 0
  
  对此缓冲区内容的更改将在新缓冲区中可见，反之亦然；两个缓冲区的位置、限制和标记值将是独立的。
  
  新缓冲区的位置将为零，其容量和限制将是此缓冲区中剩余字节数或更少（取决于对齐情况），其标记将是未定义的，其字节顺序将为BIG_ENDIAN。如果且仅如果此缓冲区是直接的，则新缓冲区将是直接的，如果且仅如果此缓冲区是只读的，则新缓冲区将是只读的。
  API 注意:
  
  如果本地平台支持，此方法可用于创建一个新的缓冲区，其中可以原子方式访问从索引开始的单位大小字节，该索引是单位大小的倍数。
  
  实现注意:
  
  当给定的单位大小大于8时，此实现对非直接缓冲区抛出UnsupportedOperationException。
  
  参数:
  
  unitSize - 字节单位大小，必须是2的幂
  
  返回:
  
  新的字节缓冲区
  
  抛出:
  
  IllegalArgumentException - 如果单位大小不是2的幂
  
  UnsupportedOperationException - 如果本地平台在管理与此缓冲区相同类型的缓冲区的内存区域时不保证给定单位大小的稳定对齐切片。例如，如果垃圾回收导致非直接缓冲区覆盖的内存区域从一个位置移动到另一个位置，并且两个位置具有不同的对齐特性。
  
  自:
  
  9
  
  另请参阅:
  
  alignmentOffset(int, int)
  
  slice()
- getChar
  
  public abstract char getChar()
  
  用于读取char值的相对get方法。
  读取此缓冲区当前位置的下两个字节，根据当前字节顺序将它们组合成char值，然后将位置增加两。
  
  返回:
  
  缓冲区当前位置的char值
  
  抛出:
  
  BufferUnderflowException - 如果此缓冲区中剩余的字节数少于两个
- putChar
  
  public abstract ByteBuffer putChar(char value)
  
  用于写入char值的相对put方法 (可选操作)。
  将包含给定char值的两个字节，按照当前字节顺序，写入此缓冲区的当前位置，然后将位置增加两。
  
  参数:
  
  value - 要写入的字符值
  
  返回:
  
  此缓冲区
  
  抛出:
  
  BufferOverflowException - 如果此缓冲区中剩余的字节数少于两个
  
  ReadOnlyBufferException - 如果此缓冲区是只读的
- getChar
  
  public abstract char getChar(int index)
  
  绝对 get 方法用于读取字符值。
  在给定索引处读取两个字节，根据当前字节顺序将它们组合成一个字符值。
  
  参数:
  
  index - 将要读取字节的索引
  
  返回:
  
  给定索引处的字符值
  
  抛出:
  
  IndexOutOfBoundsException - 如果index为负数或不小于缓冲区的限制减一
- putChar
  
  public abstract ByteBuffer putChar(int index, char value)
  
  绝对 put 方法用于写入字符值 (可选操作)。
  将包含给定字符值的两个字节，按照当前字节顺序，写入到给定索引处的此缓冲区中。
  
  参数:
  
  index - 将要写入字节的索引
  
  value - 要写入的字符值
  
  返回:
  
  此缓冲区
  
  抛出:
  
  IndexOutOfBoundsException - 如果index为负数或不小于缓冲区的限制减一
  
  ReadOnlyBufferException - 如果此缓冲区是只读的
- asCharBuffer
  
  public abstract CharBuffer asCharBuffer()
  
  创建此字节缓冲区的 char 缓冲区视图。
  新缓冲区的内容将从此缓冲区的当前位置开始。对此缓冲区内容的更改将在新缓冲区中可见，反之亦然；两个缓冲区的位置、限制和标记值将是独立的。
  
  新缓冲区的位置将为零，其容量和限制将为此缓冲区中剩余字节数除以二，其标记将未定义，其字节顺序将为创建视图时的字节缓冲区的字节顺序。如果此缓冲区是直接的，则新缓冲区也将是直接的，如果此缓冲区是只读的，则新缓冲区也将是只读的。
  
  返回:
  
  一个新的 char 缓冲区
- getShort
  
  public abstract short getShort()
  
  相对 get 方法用于读取 short 值。
  在此缓冲区的当前位置读取接下来的两个字节，根据当前字节顺序将它们组合成一个 short 值，然后将位置增加两。
  
  返回:
  
  缓冲区当前位置的 short 值
  
  抛出:
  
  BufferUnderflowException - 如果此缓冲区中剩余的字节数少于两个
- putShort
  
  public abstract ByteBuffer putShort(short value)
  
  相对 put 方法用于写入 short 值 (可选操作)。
  将包含给定 short 值的两个字节，按照当前字节顺序，写入到当前位置的此缓冲区中，并将位置增加两。
  
  参数:
  
  value - 要写入的 short 值
  
  返回:
  
  此缓冲区
  
  抛出:
  
  BufferOverflowException - 如果此缓冲区中剩余的字节数少于两个
  
  ReadOnlyBufferException - 如果此缓冲区是只读的
- getShort
  
  public abstract short getShort(int index)
  
  绝对 get 方法用于读取 short 值。
  在给定索引处读取两个字节，根据当前字节顺序将它们组合成一个 short 值。
  
  参数:
  
  index - 将要读取字节的索引
  
  返回:
  
  给定索引处的 short 值
  
  抛出:
  
  IndexOutOfBoundsException - 如果index为负数或不小于缓冲区的限制减一
- putShort
  
  public abstract ByteBuffer putShort(int index, short value)
  
  绝对 put 方法用于写入 short 值 (可选操作)。
  将包含给定 short 值的两个字节，按照当前字节顺序，写入到给定索引处的此缓冲区中。
  
  参数:
  
  index - 将要写入字节的索引
  
  value - 要写入的 short 值
  
  返回:
  
  此缓冲区
  
  抛出:
  
  IndexOutOfBoundsException - 如果index为负数或不小于缓冲区的限制减一
  
  ReadOnlyBufferException - 如果此缓冲区是只读的
- asShortBuffer
  
  public abstract ShortBuffer asShortBuffer()
  
  创建此字节缓冲区的 short 缓冲区视图。
  新缓冲区的内容将从此缓冲区的当前位置开始。对此缓冲区内容的更改将在新缓冲区中可见，反之亦然；两个缓冲区的位置、限制和标记值将是独立的。
  
  新缓冲区的位置将为零，其容量和限制将为此缓冲区中剩余字节数除以二，其标记将未定义，其字节顺序将为创建视图时的字节缓冲区的字节顺序。如果此缓冲区是直接的，则新缓冲区也将是直接的，如果此缓冲区是只读的，则新缓冲区也将是只读的。
  
  返回:
  
  一个新的 short 缓冲区
- getInt
  
  public abstract int getInt()
  
  相对 get 方法用于读取 int 值。
  在此缓冲区的当前位置读取接下来的四个字节，根据当前字节顺序将它们组合成一个 int 值，然后将位置增加四。
  
  返回:
  
  缓冲区当前位置的 int 值
  
  抛出:
  
  BufferUnderflowException - 如果此缓冲区中剩余的字节数少于四个
- putInt
  
  public abstract ByteBuffer putInt(int value)
  
  相对 put 方法用于写入 int 值 (可选操作)。
  将包含给定 int 值的四个字节，按照当前字节顺序，写入到当前位置的此缓冲区中，并将位置增加四。
  
  参数:
  
  value - 要写入的 int 值
  
  返回:
  
  此缓冲区
  
  抛出:
  
  BufferOverflowException - 如果此缓冲区中剩余的字节数少于四个
  
  ReadOnlyBufferException - 如果此缓冲区是只读的
- getInt
  
  public abstract int getInt(int index)
  
  绝对 get 方法用于读取 int 值。
  在给定索引处读取四个字节，根据当前字节顺序将它们组合成一个 int 值。
  
  参数:
  
  index - 将要读取字节的索引
  
  返回:
  
  给定索引处的 int 值
  
  抛出:
  
  IndexOutOfBoundsException - 如果index为负数或不小于缓冲区的限制减三
- putInt
  
  public abstract ByteBuffer putInt(int index, int value)
  
  绝对 put 方法用于写入 int 值 (可选操作)。
  将包含给定 int 值的四个字节，按照当前字节顺序，写入到给定索引处的此缓冲区中。
  
  参数:
  
  index - 将要写入字节的索引
  
  value - 要写入的 int 值
  
  返回:
  
  此缓冲区
  
  抛出:
  
  IndexOutOfBoundsException - 如果index为负数或不小于缓冲区的限制减三
  
  ReadOnlyBufferException - 如果此缓冲区是只读的
- asIntBuffer
  
  public abstract IntBuffer asIntBuffer()
  
  创建此字节缓冲区的 int 缓冲区视图。
  新缓冲区的内容将从此缓冲区的当前位置开始。对此缓冲区内容的更改将在新缓冲区中可见，反之亦然；两个缓冲区的位置、限制和标记值将是独立的。
  
  新缓冲区的位置将为零，其容量和限制将为此缓冲区中剩余字节数除以四，其标记将未定义，其字节顺序将为创建视图时的字节缓冲区的字节顺序。如果此缓冲区是直接的，则新缓冲区也将是直接的，如果此缓冲区是只读的，则新缓冲区也将是只读的。
  
  返回:
  
  一个新的 int 缓冲区
- getLong
  
  public abstract long getLong()
  
  相对 get 方法用于读取 long 值。
  在此缓冲区的当前位置读取接下来的八个字节，根据当前字节顺序将它们组合成一个 long 值，然后将位置增加八。
  
  返回:
  
  缓冲区当前位置的 long 值
  
  抛出:
  
  BufferUnderflowException - 如果此缓冲区中剩余的字节数少于八个
- putLong
  
  public abstract ByteBuffer putLong(long value)
  
  相对 put 方法用于写入 long 值 (可选操作)。
  将包含给定 long 值的八个字节，按照当前字节顺序，写入到当前位置的此缓冲区中，并将位置增加八。
  
  参数:
  
  value - 要写入的 long 值
  
  返回:
  
  此缓冲区
  
  抛出:
  
  BufferOverflowException - 如果此缓冲区中剩余的字节数少于八个
  
  ReadOnlyBufferException - 如果此缓冲区是只读的
- getLong
  
  public abstract long getLong(int index)
  
  绝对 get 方法用于读取长整型值。
  根据当前字节顺序，从给定索引处读取八个字节，并将它们组合成一个长整型值。
  
  参数:
  
  index - 将要读取字节的索引
  
  返回:
  
  给定索引处的长整型值
  
  抛出:
  
  IndexOutOfBoundsException - 如果 index 为负数或不小于缓冲区的限制减去七
- putLong
  
  public abstract ByteBuffer putLong(int index, long value)
  
  绝对 put 方法用于写入长整型值 (可选操作)。
  根据当前字节顺序，将包含给定长整型值的八个字节写入到给定索引处的缓冲区中。
  
  参数:
  
  index - 将要写入字节的索引
  
  value - 将要写入的长整型值
  
  返回:
  
  此缓冲区
  
  抛出:
  
  IndexOutOfBoundsException - 如果 index 为负数或不小于缓冲区的限制减去七
  
  ReadOnlyBufferException - 如果此缓冲区为只读
- asLongBuffer
  
  public abstract LongBuffer asLongBuffer()
  
  创建此字节缓冲区的长整型缓冲区视图。
  新缓冲区的内容将从此缓冲区的当前位置开始。对此缓冲区内容的更改将在新缓冲区中可见，反之亦然；两个缓冲区的位置、限制和标记值将是独立的。
  
  新缓冲区的位置将为零，其容量和限制将为此缓冲区中剩余字节数除以八，其标记将未定义，其字节顺序将为创建视图时的字节缓冲区的字节顺序。如果此缓冲区为直接，则新缓冲区也将为直接，如果此缓冲区为只读，则新缓冲区也将为只读。
  
  返回:
  
  一个新的长整型缓冲区
- getFloat
  
  public abstract float getFloat()
  
  相对 get 方法用于读取浮点值。
  从此缓冲区的当前位置读取接下来的四个字节，根据当前字节顺序将它们组合成一个浮点值，然后将位置增加四。
  
  返回:
  
  缓冲区当前位置的浮点值
  
  抛出:
  
  BufferUnderflowException - 如果此缓冲区中剩余的字节数少于四个
- putFloat
  
  public abstract ByteBuffer putFloat(float value)
  
  相对 put 方法用于写入浮点值 (可选操作)。
  根据当前字节顺序，将包含给定浮点值的四个字节写入到此缓冲区的当前位置，并将位置增加四。
  
  参数:
  
  value - 将要写入的浮点值
  
  返回:
  
  此缓冲区
  
  抛出:
  
  BufferOverflowException - 如果此缓冲区中剩余的字节数少于四个
  
  ReadOnlyBufferException - 如果此缓冲区为只读
- getFloat
  
  public abstract float getFloat(int index)
  
  绝对 get 方法用于读取浮点值。
  根据当前字节顺序，从给定索引处读取四个字节，并将它们组合成一个浮点值。
  
  参数:
  
  index - 将要读取字节的索引
  
  返回:
  
  给定索引处的浮点值
  
  抛出:
  
  IndexOutOfBoundsException - 如果 index 为负数或不小于缓冲区的限制减去三
- putFloat
  
  public abstract ByteBuffer putFloat(int index, float value)
  
  绝对 put 方法用于写入浮点值 (可选操作)。
  根据当前字节顺序，将包含给定浮点值的四个字节写入到给定索引处的缓冲区中。
  
  参数:
  
  index - 将要写入字节的索引
  
  value - 将要写入的浮点值
  
  返回:
  
  此缓冲区
  
  抛出:
  
  IndexOutOfBoundsException - 如果 index 为负数或不小于缓冲区的限制减去三
  
  ReadOnlyBufferException - 如果此缓冲区为只读
- asFloatBuffer
  
  public abstract FloatBuffer asFloatBuffer()
  
  创建此字节缓冲区的浮点缓冲区视图。
  新缓冲区的内容将从此缓冲区的当前位置开始。对此缓冲区内容的更改将在新缓冲区中可见，反之亦然；两个缓冲区的位置、限制和标记值将是独立的。
  
  新缓冲区的位置将为零，其容量和限制将为此缓冲区中剩余字节数除以四，其标记将未定义，其字节顺序将为创建视图时的字节缓冲区的字节顺序。如果此缓冲区为直接，则新缓冲区也将为直接，如果此缓冲区为只读，则新缓冲区也将为只读。
  
  返回:
  
  一个新的浮点缓冲区
- getDouble
  
  public abstract double getDouble()
  
  相对 get 方法用于读取双精度浮点值。
  从此缓冲区的当前位置读取接下来的八个字节，根据当前字节顺序将它们组合成一个双精度浮点值，然后将位置增加八。
  
  返回:
  
  缓冲区当前位置的双精度浮点值
  
  抛出:
  
  BufferUnderflowException - 如果此缓冲区中剩余的字节数少于八个
- putDouble
  
  public abstract ByteBuffer putDouble(double value)
  
  相对 put 方法用于写入双精度浮点值 (可选操作)。
  根据当前字节顺序，将包含给定双精度浮点值的八个字节写入到此缓冲区的当前位置，并将位置增加八。
  
  参数:
  
  value - 将要写入的双精度浮点值
  
  返回:
  
  此缓冲区
  
  抛出:
  
  BufferOverflowException - 如果此缓冲区中剩余的字节数少于八个
  
  ReadOnlyBufferException - 如果此缓冲区为只读
- getDouble
  
  public abstract double getDouble(int index)
  
  绝对 get 方法用于读取双精度浮点值。
  根据当前字节顺序，从给定索引处读取八个字节，并将它们组合成一个双精度浮点值。
  
  参数:
  
  index - 将要读取字节的索引
  
  返回:
  
  给定索引处的双精度浮点值
  
  抛出:
  
  IndexOutOfBoundsException - 如果 index 为负数或不小于缓冲区的限制减去七
- putDouble
  
  public abstract ByteBuffer putDouble(int index, double value)
  
  绝对 put 方法用于写入双精度浮点值 (可选操作)。
  根据当前字节顺序，将包含给定双精度浮点值的八个字节写入到给定索引处的缓冲区中。
  
  参数:
  
  index - 将要写入字节的索引
  
  value - 将要写入的双精度浮点值
  
  返回:
  
  此缓冲区
  
  抛出:
  
  IndexOutOfBoundsException - 如果 index 为负数或不小于缓冲区的限制减去七
  
  ReadOnlyBufferException - 如果此缓冲区为只读
- asDoubleBuffer
  
  public abstract DoubleBuffer asDoubleBuffer()
  
  创建此字节缓冲区的双精度浮点缓冲区视图。
  新缓冲区的内容将从此缓冲区的当前位置开始。对此缓冲区内容的更改将在新缓冲区中可见，反之亦然；两个缓冲区的位置、限制和标记值将是独立的。
  
  新缓冲区的位置将为零，其容量和限制将为此缓冲区中剩余字节数除以八，其标记将未定义，其字节顺序将为创建视图时的字节缓冲区的字节顺序。如果此缓冲区为直接，则新缓冲区也将为直接，如果此缓冲区为只读，则新缓冲区也将为只读。
  
  返回:
  
  一个新的双精度浮点缓冲区

Class ByteBuffer

直接 vs. 非直接缓冲区

访问二进制数据

调用链接

可选操作

Method Summary

Methods declared in class java.nio.Buffer

Methods declared in class java.lang.Object

Method Details

allocateDirect

allocate

wrap

wrap

slice

slice

duplicate

asReadOnlyBuffer

get

put

get

put

get

get

get

get

put

put

put

put

put

put

hasArray

array

arrayOffset

position

limit

mark

reset

clear

flip

rewind

compact

isDirect

toString

hashCode

equals

compareTo

mismatch

order

order

alignmentOffset

alignedSlice

getChar

putChar

getChar

putChar

asCharBuffer

getShort

putShort

getShort

putShort

asShortBuffer

getInt

putInt

getInt

putInt

asIntBuffer

getLong

putLong

getLong

putLong

asLongBuffer

getFloat

putFloat

getFloat

putFloat

asFloatBuffer

getDouble

putDouble

getDouble