Module java.base
Package java.nio

Class ShortBuffer

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

该类定义了对短缓冲区的四类操作：

  • 绝对和相对get和put方法，用于读取和写入单个short；

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

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

  • 用于压缩短缓冲区的方法。

短缓冲区可以通过分配、将现有short数组包装到缓冲区中，或者创建现有字节缓冲区的视图来创建。

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

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

可选操作

指定为可选操作的方法在对只读ShortBuffer调用时会抛出ReadOnlyBufferException。如果ShortBuffer不是由可访问的short数组支持的，则方法array和arrayOffset会抛出UnsupportedOperationException。
自:
1.4

  • Method Summary

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

    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 ShortBuffer allocate(int capacity)
      分配一个新的短缓冲区。

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

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

    • wrap

      public static ShortBuffer wrap(short[] array, int offset, int length)
      将一个short数组包装成缓冲区。

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

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

    • wrap

      public static ShortBuffer wrap(short[] array)
      将一个short数组包装成缓冲区。

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

      参数:
      array - 将支持该缓冲区的数组
      返回:
      新的短缓冲区

    • slice

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

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

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

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

    • slice

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

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

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

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

    • asReadOnlyBuffer

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

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

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

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

      返回值:
      新的只读短缓冲区

    • get

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

    • put

      public abstract ShortBuffer put(short s)
      相对put方法  (可选操作)。

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

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

    • get

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

    • put

      public abstract ShortBuffer put(int index, short s)
      绝对put方法  (可选操作)。

      将给定的短整数写入此缓冲区的给定索引处。

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

    • get

      public ShortBuffer get(short[] dst, int offset, int length)
      相对批量get方法。

      此方法将短整数从此缓冲区传输到给定的目标数组。如果缓冲区中剩余的短整数数量少于请求的数量，则不会传输任何短整数，并抛出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 ShortBuffer get(short[] dst)
      相对批量get方法。

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

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

    • get

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

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

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

      换句话说，形式为 dst.put(src) 的此方法调用与循环

          while (src.hasRemaining())
        dst.put(src.get());
      具有完全相同的效果，只是它首先检查此缓冲区中是否有足够的空间，并且可能更有效。如果此缓冲区和源缓冲区共享相同的支持数组或内存，则结果将是源元素首先被复制到中间位置，然后写入此缓冲区。
      参数:
      src - 要读取shorts的源缓冲区；不得是此缓冲区
      返回:
      此缓冲区
      抛出:
      BufferOverflowException - 如果此缓冲区中没有足够的空间来容纳源缓冲区中剩余的shorts
      IllegalArgumentException - 如果源缓冲区是此缓冲区
      ReadOnlyBufferException - 如果此缓冲区是只读的

    • put

      public ShortBuffer put(int index, ShortBuffer src, int offset, int length)
      绝对批量 put 方法  (可选操作)。

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

      换句话说，形式为 dst.put(index, src, offset, length) 的此方法调用与循环

          for (int i = offset, j = index; i < offset + length; i++, j++)
        dst.put(j, src.get(i));
      具有完全相同的效果，只是它首先检查所提供参数的一致性，并且可能更有效。如果此缓冲区和源缓冲区共享相同的支持数组或内存，则结果将是源元素首先被复制到中间位置，然后写入此缓冲区。
      参数:
      index - 将写入第一个short的此缓冲区中的索引；必须是非负数且小于 limit()
      src - 要读取shorts的缓冲区
      offset - 要读取的第一个short在源缓冲区中的索引；必须是非负数且小于 src.limit()
      length - 要从给定缓冲区中读取的shorts数量；必须是非负数且不大于 limit() - index 和 src.limit() - offset 中较小的值
      返回:
      此缓冲区
      抛出:
      IndexOutOfBoundsException - 如果 index、offset 和 length 参数的前提条件不成立
      ReadOnlyBufferException - 如果此缓冲区是只读的
      自:
      16

    • put

      public ShortBuffer put(short[] src, int offset, int length)
      相对批量 put 方法  (可选操作)。

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

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

      换句话说，形式为 dst.put(src, off, len) 的此方法调用与循环

          for (int i = off; i < off + len; i++)
        dst.put(src[i]);
      具有完全相同的效果，只是它首先检查此缓冲区中是否有足够的空间，并且可能更有效。
      参数:
      src - 要读取shorts的数组
      offset - 要读取的第一个short在数组中的偏移量；必须是非负数且不大于 src.length
      length - 要从给定数组中读取的shorts数量；必须是非负数且不大于 src.length - offset
      返回:
      此缓冲区
      抛出:
      BufferOverflowException - 如果此缓冲区中没有足够的空间
      IndexOutOfBoundsException - 如果 offset 和 length 参数的前提条件不成立
      ReadOnlyBufferException - 如果此缓冲区是只读的

    • put

      public final ShortBuffer put(short[] src)
      相对批量 put 方法  (可选操作)。

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

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

    • put

      public ShortBuffer put(int index, short[] src, int offset, int length)
      绝对批量 put 方法  (可选操作)。

      此方法从给定数组中的给定偏移量开始，从数组中传输 length 个shorts到此缓冲区中，并在此缓冲区中的给定索引处开始。此缓冲区的位置保持不变。

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

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

    • put

      public ShortBuffer put(int index, short[] src)
      绝对批量 put 方法  (可选操作)。

      此方法从给定源数组中复制shorts到此缓冲区中。此缓冲区的位置保持不变。形式为 dst.put(index, src) 的此方法调用的行为与以下调用完全相同：

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

    • hasArray

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

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

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

    • array

      public final short[] array()
      返回支持此缓冲区的short数组  (可选操作)。

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

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

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

    • arrayOffset

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

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

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

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

    • position

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

    • limit

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

    • mark

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

    • reset

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

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

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

    • clear

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

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

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

      此方法实际上不会擦除缓冲区中的数据，但它的命名方式表明它可能会在那种情况下使用。

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

    • flip

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

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

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

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

    • rewind

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

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

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

    • compact

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

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

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

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

    • isDirect

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

    • toString

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

    • hashCode

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

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

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

      覆盖:
      hashCode 在类 Object
      返回:
      此缓冲区的当前哈希码
      参见:

    • equals

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

      两个短缓冲区仅在以下情况下相等：

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

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

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

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

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

    • compareTo

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

      通过按字典顺序比较两个短缓冲区的剩余元素序列来比较它们，而不考虑每个序列在相应缓冲区内的起始位置。对short元素对进行比较，就好像调用Short.compare(short,short)一样。

      短缓冲区不可与任何其他类型的对象进行比较。

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

    • mismatch

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

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

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

    • order

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

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

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