Module java.base
Package java.nio

Class LongBuffer

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

这个类定义了长整型缓冲区的四类操作：

  • 绝对和相对的get和put方法，用于读取和写入单个长整型；

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

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

  • 用于压缩长整型缓冲区的方法。

长整型缓冲区可以通过分配空间来创建，通过将现有的长整型数组包装成缓冲区，或者通过创建现有字节缓冲区的视图来创建。

与字节缓冲区类似，长整型缓冲区可以是直接或非直接的。通过该类的wrap方法创建的长整型缓冲区将是非直接的。如果长整型缓冲区作为字节缓冲区的视图创建，则只有当字节缓冲区本身是直接的时，长整型缓冲区才会是直接的。可以通过调用isDirect方法来确定长整型缓冲区是否是直接的。

在这个类中，如果方法没有其他返回值，则规定在调用它们的缓冲区上返回缓冲区。这允许方法调用进行链接。

可选操作

指定为可选操作的方法在只读长整型缓冲区上调用时会抛出ReadOnlyBufferException。方法array和arrayOffset如果长整型缓冲区不由可访问的长整型数组支持，则会抛出UnsupportedOperationException（无论长整型缓冲区是否为只读）。
自 JDK 版本:
1.4

  • Method Summary

    Modifier and Type
    Method
    Description
    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)
    将长整型数组包装成缓冲区。

    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

    • allocate

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

      新缓冲区的位置将为零，限制将为容量，标记将未定义，每个元素将初始化为零，并且字节顺序将是底层硬件的本机顺序。它将有一个支持数组，其数组偏移将为零。

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

    • wrap

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

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

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

    • wrap

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

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

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

    • slice

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

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

      新缓冲区的位置将为零，其容量和限制将是该缓冲区中剩余的长整型数目，其标记将未定义，并且字节顺序将与该缓冲区相同。如果该缓冲区是直接的，则新缓冲区也将是直接的，如果该缓冲区是只读的，则新缓冲区也将是只读的。

      指定者:
      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方法。读取此缓冲区当前位置处的长整型，然后增加位置。
      返回值:
      缓冲区当前位置处的长整型
      抛出:
      BufferUnderflowException - 如果缓冲区当前位置不小于其限制

    • put

      public abstract LongBuffer put(long l)
      相对put方法  (可选操作)。

      将给定的长整型写入此缓冲区的当前位置，然后增加位置。

      参数:
      l - 要写入的长整型
      返回值:
      此缓冲区
      抛出:
      BufferOverflowException - 如果此缓冲区的当前位置不小于其限制
      ReadOnlyBufferException - 如果此缓冲区是只读的

    • get

      public abstract long get(int index)
      绝对get方法。读取给定索引处的长整型。
      参数:
      index - 将读取长整型的索引
      返回值:
      给定索引处的长整型
      抛出:
      IndexOutOfBoundsException - 如果index为负或不小于缓冲区的限制

    • put

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

      将给定的长整型写入此缓冲区的给定索引处。

      参数:
      index - 将写入长整型的索引
      l - 要写入的长整型值
      返回值:
      此缓冲区
      抛出:
      IndexOutOfBoundsException - 如果index为负或不小于缓冲区的限制
      ReadOnlyBufferException - 如果此缓冲区是只读的

    • get

      public LongBuffer get(long[] 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 LongBuffer get(long[] dst)
      相对批量get方法。

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

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

    • get

      public LongBuffer get(int index, long[] 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 LongBuffer get(int index, long[] 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 LongBuffer put(LongBuffer src)
      相对批量 put 方法  (可选操作)。

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

      否则，此方法将从给定缓冲区复制 n = src.remaining() 个 long 值到此缓冲区，从每个缓冲区的当前位置开始。然后，两个缓冲区的位置都增加 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 方法  (可选操作)。

      此方法从给定源缓冲区中的给定 offset 和此缓冲区中的给定 index 开始，将 length 个 long 值传输到此缓冲区。两个缓冲区的位置保持不变。

      换句话说，形如 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 方法  (可选操作)。

      此方法从给定源数组中传输 long 值到此缓冲区。如果要从数组中复制的 long 值多于此缓冲区中剩余的 long 值，即如果 length > remaining()，则不会传输任何 long 值，并抛出 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 方法  (可选操作)。

      此方法将给定源 long 数组的全部内容传输到此缓冲区。形如 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 - 将第一个长整型写入此缓冲区的索引；必须是非负的且小于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 long[] array()
      返回支持此缓冲区的长整型数组  (可选操作)。

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

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

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

    • arrayOffset

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

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

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

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

    • position

      public final LongBuffer position(int newPosition)
      设置此缓冲区的位置。如果标记已定义且大于新位置，则将其丢弃。
      覆盖:
      position 在类中 Buffer
      参数:
      newPosition - 新的位置值；必须是非负的且不大于当前限制
      返回:
      此缓冲区
      自从:
      9

    • limit

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

    • mark

      public final LongBuffer mark()
      设置此缓冲区的标记为其位置。
      覆盖:
      mark 在类中 Buffer
      返回:
      此缓冲区
      自从:
      9

    • reset

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

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

      覆盖:
      reset 在类中 Buffer
      返回:
      此缓冲区
      自从:
      9

    • clear

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

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

          buf.clear();     // 准备缓冲区进行读取
    in.read(buf);    // 读取数据

      此方法实际上不会擦除缓冲区中的数据，但命名为这样是因为它通常在可能需要这样做的情况下使用。

      覆盖:
      clear 在类中 Buffer
      返回:
      此缓冲区
      自从:
      9

    • flip

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

      在一系列通道读取或put操作之后，调用此方法以准备进行一系列通道写入或相对get操作。例如：

          buf.put(magic);    // 在头部添加
    in.read(buf);      // 将数据读入缓冲区的其余部分
    buf.flip();        // 翻转缓冲区
    out.write(buf);    // 将头部+数据写入通道

      此方法通常与compact方法一起在将数据从一个地方传输到另一个地方时使用。

      覆盖:
      flip 在类中 Buffer
      返回:
      此缓冲区
      自从:
      9

    • rewind

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

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

          out.write(buf);    // 写入剩余数据
    buf.rewind();      // 倒带缓冲区
    buf.get(array);    // 将数据复制到数组中
      覆盖:
      rewind 在类中 Buffer
      返回:
      此缓冲区
      自从:
      9

    • compact

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

      如果有的话，缓冲区当前位置和限制之间的长整型将被复制到缓冲区的开头。也就是说，索引为p = position()的长整型将被复制到索引零，索引为p + 1的长整型将被复制到索引一，依此类推，直到索引limit() - 1的长整型被复制到索引n = limit() - 1 - p。然后，缓冲区的位置设置为n+1，其限制设置为其容量。如果定义了标记，则将其丢弃。

      缓冲区的位置设置为复制的长整型数目，而不是零，以便可以立即调用另一个相对put方法。

      返回:
      此缓冲区
      抛出:
      ReadOnlyBufferException - 如果此缓冲区是只读的

    • isDirect

      public abstract boolean isDirect()
      告诉此长整型缓冲区是否是直接的。
      指定者:
      isDirect 在类中 Buffer
      返回:
      如果且仅如果此缓冲区是直接的，则为true

    • toString

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

    • hashCode

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

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

      因为缓冲区哈希码是内容相关的，所以不建议将缓冲区用作哈希映射或类似数据结构中的键，除非知道它们的内容不会更改。

      覆盖:
      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（包括）到每个缓冲区中剩余元素的较小值（不包括）的范围内。

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

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

    • order

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

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

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