Module java.base
Package java.nio

Class FloatBuffer

java.lang.Object
java.nio.Buffer
java.nio.FloatBuffer
所有已实现的接口:
Comparable<FloatBuffer>
public abstract sealed class FloatBuffer extends Buffer implements Comparable<FloatBuffer>
一个浮点数缓冲区。

这个类定义了浮点数缓冲区的四类操作：

  • 绝对和相对的get和put方法，用于读取和写入单个浮点数；

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

  • 绝对和相对的bulk put方法，将连续的浮点数序列从一个浮点数数组或其他浮点数缓冲区传输到该缓冲区中；

  • 一个用于压缩浮点数缓冲区的方法。

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

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

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

可选操作

指定为可选操作的方法在对只读的浮点数缓冲区调用时会抛出ReadOnlyBufferException。方法array和arrayOffset在浮点数缓冲区不由可访问的浮点数数组支持时会抛出UnsupportedOperationException。
自从:
1.4

  • Method Summary

    Modifier and Type
    Method
    Description
    static FloatBuffer
    allocate(int capacity)
    分配一个新的浮点数缓冲区。
    final float[]
    array()
    返回支持该缓冲区的浮点数数组  (可选操作)。
    final int
    arrayOffset()
    返回该缓冲区的支持数组中第一个元素的偏移量  (可选操作)。
    abstract FloatBuffer
    asReadOnlyBuffer()
    创建一个新的只读浮点数缓冲区，共享该缓冲区的内容。
    final FloatBuffer
    clear()
    清除该缓冲区。
    abstract FloatBuffer
    compact()
    压缩该缓冲区  (可选操作)。
    int
    compareTo(FloatBuffer that)
    将该缓冲区与另一个缓冲区进行比较。
    abstract FloatBuffer
    duplicate()
    创建一个新的浮点数缓冲区，共享该缓冲区的内容。
    boolean
    equals(Object ob)
    判断该缓冲区是否等于另一个对象。
    final FloatBuffer
    flip()
    翻转该缓冲区。
    abstract float
    get()
    相对的get方法。
    FloatBuffer
    get(float[] dst)
    相对的批量get方法。
    FloatBuffer
    get(float[] dst, int offset, int length)
    相对的批量get方法。
    abstract float
    get(int index)
    绝对的get方法。
    FloatBuffer
    get(int index, float[] dst)
    绝对的批量get方法。
    FloatBuffer
    get(int index, float[] dst, int offset, int length)
    绝对的批量get方法。
    final boolean
    hasArray()
    判断该缓冲区是否由可访问的浮点数数组支持。
    int
    hashCode()
    返回该缓冲区的当前哈希码。
    abstract boolean
    isDirect()
    判断该浮点数缓冲区是否是直接的。
    final FloatBuffer
    limit(int newLimit)
    设置该缓冲区的限制。
    final FloatBuffer
    mark()
    在位置设置该缓冲区的标记。
    int
    mismatch(FloatBuffer that)
    找到并返回该缓冲区与给定缓冲区之间第一个不匹配的相对索引。
    abstract ByteOrder
    order()
    检索该缓冲区的字节顺序。
    final FloatBuffer
    position(int newPosition)
    设置该缓冲区的位置。
    abstract FloatBuffer
    put(float f)
    相对的put方法  (可选操作)。
    final FloatBuffer
    put(float[] src)
    相对的批量put方法  (可选操作)。
    FloatBuffer
    put(float[] src, int offset, int length)
    相对的批量put方法  (可选操作)。
    abstract FloatBuffer
    put(int index, float f)
    绝对的put方法  (可选操作)。
    FloatBuffer
    put(int index, float[] src)
    绝对的批量put方法  (可选操作)。
    FloatBuffer
    put(int index, float[] src, int offset, int length)
    绝对的批量put方法  (可选操作)。
    FloatBuffer
    put(int index, FloatBuffer src, int offset, int length)
    绝对的批量put方法  (可选操作)。
    FloatBuffer
    put(FloatBuffer src)
    相对的批量put方法  (可选操作)。
    final FloatBuffer
    reset()
    将该缓冲区的位置重置为先前标记的位置。
    final FloatBuffer
    rewind()
    倒带该缓冲区。
    abstract FloatBuffer
    slice()
    创建一个新的浮点数缓冲区，其内容是该缓冲区内容的共享子序列。
    abstract FloatBuffer
    slice(int index, int length)
    创建一个新的浮点数缓冲区，其内容是该缓冲区内容的共享子序列。
    String
    toString()
    返回总结该缓冲区状态的字符串。
    static FloatBuffer
    wrap(float[] array)
    将一个浮点数数组包装成缓冲区。
    static FloatBuffer
    wrap(float[] 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 FloatBuffer allocate(int capacity)
      分配一个新的浮点数缓冲区。

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

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

    • wrap

      public static FloatBuffer wrap(float[] 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 FloatBuffer wrap(float[] array)
      将一个浮点数数组包装成缓冲区。

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

      参数:
      array - 将支持此缓冲区的数组
      返回:
      新的浮点数缓冲区

    • slice

      public abstract FloatBuffer slice()
      创建一个新的浮点数缓冲区，其内容是该缓冲区内容的共享子序列。

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

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

      指定者:
      slice 在类 Buffer中
      返回:
      新的浮点数缓冲区

    • slice

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

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

      新缓冲区的容量、限制、位置、标记值和字节顺序将与此缓冲区相同。如果此缓冲区是直接缓冲区，则新缓冲区也将是直接缓冲区；如果此缓冲区是只读的，则新缓冲区也将是只读的。

      指定者:
      duplicate 在类 Buffer中
      返回值:
      新浮点数缓冲区

    • asReadOnlyBuffer

      public abstract FloatBuffer asReadOnlyBuffer()
      创建一个新的只读浮点数缓冲区，共享此缓冲区的内容。

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

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

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

      返回值:
      新的只读浮点数缓冲区

    • get

      public abstract float get()
      相对get方法。读取此缓冲区当前位置的浮点数，然后增加位置。
      返回值:
      缓冲区当前位置的浮点数
      抛出:
      BufferUnderflowException - 如果缓冲区当前位置不小于其限制

    • put

      public abstract FloatBuffer put(float f)
      相对put方法  (可选操作)。

      将给定的浮点数写入此缓冲区的当前位置，然后增加位置。

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

    • get

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

    • put

      public abstract FloatBuffer put(int index, float f)
      绝对put方法  (可选操作)。

      将给定的浮点数写入此缓冲区的给定索引处。

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

    • get

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

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

          src.get(a, 0, a.length)
      完全相同。
      参数:
      dst - 目标数组
      返回值:
      此缓冲区
      抛出:
      BufferUnderflowException - 如果此缓冲区中剩余的浮点数少于length个

    • get

      public FloatBuffer get(int index, float[] 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 FloatBuffer get(int index, float[] 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 FloatBuffer put(FloatBuffer 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 FloatBuffer put(int index, FloatBuffer src, int offset, int length)
      绝对批量 put 方法  (可选操作)。

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

      换句话说，形如 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 FloatBuffer put(float[] 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 FloatBuffer put(float[] src)
      相对批量 put 方法  (可选操作)。

      此方法将给定源浮点数数组的整个内容传输到此缓冲区。形如 dst.put(a) 的此方法调用的行为与以下调用完全相同

          dst.put(a, 0, a.length)
      参数:
      src - 源数组
      返回:
      此缓冲区
      抛出:
      BufferOverflowException - 如果此缓冲区中没有足够的空间
      ReadOnlyBufferException - 如果此缓冲区是只读的

    • put

      public FloatBuffer put(int index, float[] 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 FloatBuffer put(int index, float[] 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 float[] array()
      返回支持此缓冲区的浮点数数组  (可选操作)。

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

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

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

    • arrayOffset

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

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

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

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

    • position

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

    • limit

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

    • mark

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

    • reset

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

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

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

    • clear

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

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

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

      此方法实际上并不擦除缓冲区中的数据，但它的命名方式表明它可能经常用于可能需要这样做的情况。

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

    • flip

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

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

          buf.put(magic);    // 在头部添加
    in.read(buf);      // 将数据读入缓冲区的其余部分
    buf.flip();        // 翻转缓冲区
    out.write(buf);    // 将头部 + 数据写入通道
      compact 方法一起在将数据从一个地方传输到另一个地方时使用。

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

    • rewind

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

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

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

    • compact

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

      在缓冲区当前位置和限制之间的浮点数（如果有）将被复制到缓冲区的开头。也就是说，索引 p 处的浮点数（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. 两个剩余元素序列，独立于它们的起始位置考虑，逐点相等。此方法认为两个浮点元素 a 和 b 相等，如果 (a == b) || (Float.isNaN(a) && Float.isNaN(b))。值 -0.0 和 +0.0 被视为相等，不同于 Float.equals(Object)。

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

      覆盖:
      equals 在类 Object
      参数:
      ob - 要比较此缓冲区的对象
      返回:
      如果且仅如果此缓冲区等于给定对象，则返回true
      参见:

    • compareTo

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

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

      浮点缓冲区无法与任何其他类型的对象进行比较。

      指定者:
      compareTo 在接口 Comparable<FloatBuffer>
      参数:
      that - 要比较的对象
      返回:
      如果此缓冲区小于、等于或大于给定缓冲区，则返回负整数、零或正整数

    • mismatch

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

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

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

    • order

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

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

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