模块 java.base
包 java.nio

类 LongBuffer

java.lang.Object
java.nio.Buffer
java.nio.LongBuffer
所有已实现的接口：
Comparable<LongBuffer>
public abstract sealed class LongBuffer extends Buffer implements Comparable <LongBuffer >
一个长缓冲区。

此类定义了对长缓冲区的四类操作：

  • 绝对和相对 get 和 put 读写单个 long 的方法；

  • 绝对和相对 bulk get 方法，将连续的 long 序列从该缓冲区传输到数组中；

  • 绝对和相对 bulk put 方法，将连续的 long 序列从长数组或其他一些 long 缓冲区传输到此缓冲区；

  • compacting 长缓冲区的方法。

长缓冲区可以通过 allocation 创建，它为缓冲区的内容分配空间，通过 wrapping 将现有的长数组放入缓冲区，或者通过创建现有字节缓冲区的 看法 来创建。

像字节缓冲区一样，长缓冲区是 直接的或者非直接的 。通过此类的wrap 方法创建的长缓冲区将是非直接的。当且仅当字节缓冲区本身是直接的时，作为字节缓冲区的视图创建的长缓冲区将是直接的。长缓冲区是否直接可以通过调用 isDirect 方法来确定。

此类中没有返回值的方法被指定为返回调用它们的缓冲区。这允许链接方法调用。

自从：
1.4

  • 方法总结

    修饰符和类型
    方法
    描述
    static LongBuffer
    allocate(int capacity)
    分配一个新的长缓冲区。
    final long[]
    array()
    返回支持此缓冲区的长数组（可选操作）.
    final int
    arrayOffset()
    返回缓冲区第一个元素在此缓冲区的后备数组中的偏移量（可选操作）.
    abstract LongBuffer
    asReadOnlyBuffer()
    创建一个共享此缓冲区内容的新的只读长缓冲区。
    final LongBuffer
    clear()
    清除此缓冲区。
    abstract LongBuffer
    compact()
    压缩此缓冲区（可选操作）.
    int
    compareTo(LongBuffer that)
    将此缓冲区与另一个缓冲区进行比较。
    abstract LongBuffer
    duplicate()
    创建一个共享此缓冲区内容的新长缓冲区。
    boolean
    equals(Object ob)
    告知此缓冲区是否等于另一个对象。
    final LongBuffer
    flip()
    翻转此缓冲区。
    abstract long
    get()
    相对的get方法。
    abstract long
    get(int index)
    绝对get方法。
    LongBuffer
    get(int index, long[] dst)
    绝对散装get方法。
    LongBuffer
    get(int index, long[] dst, int offset, int length)
    绝对散装get方法。
    LongBuffer
    get(long[] dst)
    相对体积get方法。
    LongBuffer
    get(long[] dst, int offset, int length)
    相对体积get方法。
    final boolean
    hasArray()
    告知此缓冲区是否由可访问的长数组支持。
    int
    hashCode()
    返回此缓冲区的当前哈希码。
    abstract boolean
    isDirect()
    告诉这个长缓冲区是否是直接的。
    final LongBuffer
    limit(int newLimit)
    设置此缓冲区的限制。
    final LongBuffer
    mark()
    在其位置设置此缓冲区的标记。
    int
    mismatch(LongBuffer that)
    查找并返回此缓冲区与给定缓冲区之间第一个不匹配的相对索引。
    abstract ByteOrder
    order()
    检索此缓冲区的字节顺序。
    final LongBuffer
    position(int newPosition)
    设置此缓冲区的位置。
    abstract LongBuffer
    put(int index, long l)
    绝对put方法（可选操作）.
    LongBuffer
    put(int index, long[] src)
    绝对散装put方法（可选操作）.
    LongBuffer
    put(int index, long[] src, int offset, int length)
    绝对散装put方法（可选操作）.
    LongBuffer
    put(int index, LongBuffer src, int offset, int length)
    绝对散装put方法（可选操作）.
    abstract LongBuffer
    put(long l)
    相对的put方法（可选操作）.
    final LongBuffer
    put(long[] src)
    相对体积put方法（可选操作）.
    LongBuffer
    put(long[] src, int offset, int length)
    相对体积put方法（可选操作）.
    LongBuffer
    put(LongBuffer src)
    相对体积put方法（可选操作）.
    final LongBuffer
    reset()
    将此缓冲区的位置重置为先前标记的位置。
    final LongBuffer
    rewind()
    倒带此缓冲区。
    abstract LongBuffer
    slice()
    创建一个新的长缓冲区，其内容是此缓冲区内容的共享子序列。
    abstract LongBuffer
    slice(int index, int length)
    创建一个新的长缓冲区，其内容是此缓冲区内容的共享子序列。
    String
    toString()
    返回总结此缓冲区状态的字符串。
    static LongBuffer
    wrap(long[] array)
    将长数组包装到缓冲区中。
    static LongBuffer
    wrap(long[] array, int offset, int length)
    将长数组包装到缓冲区中。

    在类 java.nio.Buffer 中声明的方法

    capacity, hasRemaining, isReadOnly, limit, position, remaining

    在类 java.lang.Object 中声明的方法

    clone, finalize, getClass, notify, notifyAll, wait, wait, wait

  • 方法详情

    • allocate

      public static LongBuffer  allocate(int capacity)
      分配一个新的长缓冲区。

      新缓冲区的位置将为零，其限制为其容量，其标记为未定义，其每个元素都将初始化为零，其字节顺序将为底层硬件的native order 。它会有一个 backing array ，它的 array offset 将为零。

      参数：
      capacity - 新缓冲区的容量，以 long 为单位
      返回：
      新的长缓冲区
      抛出：
      IllegalArgumentException - 如果 capacity 是负整数

    • wrap

      public static LongBuffer  wrap(long[] array, int offset, int length)
      将长数组包装到缓冲区中。

      新缓冲区将由给定的长数组支持；也就是说，对缓冲区的修改将导致数组被修改，反之亦然。新缓冲区的容量为 array.length，其位置为 offset，其限制为 offset + length，其标记未定义，其字节顺序为底层硬件的 native order 。它的 backing array 将是给定的数组，而它的 array offset 将为零。

      参数：
      array - 将支持新缓冲区的数组
      offset - 要使用的子数组的偏移量；必须为非负且不大于 array.length 。新缓冲区的位置将设置为此值。
      length - 要使用的子数组的长度；必须为非负且不大于 array.length - offset 。新缓冲区的限制将设置为 offset + length 。
      返回：
      新的长缓冲区
      抛出：
      IndexOutOfBoundsException - 如果 offset 和 length 参数的先决条件不成立

    • wrap

      public static LongBuffer  wrap(long[] array)
      将长数组包装到缓冲区中。

      新缓冲区将由给定的长数组支持；也就是说，对缓冲区的修改将导致数组被修改，反之亦然。新缓冲区的容量和限制将为 array.length，其位置将为零，其标记将未定义，其字节顺序将为底层硬件的 native order 。它的 backing array 将是给定的数组，而它的 array offset 将为零。

      参数：
      array - 将支持此缓冲区的数组
      返回：
      新的长缓冲区

    • slice

      public abstract LongBuffer  slice()
      创建一个新的长缓冲区，其内容是此缓冲区内容的共享子序列。

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

      新缓冲区的位置将为零，其容量和限制将为该缓冲区中剩余的 long 数，其标记将未定义，其字节顺序将与该缓冲区的字节顺序相同。当且仅当此缓冲区是直接的时，新缓冲区将是直接的，并且当且仅当此缓冲区是只读的时，它将是只读的。

      指定者：
      slice 在类 Buffer 中
      返回：
      新的长缓冲区

    • slice

      public abstract LongBuffer  slice(int index, int length)
      创建一个新的长缓冲区，其内容是此缓冲区内容的共享子序列。

      新缓冲区的内容将从该缓冲区中的位置 index 开始，并将包含 length 个元素。对此缓冲区内容的更改将在新缓冲区中可见，反之亦然；两个缓冲区的位置、限制和标记值将是独立的。

      新缓冲区的位置将为零，其容量和限制将为 length ，其标记将未定义，其字节顺序将与该缓冲区的字节顺序相同。当且仅当此缓冲区是直接的时，新缓冲区将是直接的，并且当且仅当此缓冲区是只读的时，它将是只读的。

      指定者：
      slice 在类 Buffer 中
      参数：
      index - 该缓冲区中新缓冲区内容开始的位置；必须为非负且不大于 limit()
      length - 新缓冲区将包含的元素数；必须为非负且不大于 limit() - index
      返回：
      新缓冲区
      抛出：
      IndexOutOfBoundsException - 如果 index 为负或大于 limit() ，则 length 为负，或 length > limit() - index
      自从：
      13

    • duplicate

      public abstract LongBuffer  duplicate()
      创建一个共享此缓冲区内容的新长缓冲区。

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

      新缓冲区的容量、限制、位置、标记值和字节顺序将与该缓冲区的相同。当且仅当此缓冲区是直接的时，新缓冲区将是直接的，并且当且仅当此缓冲区是只读的时，它将是只读的。

      指定者：
      duplicate 在类 Buffer 中
      返回：
      新的长缓冲区

    • asReadOnlyBuffer

      public abstract LongBuffer  asReadOnlyBuffer()
      创建一个共享此缓冲区内容的新的只读长缓冲区。

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

      新缓冲区的容量、限制、位置、标记值和字节顺序将与该缓冲区的相同。

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

      返回：
      新的只读长缓冲区

    • get

      public abstract long get()
      相对的get方法。读取此缓冲区当前位置的 long，然后递增该位置。
      返回：
      缓冲区当前位置的多头
      抛出：
      BufferUnderflowException - 如果缓冲区的当前位置不小于其限制

    • put

      public abstract LongBuffer  put(long l)
      相对的put方法（可选操作）.

      将给定的 long 写入此缓冲区的当前位置，然后递增该位置。

      参数：
      l - 待写的长篇
      返回：
      这个缓冲区
      抛出：
      BufferOverflowException - 如果此缓冲区的当前位置不小于其限制
      ReadOnlyBufferException - 如果这个缓冲区是只读的

    • get

      public abstract long get(int index)
      绝对get方法。读取给定索引处的 long。
      参数：
      index - 从中读取 long 的索引
      返回：
      给定指数的多头
      抛出：
      IndexOutOfBoundsException - 如果 index 为负数或不小于缓冲区的限制

    • put

      public abstract LongBuffer  put(int index, long l)
      绝对put方法（可选操作）.

      在给定的索引处将给定的 long 写入此缓冲区。

      参数：
      index - 将写入 long 的索引
      l - 要写入的 long 值
      返回：
      这个缓冲区
      抛出：
      IndexOutOfBoundsException - 如果 index 为负数或不小于缓冲区的限制
      ReadOnlyBufferException - 如果这个缓冲区是只读的

    • get

      public LongBuffer  get(long[] dst, int offset, int length)
      相对体积get方法。

      此方法将 long 从此缓冲区传输到给定的目标数组。如果缓冲区中剩余的 longs 少于满足请求所需的 longs，即如果 length > remaining() ，则不会传输 longs 并抛出 BufferUnderflowException 。

      否则，此方法将 length longs 从该缓冲区复制到给定数组，从该缓冲区的当前位置和数组中的给定偏移量开始。然后这个缓冲区的位置增加 length 。

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

      
   for (int i = off; i < off + len; i++)
     dst[i] = src.get();
      除了它首先检查此缓冲区中是否有足够长的长度并且它可能更有效。
      参数：
      dst - 要写入 long 的数组
      offset - 要写入的第一个 long 数组内的偏移量；必须为非负且不大于 dst.length
      length - 要写入给定数组的 long 的最大数量；必须为非负且不大于 dst.length - offset
      返回：
      这个缓冲区
      抛出：
      BufferUnderflowException - 如果此缓冲区中剩余的 long 少于 length
      IndexOutOfBoundsException - 如果 offset 和 length 参数的先决条件不成立

    • get

      public LongBuffer  get(long[] dst)
      相对体积get方法。

      此方法将 long 从此缓冲区传输到给定的目标数组。调用 src.get(a) 形式的方法的行为与调用完全相同

         src.get(a, 0, a.length)
      参数：
      dst - 目标数组
      返回：
      这个缓冲区
      抛出：
      BufferUnderflowException - 如果此缓冲区中剩余的 long 少于 length

    • get

      public LongBuffer  get(int index, long[] dst, int offset, int length)
      绝对散装get方法。

      此方法将 length longs 从该缓冲区传输到给定数组，从该缓冲区中的给定索引和数组中的给定偏移量开始。这个缓冲区的位置没有改变。

      调用 src.get(index, dst, offset, length) 形式的此方法与以下循环具有完全相同的效果，除了它首先检查提供的参数的一致性并且它可能更有效：

      
   for (int i = offset, j = index; i < offset + length; i++, j++)
     dst[i] = src.get(j);
      参数：
      index - 从中读取第一个 long 的缓冲区中的索引；必须为非负且小于 limit()
      dst - 目标数组
      offset - 要写入的第一个 long 数组内的偏移量；必须为非负且小于 dst.length
      length - 要写入给定数组的 long 数；必须为非负且不大于 limit() - index 和 dst.length - offset 中的较小者
      返回：
      这个缓冲区
      抛出：
      IndexOutOfBoundsException - 如果 index、offset 和 length 参数的先决条件不成立
      自从：
      13

    • get

      public LongBuffer  get(int index, long[] dst)
      绝对散装get方法。

      此方法将 long 从此缓冲区传输到给定的目标数组。这个缓冲区的位置没有改变。调用 src.get(index, dst) 形式的方法的行为与调用完全相同：

         src.get(index, dst, 0, dst.length)
      参数：
      index - 从中读取第一个 long 的缓冲区中的索引；必须为非负且小于 limit()
      dst - 目标数组
      返回：
      这个缓冲区
      抛出：
      IndexOutOfBoundsException - 如果 index 为负，不小于 limit() 或 limit() - index < dst.length
      自从：
      13

    • put

      public LongBuffer  put(LongBuffer  src)
      相对体积put方法（可选操作）.

      此方法将给定源缓冲区中剩余的 long 传输到此缓冲区中。如果源缓冲区中剩余的 longs 多于此缓冲区中的 longs，即如果 src.remaining() > remaining() ，则不会传输 longs 并抛出 BufferOverflowException 。

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

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

         while (src.hasRemaining())
     dst.put(src.get());
      除了它首先检查此缓冲区中是否有足够的空间并且它可能更有效。如果此缓冲区和源缓冲区共享相同的后备数组或内存，则结果将好像源元素在写入此缓冲区之前首先复制到中间位置。
      参数：
      src - 要从中读取 long 的源缓冲区；不能是这个缓冲区
      返回：
      这个缓冲区
      抛出：
      BufferOverflowException - 如果此缓冲区中的空间不足以容纳源缓冲区中的剩余 long
      IllegalArgumentException - 如果源缓冲区是这个缓冲区
      ReadOnlyBufferException - 如果这个缓冲区是只读的

    • put

      public LongBuffer  put(int index, LongBuffer  src, int offset, int length)
      绝对散装put方法（可选操作）.

      此方法将 length long 从给定的源缓冲区传输到此缓冲区，从源缓冲区中的给定 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 - 该缓冲区中第一个 long 将被写入的索引；必须为非负且小于 limit()
      src - 要从中读取 long 的缓冲区
      offset - 要读取的第一个 long 的源缓冲区内的索引；必须为非负且小于 src.limit()
      length - 要从给定缓冲区读取的 long 数；必须为非负且不大于 limit() - index 和 src.limit() - offset 中的较小者
      返回：
      这个缓冲区
      抛出：
      IndexOutOfBoundsException - 如果 index、offset 和 length 参数的先决条件不成立
      ReadOnlyBufferException - 如果这个缓冲区是只读的
      自从：
      16

    • put

      public LongBuffer  put(long[] src, int offset, int length)
      相对体积put方法（可选操作）.

      此方法将 longs 从给定的源数组传输到此缓冲区。如果要从数组中复制的 longs 多于保留在此缓冲区中的 longs，即如果 length > remaining() ，则不会传输 longs 并抛出 BufferOverflowException 。

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

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

      
   for (int i = off; i < off + len; i++)
     dst.put(src[i]);
      除了它首先检查此缓冲区中是否有足够的空间并且它可能更有效。
      参数：
      src - 要从中读取 long 的数组
      offset - 要读取的第一个 long 数组内的偏移量；必须为非负且不大于 src.length
      length - 要从给定数组中读取的 long 数；必须为非负且不大于 src.length - offset
      返回：
      这个缓冲区
      抛出：
      BufferOverflowException - 如果缓冲区空间不足
      IndexOutOfBoundsException - 如果 offset 和 length 参数的先决条件不成立
      ReadOnlyBufferException - 如果这个缓冲区是只读的

    • put

      public final LongBuffer  put(long[] src)
      相对体积put方法（可选操作）.

      此方法将给定源长数组的全部内容传输到此缓冲区中。调用 dst.put(a) 形式的方法的行为与调用完全相同

         dst.put(a, 0, a.length)
      参数：
      src - 源数组
      返回：
      这个缓冲区
      抛出：
      BufferOverflowException - 如果缓冲区空间不足
      ReadOnlyBufferException - 如果这个缓冲区是只读的

    • put

      public LongBuffer  put(int index, long[] src, int offset, int length)
      绝对散装put方法（可选操作）.

      此方法从给定数组传输 length long，从数组中的给定偏移量开始，并在此缓冲区中的给定索引处。这个缓冲区的位置没有改变。

      调用 dst.put(index, src, offset, length) 形式的此方法与以下循环具有完全相同的效果，除了它首先检查提供的参数的一致性并且它可能更有效：

      
   for (int i = offset, j = index; i < offset + length; i++, j++)
     dst.put(j, src[i]);
      参数：
      index - 该缓冲区中第一个 long 将被写入的索引；必须为非负且小于 limit()
      src - 要从中读取 long 的数组
      offset - 要读取的第一个 long 数组内的偏移量；必须为非负且小于 src.length
      length - 要从给定数组中读取的 long 数；必须为非负且不大于 limit() - index 和 src.length - offset 中的较小者
      返回：
      这个缓冲区
      抛出：
      IndexOutOfBoundsException - 如果 index、offset 和 length 参数的先决条件不成立
      ReadOnlyBufferException - 如果这个缓冲区是只读的
      自从：
      13

    • put

      public LongBuffer  put(int index, long[] src)
      绝对散装put方法（可选操作）.

      此方法将 long 从给定的源数组复制到此缓冲区中。这个缓冲区的位置没有改变。对 dst.put(index, src) 形式的方法的调用与调用的行为完全相同：

         dst.put(index, src, 0, src.length);
      参数：
      index - 该缓冲区中第一个 long 将被写入的索引；必须为非负且小于 limit()
      src - 要从中读取 long 的数组
      返回：
      这个缓冲区
      抛出：
      IndexOutOfBoundsException - 如果 index 为负，不小于 limit() 或 limit() - index < src.length
      ReadOnlyBufferException - 如果这个缓冲区是只读的
      自从：
      13

    • hasArray

      public final boolean hasArray()
      告知此缓冲区是否由可访问的长数组支持。

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

      指定者：
      hasArray 在类 Buffer 中
      返回：
      true 当且仅当此缓冲区由数组支持并且不是只读的

    • array

      public final long[] array()
      返回支持此缓冲区的长数组（可选操作）.

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

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

      指定者：
      array 在类 Buffer 中
      返回：
      支持此缓冲区的数组
      抛出：
      ReadOnlyBufferException - 如果此缓冲区由数组支持但为只读
      UnsupportedOperationException - 如果此缓冲区不受可访问数组的支持

    • arrayOffset

      public final int arrayOffset()
      返回缓冲区第一个元素在此缓冲区的后备数组中的偏移量（可选操作）.

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

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

      指定者：
      arrayOffset 在类 Buffer 中
      返回：
      缓冲区第一个元素在此缓冲区数组中的偏移量
      抛出：
      ReadOnlyBufferException - 如果此缓冲区由数组支持但为只读
      UnsupportedOperationException - 如果此缓冲区不受可访问数组的支持

    • position

      public final LongBuffer  position(int newPosition)
      设置此缓冲区的位置。如果标记已定义且大于新位置，则将其丢弃。
      重写：
      position 在类 Buffer 中
      参数：
      newPosition - 新的位置值；必须为非负且不大于电流限制
      返回：
      这个缓冲区

    • limit

      public final LongBuffer  limit(int newLimit)
      设置此缓冲区的限制。如果位置大于新限制，则将其设置为新限制。如果标记已定义且大于新限制，则将其丢弃。
      重写：
      limit 在类 Buffer 中
      参数：
      newLimit - 新的极限值；必须为非负且不大于此缓冲区的容量
      返回：
      这个缓冲区

    • mark

      public final LongBuffer  mark()
      在其位置设置此缓冲区的标记。
      重写：
      mark 在类 Buffer 中
      返回：
      这个缓冲区

    • reset

      public final LongBuffer  reset()
      将此缓冲区的位置重置为先前标记的位置。

      调用此方法既不会更改也不会丢弃标记的值。

      重写：
      reset 在类 Buffer 中
      返回：
      这个缓冲区

    • clear

      public final LongBuffer  clear()
      清除此缓冲区。位置设置为零，限制设置为容量，标记被丢弃。

      在使用一系列通道读取或之前调用此方法put填充此缓冲区的操作。例如：

       buf.clear();   // Prepare buffer for reading
 in.read(buf);  // Read data

      这种方法实际上并没有擦除缓冲区中的数据，但它的命名就好像它确实擦除一样，因为它最常用于可能是这种情况的情况。

      重写：
      clear 在类 Buffer 中
      返回：
      这个缓冲区

    • flip

      public final LongBuffer  flip()
      翻转此缓冲区。限制设置为当前位置，然后位置设置为零。如果标记已定义，则将其丢弃。

      经过一系列通道读取或put操作，调用此方法来准备一系列通道写入或相关get操作。例如：

       buf.put(magic);  // Prepend header
 in.read(buf);   // Read data into rest of buffer
 buf.flip();    // Flip buffer
 out.write(buf);  // Write header + data to channel

      在将数据从一个地方传输到另一个地方时，该方法通常与compact 方法结合使用。

      重写：
      flip 在类 Buffer 中
      返回：
      这个缓冲区

    • rewind

      public final LongBuffer  rewind()
      倒带此缓冲区。位置设置为零，标记被丢弃。

      在一系列通道写入或之前调用此方法get操作，假设已经适当地设置了限制。例如：

       out.write(buf);  // Write remaining data
 buf.rewind();   // Rewind buffer
 buf.get(array);  // Copy data into array
      重写：
      rewind 在类 Buffer 中
      返回：
      这个缓冲区

    • compact

      public abstract LongBuffer  compact()
      压缩此缓冲区（可选操作）.

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

      缓冲区的位置设置为复制的 long 数，而不是零，因此调用此方法后可以立即调用另一个相关方法put方法。

      返回：
      这个缓冲区
      抛出：
      ReadOnlyBufferException - 如果这个缓冲区是只读的

    • isDirect

      public abstract boolean isDirect()
      告诉这个长缓冲区是否是直接的。
      指定者：
      isDirect 在类 Buffer 中
      返回：
      true 当且仅当此缓冲区是直接的

    • toString

      public String  toString()
      返回总结此缓冲区状态的字符串。
      重写：
      toString 在类 Object 中
      返回：
      摘要字符串

    • hashCode

      public int hashCode()
      返回此缓冲区的当前哈希码。

      长缓冲区的哈希码仅取决于其剩余元素；也就是说，基于从 position() 到并包括 limit() - 1 处的元素的元素。

      因为缓冲区哈希码依赖于内容，所以不建议使用缓冲区作为hash map或类似数据结构中的键，除非知道它们的内容不会改变。

      重写：
      hashCode 在类 Object 中
      返回：
      此缓冲区的当前哈希码
      参见：

    • equals

      public boolean equals(Object  ob)
      告知此缓冲区是否等于另一个对象。

      两个长缓冲区相等当且仅当

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

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

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

      长缓冲区不等于任何其他类型的对象。

      重写：
      equals 在类 Object 中
      参数：
      ob - 此缓冲区要与之比较的对象
      返回：
      true 当且仅当此缓冲区等于给定对象
      参见：

    • compareTo

      public int compareTo(LongBuffer  that)
      将此缓冲区与另一个缓冲区进行比较。

      通过按字典顺序比较剩余元素的序列来比较两个长缓冲区，而不考虑每个序列在其相应缓冲区中的起始位置。成对的 long 元素就像调用 Long.compare(long,long) 一样进行比较。

      长缓冲区无法与任何其他类型的对象相提并论。

      指定者：
      compareTo 在接口 Comparable<LongBuffer> 中
      参数：
      that - 要比较的对象。
      返回：
      负整数、零或正整数，因为此缓冲区小于、等于或大于给定缓冲区

    • mismatch

      public int mismatch(LongBuffer  that)
      查找并返回此缓冲区与给定缓冲区之间第一个不匹配的相对索引。该索引与每个缓冲区的 position 相关，并且将在 0（含）到每个缓冲区中的 remaining 元素（不包括）中较小的范围内。

      如果两个缓冲区共享一个公共前缀，则返回的索引是公共前缀的长度，因此两个缓冲区在各自缓冲区内的该索引处存在不匹配。如果一个缓冲区是另一个缓冲区的适当前缀，则返回的索引是每个缓冲区中剩余元素中较小的一个，因此该索引仅对剩余元素数量较多的缓冲区有效。否则，不存在不匹配。

      参数：
      that - 要测试与此缓冲区不匹配的字节缓冲区
      返回：
      此缓冲区与给定缓冲区之间第一个不匹配的相对索引，否则如果不匹配则为 -1。
      自从：
      11

    • order

      public abstract ByteOrder  order()
      检索此缓冲区的字节顺序。

      通过分配或包装现有 long 数组创建的长缓冲区的字节顺序是底层硬件的 native order 。创建为字节缓冲区的 看法 的长缓冲区的字节顺序是创建视图时字节缓冲区的字节顺序。

      返回：
      此缓冲区的字节顺序