模块 java.base
包 java.nio

类 DoubleBuffer

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

此类定义了双缓冲区上的四类操作：

  • 读写单双打的绝对和相对get 和put 方法；

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

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

  • compacting 双缓冲区的方法。

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

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

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

自从：
1.4

  • 方法详情

    • allocate

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

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

      参数：
      capacity - 新缓冲区的容量，以双精度表示
      返回：
      新的双缓冲区
      抛出：
      IllegalArgumentException - 如果 capacity 是负整数

    • wrap

      public static DoubleBuffer  wrap(double[] 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 DoubleBuffer  wrap(double[] array)
      将双精度数组包装到缓冲区中。

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

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

    • slice

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

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

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

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

    • slice

      public abstract DoubleBuffer  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 DoubleBuffer  duplicate()
      创建一个共享此缓冲区内容的新双缓冲区。

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

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

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

    • asReadOnlyBuffer

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

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

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

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

      返回：
      新的只读双缓冲区

    • get

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

    • put

      public abstract DoubleBuffer  put(double d)
      相对的put方法（可选操作）.

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

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

    • get

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

    • put

      public abstract DoubleBuffer  put(int index, double d)
      绝对put方法（可选操作）.

      将给定的 double 写入此缓冲区中给定索引处。

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

    • get

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

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

      否则，此方法将 length double 从该缓冲区复制到给定数组，从该缓冲区的当前位置开始，并在数组中的给定偏移处开始。然后这个缓冲区的位置增加 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 DoubleBuffer  get(double[] dst)
      相对体积get方法。

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

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

    • get

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

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

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

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

    • get

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

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

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

    • put

      public DoubleBuffer  put(DoubleBuffer  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 DoubleBuffer  put(int index, DoubleBuffer  src, int offset, int length)
      绝对散装put方法（可选操作）.

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

    • put

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

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

      否则，此方法将从给定数组中的 length double 复制到此缓冲区，从数组中的给定偏移量和此缓冲区的当前位置开始。然后这个缓冲区的位置增加 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 DoubleBuffer  put(double[] src)
      相对体积put方法（可选操作）.

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

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

    • put

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

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

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

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

    • put

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

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

         dst.put(index, src, 0, src.length);
      参数：
      index - 该缓冲区中第一个 double 将被写入的索引；必须为非负且小于 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 double[] array()
      返回支持此缓冲区的双精度数组（可选操作）.

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

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

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

    • arrayOffset

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

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

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

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

    • position

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

    • limit

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

    • mark

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

    • reset

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

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

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

    • clear

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

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

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

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

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

    • flip

      public final DoubleBuffer  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 DoubleBuffer  rewind()
      倒带此缓冲区。位置设置为零，标记被丢弃。

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

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

    • compact

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

      缓冲区当前位置与其限制之间的双精度值（如果有）被复制到缓冲区的开头。也就是说， double at indexp= position() 被复制到索引零，索引处的双精度数p1 被复制到索引 1，依此类推，直到索引 limit() - 1 处的双精度被复制到索引nlimit() - 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 处的元素的元素。

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

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

    • equals

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

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

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

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

      3. 独立于它们的起始位置考虑的剩余元素的两个序列逐点相等。如果 (a == b) || (Double.isNaN(a) && Double.isNaN(b)) ，此方法认为两个双精度元素 a 和 b 相等。值 -0.0 和 +0.0 被认为是相等的，不像 Double.equals(Object) 。

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

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

    • compareTo

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

      通过按字典顺序比较剩余元素的序列来比较两个双缓冲区，而不考虑每个序列在其相应缓冲区中的起始位置。成对的 double 元素就像调用 Double.compare(double,double) 一样进行比较，除了 -0.0 和 0.0 被认为是相等的。此方法认为 Double.NaN 等于其自身并大于所有其他 double 值（包括 Double.POSITIVE_INFINITY ）。

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

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

    • mismatch

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

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

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

    • order

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

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

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