Module java.base
Package java.nio

Class IntBuffer

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

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

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

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

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

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

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

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

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

可选操作

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

  • Method Summary

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

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

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

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

    • wrap

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

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

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

    • wrap

      public static IntBuffer wrap(int[] array)
      将int数组包装成缓冲区。

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

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

    • slice

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

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

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

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

    • slice

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

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

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

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

    • duplicate

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

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

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

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

    • asReadOnlyBuffer

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

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

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

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

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

    • get

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

    • put

      public abstract IntBuffer put(int i)
      相对put方法  (可选操作)。

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

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

    • get

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

    • put

      public abstract IntBuffer put(int index, int i)
      绝对put方法  (可选操作)。

      将给定的int写入此缓冲区的给定索引。

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

    • get

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

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

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

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

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

    • get

      public IntBuffer get(int[] dst)
      相对批量get方法。

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

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

    • get

      public IntBuffer get(int index, int[] dst, int offset, int length)
      绝对批量get方法。

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

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

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

    • get

      public IntBuffer get(int index, int[] dst)
      绝对批量get方法。

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

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

    • put

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

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

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

    • put

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

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

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

    • hasArray

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

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

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

    • array

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

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

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

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

    • arrayOffset

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

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

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

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

    • position

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

    • limit

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

    • mark

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

    • reset

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

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

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

    • clear

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

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

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

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

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

    • flip

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

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

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

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

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

    • rewind

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

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

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

    • compact

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

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

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

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

    • isDirect

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

    • toString

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

    • hashCode

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

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

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

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

    • equals

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

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

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

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

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

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

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

    • compareTo

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

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

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

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

    • mismatch

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

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

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

    • order

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

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

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