实现的所有接口

Comparable<ByteBuffer>

已知直接子类：

MappedByteBuffer
```
public abstract class ByteBufferextends Bufferimplements Comparable<ByteBuffer>
```
一个字节缓冲区。
该类在字节缓冲区上定义了六类操作：
- 绝对和相对get和put读写单字节的方法;
- 相对bulk get方法，将连续的字节序列从此缓冲区转移到数组中;
- 相对bulk put方法，将字节数组或其他字节缓冲区中的连续字节序列传输到此缓冲区中;
- 绝对和相对get和put方法，用于读取和写入其他基元类型的值，以特定字节顺序将它们转换为字节序列和从字节序列转换它们;
- 创建view buffers的方法，允许将字节缓冲区视为包含某些其他基本类型值的缓冲区; 和
- 一种用于compacting的字节缓冲区的方法。
字节缓冲区可以由allocation创建，它为缓冲区的内容分配空间，或者通过wrapping将现有的字节数组创建到缓冲区中。

直接与非直接缓冲

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

可以通过调用此类的allocateDirect工厂方法来创建直接字节缓冲区。与非直接缓冲区相比，此方法返回的缓冲区通常具有更高的分配和解除分配成本。直接缓冲区的内容可能位于正常的垃圾收集堆之外，因此它们对应用程序的内存占用量的影响可能并不明显。因此，建议直接缓冲区主要分配给受基础系统本机I / O操作影响的大型长期缓冲区。通常，最好只在它们在程序性能上产生可测量的增益时才分配直接缓冲区。

直接字节缓冲区也可以由mapping直接创建到存储器中的文件区域。 Java平台的实现可以可选地支持通过JNI从本机代码创建直接字节缓冲区。如果这些类型的缓冲区之一的实例引用了一个不可访问的内存区域，则访问该区域的尝试不会更改缓冲区的内容，并且会导致在访问时或稍后某个时间抛出未指定的异常时间。

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

访问二进制数据

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

为了访问异构二进制数据，即不同类型的值序列，该类为每种类型定义了一系列绝对和相对的get和put方法。例如，对于32位浮点值，此类定义：
```
 float  getFloat() float  getFloat(int index)  void  putFloat(float f)  void  putFloat(int index, float f)
```
为类型char, short, int, long和double定义了相应的方法。绝对get和put方法的索引参数是以字节而不是读取或写入的类型。

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

与上述类型特定的get和put方法系列相比，View缓冲区有三个重要优点：
- 视图缓冲区的索引不是以字节为单位，而是根据其值的类型特定大小进行索引;
- 视图缓冲区提供相对批量get和put方法，这些方法可以在缓冲区和数组或相同类型的某个其他缓冲区之间传输连续的值序列; 和
- 视图缓冲区可能更有效，因为当且仅当其后备字节缓冲区是直接缓冲区时，它才是直接的。
视图缓冲区的字节顺序固定为创建视图时其字节缓冲区的字节顺序。

调用链接

此类中没有返回值的方法被指定为返回调用它们的缓冲区。这允许链接方法调用。陈述的顺序
```
 bb.putInt(0xCAFEBABE); bb.putShort(3); bb.putShort(45);
```
例如，可以用单个语句替换
```
 bb.putInt(0xCAFEBABE).putShort(3).putShort(45);
```
从以下版本开始：

1.4

方法摘要

所有方法静态方法实例方法抽象方法具体的方法
变量和类型	方法	描述
`ByteBuffer`	`alignedSlice(int unitSize)`	创建一个新的字节缓冲区，其内容是此缓冲区内容的共享和对齐的子序列。
`int`	`alignmentOffset(int index, int unitSize)`	返回内存地址，指向给定索引处的字节，给定单位大小的模数。
`static ByteBuffer`	`allocate(int capacity)`	分配一个新的字节缓冲区。
`static ByteBuffer`	`allocateDirect(int capacity)`	分配新的直接字节缓冲区。
`byte[]`	`array()`	返回支持此缓冲区的字节数组（可选操作）。
`int`	`arrayOffset()`	返回此缓冲区缓冲区第一个元素的后备数组中的偏移量（可选操作）。
`abstract CharBuffer`	`asCharBuffer()`	将此字节缓冲区的视图创建为char缓冲区。
`abstract DoubleBuffer`	`asDoubleBuffer()`	将此字节缓冲区的视图创建为双缓冲区。
`abstract FloatBuffer`	`asFloatBuffer()`	将此字节缓冲区的视图创建为浮点缓冲区。
`abstract IntBuffer`	`asIntBuffer()`	将此字节缓冲区的视图创建为int缓冲区。
`abstract LongBuffer`	`asLongBuffer()`	将此字节缓冲区的视图创建为长缓冲区。
`abstract ByteBuffer`	`asReadOnlyBuffer()`	创建一个共享此缓冲区内容的新的只读字节缓冲区。
`abstract ShortBuffer`	`asShortBuffer()`	将此字节缓冲区的视图创建为短缓冲区。
`abstract ByteBuffer`	`compact()`	压缩此缓冲区（可选操作）。
`int`	`compareTo(ByteBuffer that)`	比较此缓冲区与另一个缓冲区。
`abstract ByteBuffer`	`duplicate()`	创建一个共享此缓冲区内容的新字节缓冲区。
`boolean`	`equals(Object ob)`	判断此缓冲区是否等于另一个对象。
`abstract byte`	`get()`	相对 get方法。
`ByteBuffer`	`get(byte[] dst)`	相对批量获取方法。
`ByteBuffer`	`get(byte[] dst, int offset, int length)`	相对批量获取方法。
`abstract byte`	`get(int index)`	绝对获取方法。
`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()`	用于读取浮点值的相对 get方法。
`abstract float`	`getFloat(int index)`	用于读取浮点值的绝对 get方法。
`abstract int`	`getInt()`	读取int值的相对 get方法。
`abstract int`	`getInt(int index)`	用于读取int值的绝对 get方法。
`abstract long`	`getLong()`	读取长值的相对 get方法。
`abstract long`	`getLong(int index)`	用于读取长值的绝对 get方法。
`abstract short`	`getShort()`	读取短值的相对 get方法。
`abstract short`	`getShort(int index)`	用于读取短值的绝对 get方法。
`boolean`	`hasArray()`	判断此缓冲区是否由可访问的字节数组支持。
`int`	`hashCode()`	返回此缓冲区的当前哈希码。
`abstract boolean`	`isDirect()`	判断此字节缓冲区是否是直接的。
`int`	`mismatch(ByteBuffer that)`	查找并返回此缓冲区与给定缓冲区之间第一个不匹配的相对索引。
`ByteOrder`	`order()`	检索此缓冲区的字节顺序。
`ByteBuffer`	`order(ByteOrder bo)`	修改此缓冲区的字节顺序。
`abstract ByteBuffer`	`put(byte b)`	相对 put方法（可选操作）。
`ByteBuffer`	`put(byte[] src)`	相对批量放置方法（可选操作）。
`ByteBuffer`	`put(byte[] src, int offset, int length)`	相对批量放置方法（可选操作）。
`abstract ByteBuffer`	`put(int index, byte b)`	绝对放法（可选操作）。
`ByteBuffer`	`put(ByteBuffer src)`	相对批量放置方法（可选操作）。
`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)`	用于写入浮点值的相对 put方法（可选操作）。
`abstract ByteBuffer`	`putFloat(int index, float value)`	用于写入浮点值的绝对 put方法（可选操作）。
`abstract ByteBuffer`	`putInt(int value)`	用于写入int值的相对 put方法（可选操作）。
`abstract ByteBuffer`	`putInt(int index, int value)`	用于写入int值的绝对 put方法（可选操作）。
`abstract ByteBuffer`	`putLong(int index, long value)`	用于写入长值的绝对 put方法（可选操作）。
`abstract ByteBuffer`	`putLong(long value)`	用于写入长值的相对 put方法（可选操作）。
`abstract ByteBuffer`	`putShort(int index, short value)`	用于写入短值的绝对 put方法（可选操作）。
`abstract ByteBuffer`	`putShort(short value)`	用于写入短值的相对 put方法（可选操作）。
`abstract ByteBuffer`	`slice()`	创建一个新的字节缓冲区，其内容是此缓冲区内容的共享子序列。
`String`	`toString()`	返回总结此缓冲区状态的字符串。
`static ByteBuffer`	`wrap(byte[] array)`	将字节数组包装到缓冲区中。
`static ByteBuffer`	`wrap(byte[] array, int offset, int length)`	将字节数组包装到缓冲区中。

声明方法的类 java.nio.Buffer
capacity, clear, flip, hasRemaining, isReadOnly, limit, limit, mark, position, position, remaining, reset, rewind

声明方法的类 java.lang.Object
clone, finalize, getClass, notify, notifyAll, wait, wait, wait

- 方法详细信息
  - allocateDirect
```
public static ByteBuffer allocateDirect(int capacity)
```
    分配新的直接字节缓冲区。
    新缓冲区的位置将为零，其限制将是其容量，其标记将是未定义的，其每个元素将初始化为零，其字节顺序将为BIG_ENDIAN 。是否有backing array未指定。
    
    参数
    
    capacity - 新缓冲区的容量，以字节为单位
    
    结果
    
    新的字节缓冲区
    
    异常
    
    IllegalArgumentException - 如果 capacity是负整数
  - allocate
```
public static ByteBuffer allocate(int capacity)
```
    分配一个新的字节缓冲区。
    新缓冲区的位置将为零，其限制将是其容量，其标记将是未定义的，其每个元素将初始化为零，其字节顺序将为BIG_ENDIAN 。它将有一个backing array ，其array offset将为零。
    
    参数
    
    capacity - 新缓冲区的容量，以字节为单位
    
    结果
    
    新的字节缓冲区
    
    异常
    
    IllegalArgumentException - 如果 capacity是负整数
  - wrap
```
public static ByteBuffer wrap(byte[] array,                              int offset,                              int length)
```
    将字节数组包装到缓冲区中。
    新缓冲区将由给定的字节数组支持; 也就是说，对缓冲区的修改将导致数组被修改，反之亦然。新缓冲区的容量为array.length ，其位置为offset ，其限制为offset + length ，其标记为未定义，其字节顺序为BIG_ENDIAN 。它的backing array将是给定的数组，其array offset将为零。
    
    参数
    
    array - 将支持新缓冲区的数组
    
    offset - 要使用的子阵列的偏移量; 必须是非负数且不大于array.length 。新缓冲区的位置将设置为此值。
    
    length - 要使用的子阵列的长度; 必须是非负数且不大于array.length - offset 。新缓冲区的限制将设置为offset + length 。
    
    结果
    
    新的字节缓冲区
    
    异常
    
    IndexOutOfBoundsException - 如果 offset和 length参数的前提条件不成立
  - wrap
```
public static ByteBuffer wrap(byte[] array)
```
    将字节数组包装到缓冲区中。
    新缓冲区将由给定的字节数组支持; 也就是说，对缓冲区的修改将导致数组被修改，反之亦然。新缓冲区的容量和限制将为array.length ，其位置将为零，其标记将是未定义的，其字节顺序将为BIG_ENDIAN 。它的backing array将是给定的阵列，其array offset将为零。
    
    参数
    
    array - 将支持此缓冲区的数组
    
    结果
    
    新的字节缓冲区
  - slice
```
public abstract ByteBuffer slice()
```
    创建一个新的字节缓冲区，其内容是此缓冲区内容的共享子序列。
    新缓冲区的内容将从此缓冲区的当前位置开始。对此缓冲区内容的更改将在新缓冲区中可见，反之亦然; 两个缓冲区的位置，限制和标记值将是独立的。
    
    新缓冲区的位置将为零，其容量和限制将是此缓冲区中剩余的字节数，其标记将是未定义的，其字节顺序将为BIG_ENDIAN 。当且仅当此缓冲区是直接缓冲区时，新缓冲区将是直接的，并且当且仅当此缓冲区是只读时，它才是只读的。
    
    Specified by:
    
    slice在类 Buffer
    
    结果
    
    新的字节缓冲区
    
    另请参见：
    
    alignedSlice(int)
  - duplicate
```
public abstract ByteBuffer duplicate()
```
    创建一个共享此缓冲区内容的新字节缓冲区。
    新缓冲区的内容将是此缓冲区的内容。对此缓冲区内容的更改将在新缓冲区中可见，反之亦然; 两个缓冲区的位置，限制和标记值将是独立的。
    
    新缓冲区的容量，限制，位置和标记值将与此缓冲区的值相同，其字节顺序为BIG_ENDIAN 。当且仅当此缓冲区是直接缓冲区时，新缓冲区将是直接的，并且当且仅当此缓冲区是只读时，它才是只读的。
    
    Specified by:
    
    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)
```
    绝对获取方法。读取给定索引处的字节。
    
    参数
    
    index - 将从中读取字节的索引
    
    结果
    
    给定索引处的字节
    
    异常
    
    IndexOutOfBoundsException - 如果 index为负数或不小于缓冲区的限制
  - put
```
public abstract ByteBuffer put(int index,                               byte b)
```
    绝对放法（可选操作） 。
    在给定索引处将给定字节写入此缓冲区。
    
    参数
    
    index - 将写入字节的索引
    
    b - 要写入的字节值
    
    结果
    
    这个缓冲区
    
    异常
    
    IndexOutOfBoundsException - 如果 index为负数或不小于缓冲区的限制
    
    ReadOnlyBufferException - 如果此缓冲区是只读的
  - get
```
public ByteBuffer get(byte[] dst,                      int offset,                      int length)
```
    相对批量获取方法。
    此方法将字节从此缓冲区传输到给定的目标数组。如果缓冲区中剩余的字节数少于满足请求所需的字节数，即length > remaining() ，则不传输任何字节并抛出BufferUnderflowException 。
    
    否则，此方法将length字节从此缓冲区复制到给定数组中，从此缓冲区的当前位置开始并在阵列中的给定偏移量处开始。然后，此缓冲区的位置增加length 。
    
    换句话说，调用src.get(dst, off, len)形式的此方法与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)
```
    相对批量获取方法。
    此方法将字节从此缓冲区传输到给定的目标数组。调用src.get(a)形式的此方法的行为与调用的方式完全相同
    
    src.get(a, 0, a.length)
    参数
    
    dst - 目标阵列
    
    结果
    
    这个缓冲区
    
    异常
    
    BufferUnderflowException - 如果此缓冲区中剩余的字节少于 length
  - put
```
public ByteBuffer put(ByteBuffer src)
```
    相对批量放置方法（可选操作） 。
    此方法将给定源缓冲区中剩余的字节传输到此缓冲区。如果源缓冲区中剩余的字节数多于此缓冲区中的字节数，即src.remaining() > remaining() ，则不传输任何字节并抛出BufferOverflowException 。
    
    否则，此方法从给定缓冲区将n = src.remaining()个字节复制到此缓冲区中，从每个缓冲区的当前位置开始。然后两个缓冲区的位置增加n 。
    
    换句话说，调用dst.put(src)形式的此方法与dst.put(src)具有完全相同的效果
    
    while (src.hasRemaining()) dst.put(src.get());
    除了它首先检查此缓冲区中是否有足够的空间，它可能更有效。
    参数
    
    src - 要从中读取字节的源缓冲区; 一定不能是这个缓冲区
    
    结果
    
    这个缓冲区
    
    异常
    
    BufferOverflowException - 如果此缓冲区中没有足够的空间用于源缓冲区中的剩余字节
    
    IllegalArgumentException - 如果源缓冲区是此缓冲区
    
    ReadOnlyBufferException - 如果此缓冲区是只读的
  - put
```
public ByteBuffer put(byte[] src,                      int offset,                      int length)
```
    相对批量放置方法（可选操作） 。
    此方法将字节从给定的源数组传输到此缓冲区。如果要从数组中复制的字节数多于保留在此缓冲区中的字节数，即length > remaining() ，则不传输任何字节并抛出BufferOverflowException 。
    
    否则，此方法将length字节从给定数组复制到此缓冲区，从数组中的给定偏移量开始，并在此缓冲区的当前位置。然后，此缓冲区的位置增加length 。
    
    换句话说，调用dst.put(src, off, len)形式的此方法与dst.put(src, off, len)具有完全相同的效果
    
    for (int i = off; i < off + len; i++) dst.put(a[i]);
    除了它首先检查此缓冲区中是否有足够的空间，它可能更有效。
    参数
    
    src - 要从中读取字节的数组
    
    offset - 要读取的第一个字节的数组内的偏移量; 必须是非负数且不大于array.length
    
    length - 从给定数组中读取的字节数; 必须是非负数且不大于array.length - offset
    
    结果
    
    这个缓冲区
    
    异常
    
    BufferOverflowException - 如果此缓冲区中没有足够的空间
    
    IndexOutOfBoundsException - 如果 offset和 length参数的前提条件不成立
    
    ReadOnlyBufferException - 如果此缓冲区是只读的
  - put
```
public final ByteBuffer put(byte[] src)
```
    相对批量放置方法（可选操作） 。
    此方法将给定源字节数组的整个内容传输到此缓冲区。调用dst.put(a)形式的此方法的行为与调用的方式完全相同
    
    dst.put(a, 0, a.length)
    参数
    
    src - 源数组
    
    结果
    
    这个缓冲区
    
    异常
    
    BufferOverflowException - 如果此缓冲区中没有足够的空间
    
    ReadOnlyBufferException - 如果此缓冲区是只读的
  - hasArray
```
public final boolean hasArray()
```
    判断此缓冲区是否由可访问的字节数组支持。
    如果此方法返回true则可以安全地调用array和arrayOffset方法。
    
    Specified by:
    
    hasArray在类 Buffer
    
    结果
    
    true当且仅当此缓冲区由数组支持且不是只读时
  - array
```
public final byte[] array()
```
    返回支持此缓冲区的字节数组（可选操作） 。
    修改此缓冲区的内容将导致返回的数组内容被修改，反之亦然。
    
    在调用此方法之前调用hasArray方法，以确保此缓冲区具有可访问的后备阵列。
    
    Specified by:
    
    array在类 Buffer
    
    结果
    
    支持此缓冲区的数组
    
    异常
    
    ReadOnlyBufferException - 如果此缓冲区由数组支持但是只读
    
    UnsupportedOperationException - 如果此缓冲区未由可访问的阵列支持
  - arrayOffset
```
public final int arrayOffset()
```
    返回此缓冲区缓冲区第一个元素的后备数组中的偏移量（可选操作） 。
    如果此缓冲区由数组支持，则缓冲区位置p对应于数组索引p + arrayOffset() 。
    
    在调用此方法之前调用hasArray方法，以确保此缓冲区具有可访问的后备阵列。
    
    Specified by:
    
    arrayOffset ，类 Buffer
    
    结果
    
    缓冲区第一个元素的缓冲区数组中的偏移量
    
    异常
    
    ReadOnlyBufferException - 如果此缓冲区由数组支持但是只读
    
    UnsupportedOperationException - 如果此缓冲区未由可访问的阵列支持
  - compact
```
public abstract ByteBuffer compact()
```
    压缩此缓冲区（可选操作） 。
    缓冲区当前位置与其限制之间的字节（如果有）将复制到缓冲区的开头。也就是说，索引p = position()处的字节被复制到索引0，索引p + 1处的字节被复制到索引1，依此类推，直到索引limit()处的字节被复制到索引n = limit() - 1 - p 。然后将缓冲区的位置设置为n + 1，并将其限制设置为其容量。标记（如果已定义）将被丢弃。
    
    缓冲区的位置设置为复制的字节数，而不是零，因此可以通过调用另一个相对put方法立即调用此方法。
    
    在写入不完整的情况下从缓冲区写入数据后调用此方法。例如，以下循环通过缓冲区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 }
    结果
    
    这个缓冲区
    
    异常
    
    ReadOnlyBufferException - 如果此缓冲区是只读的
  - isDirect
```
public abstract boolean isDirect()
```
    判断此字节缓冲区是否是直接的。
    
    Specified by:
    
    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)进行比较。
    
    字节缓冲区与任何其他类型的对象都不具有可比性。
    
    Specified by:
    
    compareTo ，界面 Comparable<ByteBuffer>
    
    参数
    
    that - 要比较的对象。
    
    结果
    
    此缓冲区小于，等于或大于给定缓冲区的负整数，零或正整数
  - mismatch
```
public int mismatch(ByteBuffer that)
```
    查找并返回此缓冲区与给定缓冲区之间第一个不匹配的相对索引。索引相对于每个缓冲区的position ，并且将在0（包括）范围内，直到每个缓冲区中remaining元素中较小的一个（不包括）。
    如果两个缓冲区共享一个公共前缀，则返回的索引是公共前缀的长度，并且随后在相应缓冲区内该索引处的两个缓冲区之间存在不匹配。如果一个缓冲区是另一个缓冲区的正确前缀，则返回的索引是每个缓冲区中剩余元素中较小的一个，并且随后索引仅对具有较多剩余元素的缓冲区有效。否则，没有不匹配。
    
    参数
    
    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表示索引处字节的地址与单元大小对齐。
    
    API Note:
    
    如果原生平台支持，则可以利用该方法来确定是否可以原子地访问来自索引的单位大小字节。
    
    Implementation Note:
    
    此实现抛出 UnsupportedOperationException非直接缓冲区时给定的单元尺寸大于 8 。
    
    参数
    
    index - 查询对齐偏移的索引必须为非负数，不执行上限检查
    
    unitSize - 以字节为单位的单位大小，必须是 2
    
    结果
    
    索引字节的内存地址模数单位大小
    
    异常
    
    IllegalArgumentException - 如果索引为负数或单位大小不是 2
    
    UnsupportedOperationException - 如果在管理与此缓冲区相同类型的缓冲区（直接或非直接）的内存区域时，本机平台不保证给定单元大小的稳定对齐偏移值。例如，如果垃圾收集将导致由非直接缓冲区覆盖的存储区域从一个位置移动到另一个位置，并且两个位置具有不同的对齐特性。
    
    从以下版本开始：
    
    9
    
    另请参见：
    
    alignedSlice(int)
  - alignedSlice
```
public final ByteBuffer alignedSlice(int unitSize)
```
    创建一个新的字节缓冲区，其内容是此缓冲区内容的共享和对齐的子序列。
    新缓冲区的内容将从此缓冲区的当前位置开始向上舍入到给定单位大小的最近对齐字节的索引，并在此缓冲区的限制处向下舍入到给定单位大小的最近对齐字节的索引处。如果舍入导致越界值，则新缓冲区的容量和限制将为零。如果舍入在范围内，则对于新缓冲区nb和单位大小unitSize ，以下表达式将为true：
    
    nb.alignmentOffset(0, unitSize) == 0 nb.alignmentOffset(nb.limit(), unitSize) == 0
    
    对此缓冲区内容的更改将在新缓冲区中可见，反之亦然; 两个缓冲区的位置，限制和标记值将是独立的。
    
    新缓冲区的位置将为零，其容量和限制将是此缓冲区中剩余的字节数或更少的对齐位置，其标记将是未定义的，其字节顺序将为BIG_ENDIAN 。当且仅当此缓冲区是直接缓冲区时，新缓冲区将是直接的，并且当且仅当此缓冲区是只读时，它才是只读的。
    API Note:
    
    该方法可以用于创建新缓冲区，其中如果原生平台支持，则可以原子地访问来自索引的单位大小字节，即单元大小的倍数。
    
    Implementation Note:
    
    此实现抛出 UnsupportedOperationException非直接缓冲区时给定的单元尺寸大于 8 。
    
    参数
    
    unitSize - 以字节为单位的单位大小，必须是 2
    
    结果
    
    新的字节缓冲区
    
    异常
    
    IllegalArgumentException - 如果单位大小不是 2的功率
    
    UnsupportedOperationException - 如果在管理与此缓冲区（直接或非直接）相同类型的缓冲区的内存区域时，本机平台不保证给定单元大小的稳定对齐切片。例如，如果垃圾收集将导致由非直接缓冲区覆盖的存储区域从一个位置移动到另一个位置，并且两个位置具有不同的对齐特性。
    
    从以下版本开始：
    
    9
    
    另请参见：
    
    alignmentOffset(int, int) ， slice()
  - getChar
```
public abstract char getChar()
```
    用于读取char值的相对get方法。
    读取此缓冲区当前位置的下两个字节，根据当前字节顺序将它们组成char值，然后将位置递增2。
    
    结果
    
    缓冲区当前位置的char值
    
    异常
    
    BufferUnderflowException - 如果此缓冲区中剩余的字节少于两个
  - putChar
```
public abstract ByteBuffer putChar(char value)
```
    用于写入char值的相对put方法（可选操作） 。
    将包含给定char值的两个字节（按当前字节顺序）写入当前位置的此缓冲区，然后将位置递增2。
    
    参数
    
    value - 要写入的char值
    
    结果
    
    这个缓冲区
    
    异常
    
    BufferOverflowException - 如果此缓冲区中剩余的字节少于两个
    
    ReadOnlyBufferException - 如果此缓冲区是只读的
  - getChar
```
public abstract char getChar(int index)
```
    用于读取char值的绝对get方法。
    读取给定索引处的两个字节，根据当前字节顺序将它们组成char值。
    
    参数
    
    index - 将从中读取字节的索引
    
    结果
    
    给定索引处的char值
    
    异常
    
    IndexOutOfBoundsException - 如果 index为负数或不小于缓冲区的限制，则减1
  - putChar
```
public abstract ByteBuffer putChar(int index,                                   char value)
```
    用于写入char值的绝对put方法（可选操作） 。
    将包含给定char值的两个字节（按当前字节顺序）写入给定索引处的此缓冲区。
    
    参数
    
    index - 将写入字节的索引
    
    value - 要写入的char值
    
    结果
    
    这个缓冲区
    
    异常
    
    IndexOutOfBoundsException - 如果 index为负数或不小于缓冲区的限制，则减1
    
    ReadOnlyBufferException - 如果此缓冲区是只读的
  - asCharBuffer
```
public abstract CharBuffer asCharBuffer()
```
    将此字节缓冲区的视图创建为char缓冲区。
    新缓冲区的内容将从此缓冲区的当前位置开始。对此缓冲区内容的更改将在新缓冲区中可见，反之亦然; 两个缓冲区的位置，限制和标记值将是独立的。
    
    新缓冲区的位置将为零，其容量和限制将是此缓冲区中剩余的字节数除以2，其标记将是未定义的，并且其字节顺序将是视图时的字节缓冲区的顺序创建。当且仅当此缓冲区是直接缓冲区时，新缓冲区将是直接的，并且当且仅当此缓冲区是只读时，它才是只读的。
    
    结果
    
    一个新的char缓冲区
  - getShort
```
public abstract short getShort()
```
    读取短值的相对get方法。
    读取此缓冲区当前位置的下两个字节，根据当前字节顺序将它们组成一个短值，然后将位置递增2。
    
    结果
    
    缓冲区当前位置的短值
    
    异常
    
    BufferUnderflowException - 如果此缓冲区中剩余的字节少于两个
  - putShort
```
public abstract ByteBuffer putShort(short value)
```
    用于写入短值的相对put方法（可选操作） 。
    将包含给定short值的两个字节（按当前字节顺序）写入当前位置的此缓冲区，然后将位置递增2。
    
    参数
    
    value - 要写入的短值
    
    结果
    
    这个缓冲区
    
    异常
    
    BufferOverflowException - 如果此缓冲区中剩余的字节少于两个
    
    ReadOnlyBufferException - 如果此缓冲区是只读的
  - getShort
```
public abstract short getShort(int index)
```
    用于读取短值的绝对get方法。
    读取给定索引处的两个字节，根据当前字节顺序将它们组成一个短值。
    
    参数
    
    index - 将从中读取字节的索引
    
    结果
    
    给定指数的短值
    
    异常
    
    IndexOutOfBoundsException - 如果 index为负数或不小于缓冲区限制，则减1
  - putShort
```
public abstract ByteBuffer putShort(int index,                                    short value)
```
    用于写入短值的绝对put方法（可选操作） 。
    将包含给定short值的两个字节（按当前字节顺序）写入给定索引处的此缓冲区。
    
    参数
    
    index - 将写入字节的索引
    
    value - 要写入的短值
    
    结果
    
    这个缓冲区
    
    异常
    
    IndexOutOfBoundsException - 如果 index为负数或不小于缓冲区的限制，则减1
    
    ReadOnlyBufferException - 如果此缓冲区是只读的
  - asShortBuffer
```
public abstract ShortBuffer asShortBuffer()
```
    将此字节缓冲区的视图创建为短缓冲区。
    新缓冲区的内容将从此缓冲区的当前位置开始。对此缓冲区内容的更改将在新缓冲区中可见，反之亦然; 两个缓冲区的位置，限制和标记值将是独立的。
    
    新缓冲区的位置将为零，其容量和限制将是此缓冲区中剩余的字节数除以2，其标记将是未定义的，并且其字节顺序将是视图时的字节缓冲区的顺序创建。当且仅当此缓冲区是直接缓冲区时，新缓冲区将是直接的，并且当且仅当此缓冲区是只读时，它才是只读的。
    
    结果
    
    一个新的短缓冲区
  - getInt
```
public abstract int getInt()
```
    读取int值的相对get方法。
    在此缓冲区的当前位置读取接下来的四个字节，根据当前字节顺序将它们组成一个int值，然后将位置增加四。
    
    结果
    
    缓冲区当前位置的int值
    
    异常
    
    BufferUnderflowException - 如果此缓冲区中剩余的字节少于四个
  - putInt
```
public abstract ByteBuffer putInt(int value)
```
    用于写入int值的相对put方法（可选操作） 。
    将包含给定int值的四个字节（按当前字节顺序）写入当前位置的此缓冲区，然后将位置递增4。
    
    参数
    
    value - 要写入的int值
    
    结果
    
    这个缓冲区
    
    异常
    
    BufferOverflowException - 如果此缓冲区中剩余的字节少于四个
    
    ReadOnlyBufferException - 如果此缓冲区是只读的
  - getInt
```
public abstract int getInt(int index)
```
    用于读取int值的绝对get方法。
    读取给定索引处的四个字节，根据当前字节顺序将它们组成一个int值。
    
    参数
    
    index - 将从中读取字节的索引
    
    结果
    
    给定索引处的int值
    
    异常
    
    IndexOutOfBoundsException - 如果 index为负数或不小于缓冲区的限制，则减去3
  - putInt
```
public abstract ByteBuffer putInt(int index,                                  int value)
```
    用于写入int值的绝对put方法（可选操作） 。
    将包含给定int值的四个字节（按当前字节顺序）写入给定索引处的此缓冲区。
    
    参数
    
    index - 将写入字节的索引
    
    value - 要写入的int值
    
    结果
    
    这个缓冲区
    
    异常
    
    IndexOutOfBoundsException - 如果 index为负数或不小于缓冲区的限制，则减去3
    
    ReadOnlyBufferException - 如果此缓冲区是只读的
  - asIntBuffer
```
public abstract IntBuffer asIntBuffer()
```
    将此字节缓冲区的视图创建为int缓冲区。
    新缓冲区的内容将从此缓冲区的当前位置开始。对此缓冲区内容的更改将在新缓冲区中可见，反之亦然; 两个缓冲区的位置，限制和标记值将是独立的。
    
    新缓冲区的位置将为零，其容量和限制将是此缓冲区中剩余的字节数除以4，其标记将是未定义的，并且其字节顺序将是视图时的字节缓冲区的顺序创建。当且仅当此缓冲区是直接缓冲区时，新缓冲区将是直接的，并且当且仅当此缓冲区是只读时，它才是只读的。
    
    结果
    
    一个新的int缓冲区
  - getLong
```
public abstract long getLong()
```
    读取长值的相对get方法。
    读取此缓冲区当前位置的下八个字节，根据当前字节顺序将它们组成一个long值，然后将位置递增8。
    
    结果
    
    缓冲区当前位置的长值
    
    异常
    
    BufferUnderflowException - 如果此缓冲区中剩余的字节少于8个字节
  - putLong
```
public abstract ByteBuffer putLong(long value)
```
    用于写入长值的相对put方法（可选操作） 。
    将包含给定long值的八个字节（按当前字节顺序）写入当前位置的此缓冲区，然后将位置递增8。
    
    参数
    
    value - 要写入的长值
    
    结果
    
    这个缓冲区
    
    异常
    
    BufferOverflowException - 如果此缓冲区中剩余的字节少于8个
    
    ReadOnlyBufferException - 如果此缓冲区是只读的
  - getLong
```
public abstract long getLong(int index)
```
    用于读取长值的绝对get方法。
    读取给定索引处的八个字节，根据当前字节顺序将它们组成一个long值。
    
    参数
    
    index - 将从中读取字节的索引
    
    结果
    
    给定指数的长值
    
    异常
    
    IndexOutOfBoundsException - 如果 index为负数或不小于缓冲区的限制，则减去7
  - putLong
```
public abstract ByteBuffer putLong(int index,                                   long value)
```
    用于写入长值的绝对put方法（可选操作） 。
    将包含给定long值的八个字节（按当前字节顺序）写入给定索引处的此缓冲区。
    
    参数
    
    index - 将写入字节的索引
    
    value - 要写入的长值
    
    结果
    
    这个缓冲区
    
    异常
    
    IndexOutOfBoundsException - 如果 index为负数或不小于缓冲区的限制，则减去7
    
    ReadOnlyBufferException - 如果此缓冲区是只读的
  - asLongBuffer
```
public abstract LongBuffer asLongBuffer()
```
    将此字节缓冲区的视图创建为长缓冲区。
    新缓冲区的内容将从此缓冲区的当前位置开始。对此缓冲区内容的更改将在新缓冲区中可见，反之亦然; 两个缓冲区的位置，限制和标记值将是独立的。
    
    新缓冲区的位置将为零，其容量和限制将是此缓冲区中剩余的字节数除以8，其标记将是未定义的，并且其字节顺序将是视图时的字节缓冲区的顺序创建。当且仅当此缓冲区是直接缓冲区时，新缓冲区将是直接的，并且当且仅当此缓冲区是只读时，它才是只读的。
    
    结果
    
    一个新的长缓冲区
  - getFloat
```
public abstract float getFloat()
```
    用于读取浮点值的相对get方法。
    读取此缓冲区当前位置的下四个字节，根据当前字节顺序将它们组成浮点值，然后将位置递增4。
    
    结果
    
    缓冲区当前位置的浮点值
    
    异常
    
    BufferUnderflowException - 如果此缓冲区中剩余的字节少于四个
  - putFloat
```
public abstract ByteBuffer putFloat(float value)
```
    用于写入浮点值的相对put方法（可选操作） 。
    将包含给定float值的四个字节（以当前字节顺序）写入当前位置的此缓冲区，然后将位置增加四。
    
    参数
    
    value - 要写入的浮点值
    
    结果
    
    这个缓冲区
    
    异常
    
    BufferOverflowException - 如果此缓冲区中剩余的字节少于四个
    
    ReadOnlyBufferException - 如果此缓冲区是只读的
  - getFloat
```
public abstract float getFloat(int index)
```
    用于读取浮点值的绝对get方法。
    读取给定索引处的四个字节，根据当前字节顺序将它们组成浮点值。
    
    参数
    
    index - 将从中读取字节的索引
    
    结果
    
    给定索引处的浮点值
    
    异常
    
    IndexOutOfBoundsException - 如果 index为负数或不小于缓冲区的限制，则减去3
  - putFloat
```
public abstract ByteBuffer putFloat(int index,                                    float value)
```
    用于写入浮点值的绝对put方法（可选操作） 。
    将包含给定float值的四个字节（按当前字节顺序）写入给定索引处的此缓冲区。
    
    参数
    
    index - 将写入字节的索引
    
    value - 要写入的浮点值
    
    结果
    
    这个缓冲区
    
    异常
    
    IndexOutOfBoundsException - 如果 index为负数或不小于缓冲区的限制，则减去3
    
    ReadOnlyBufferException - 如果此缓冲区是只读的
  - asFloatBuffer
```
public abstract FloatBuffer asFloatBuffer()
```
    将此字节缓冲区的视图创建为浮点缓冲区。
    新缓冲区的内容将从此缓冲区的当前位置开始。对此缓冲区内容的更改将在新缓冲区中可见，反之亦然; 两个缓冲区的位置，限制和标记值将是独立的。
    
    新缓冲区的位置将为零，其容量和限制将是此缓冲区中剩余的字节数除以4，其标记将是未定义的，并且其字节顺序将是视图时的字节缓冲区的顺序创建。当且仅当此缓冲区是直接缓冲区时，新缓冲区将是直接的，并且当且仅当此缓冲区是只读时，它才是只读的。
    
    结果
    
    一个新的浮动缓冲区
  - getDouble
```
public abstract double getDouble()
```
    读取double值的相对get方法。
    读取此缓冲区当前位置的下八个字节，根据当前字节顺序将它们组成一个double值，然后将位置递增8。
    
    结果
    
    缓冲区当前位置的double值
    
    异常
    
    BufferUnderflowException - 如果此缓冲区中剩余的字节少于8个
  - putDouble
```
public abstract ByteBuffer putDouble(double value)
```
    用于写入double值的相对put方法（可选操作） 。
    将当前字节顺序中包含给定double值的八个字节写入当前位置的此缓冲区，然后将位置递增8。
    
    参数
    
    value - 要写入的double值
    
    结果
    
    这个缓冲区
    
    异常
    
    BufferOverflowException - 如果此缓冲区中剩余的字节少于8个字节
    
    ReadOnlyBufferException - 如果此缓冲区是只读的
  - getDouble
```
public abstract double getDouble(int index)
```
    用于读取double值的绝对get方法。
    读取给定索引处的八个字节，根据当前字节顺序将它们组成一个double值。
    
    参数
    
    index - 将从中读取字节的索引
    
    结果
    
    给定索引处的double值
    
    异常
    
    IndexOutOfBoundsException - 如果 index为负数或不小于缓冲区的限制，则减去7
  - putDouble
```
public abstract ByteBuffer putDouble(int index,                                     double value)
```
    用于写入double值的绝对put方法（可选操作） 。
    将包含给定double值的八个字节（按当前字节顺序）写入给定索引处的此缓冲区。
    
    参数
    
    index - 将写入字节的索引
    
    value - 要写入的double值
    
    结果
    
    这个缓冲区
    
    异常
    
    IndexOutOfBoundsException - 如果 index为负数或不小于缓冲区的限制，则减去7
    
    ReadOnlyBufferException - 如果此缓冲区是只读的
  - asDoubleBuffer
```
public abstract DoubleBuffer asDoubleBuffer()
```
    将此字节缓冲区的视图创建为双缓冲区。
    新缓冲区的内容将从此缓冲区的当前位置开始。对此缓冲区内容的更改将在新缓冲区中可见，反之亦然; 两个缓冲区的位置，限制和标记值将是独立的。
    
    新缓冲区的位置将为零，其容量和限制将是此缓冲区中剩余的字节数除以8，其标记将是未定义的，并且其字节顺序将是视图时的字节缓冲区的顺序创建。当且仅当此缓冲区是直接缓冲区时，新缓冲区将是直接的，并且当且仅当此缓冲区是只读时，它才是只读的。
    
    结果
    
    一个新的双缓冲区

Class ByteBuffer

直接与非直接缓冲

访问二进制数据

调用链接

方法摘要

声明方法的类 java.nio.Buffer

声明方法的类 java.lang.Object

方法详细信息

allocateDirect

allocate

wrap

wrap

slice

duplicate

asReadOnlyBuffer

get

put

get

put

get

get

put

put

put

hasArray

array

arrayOffset

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

putDouble

asDoubleBuffer