模块  java.base
软件包  java.nio

Class IntBuffer

  • 实现的所有接口
    Comparable<IntBuffer>

    public abstract class IntBufferextends Bufferimplements Comparable<IntBuffer>
    一个int缓冲区。

    此类在int缓冲区上定义了四类操作:

    • 绝对和相对getput读写单个int的方法;

    • 相对bulk get方法,将连续的int序列从此缓冲区转移到数组中;

    • 相对bulk put方法将int的连续序列从int数组或其他一些int缓冲区转移到此缓冲区中;

    • compacting int缓冲区的方法。

    Int缓冲区可以由allocation创建,它为缓冲区的内容分配空间, wrapping将现有的int数组分配到缓冲区,或者通过创建现有字节缓冲区的view

    像字节缓冲区一样,int缓冲区是direct or non-direct 通过wrap方法创建的int缓冲区将是非直接的。 当且仅当字节缓冲区本身是直接的时,作为字节缓冲区视图创建的int缓冲区将是直接的。 可以通过调用isDirect方法来确定int缓冲区是否是直接的。

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

    从以下版本开始:
    1.4
    • 方法详细信息

      • allocate

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

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

        参数
        capacity - 新缓冲区的容量,以整数形式表示
        结果
        新的int缓冲区
        异常
        IllegalArgumentException - 如果 capacity是负整数
      • wrap

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

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

        参数
        array - 将支持新缓冲区的数组
        offset - 要使用的子阵列的偏移量; 必须是非负数且不大于array.length 新缓冲区的位置将设置为此值。
        length - 要使用的子阵列的长度; 必须是非负数且不大于array.length - offset 新缓冲区的限制将设置为offset + length
        结果
        新的int缓冲区
        异常
        IndexOutOfBoundsException - 如果 offsetlength参数的前提条件不成立
      • wrap

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

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

        参数
        array - 将支持此缓冲区的数组
        结果
        新的int缓冲区
      • slice

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

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

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

        Specified by:
        sliceBuffer
        结果
        新的int缓冲区
      • duplicate

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

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

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

        Specified by:
        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)
        绝对获取方法。 读取给定索引处的int。
        参数
        index - 将从中读取int的索引
        结果
        给定索引处的int
        异常
        IndexOutOfBoundsException - 如果 index为负数或不小于缓冲区的限制
      • put

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

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

        参数
        index - 将写入int的索引
        i - 要写入的int值
        结果
        这个缓冲区
        异常
        IndexOutOfBoundsException - 如果 index为负数或不小于缓冲区的限制
        ReadOnlyBufferException - 如果此缓冲区是只读的
      • get

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

        此方法将ints从此缓冲区传输到给定的目标数组。 如果缓冲区中剩余的内存数少于满足请求所需的length > ,即length > remaining() ,则不会传输整数并抛出BufferUnderflowException

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

        换句话说,调用src.get(dst, off, len)形式的此方法与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 - 如果此缓冲区中剩余的少于 length整数
        IndexOutOfBoundsException - 如果 offsetlength参数的前提条件不成立
      • get

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

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

          src.get(a, 0, a.length) 
        参数
        dst - 目标阵列
        结果
        这个缓冲区
        异常
        BufferUnderflowException - 如果此缓冲区中剩余的少于 length
      • put

        public IntBuffer put​(IntBuffer src)
        相对批量放置方法(可选操作)

        此方法将剩余在给定源缓冲区中的int转移到此缓冲区中。 如果源缓冲区中剩余的内容多于此缓冲区中的src.remaining() ,即src.remaining() > remaining() ,则不会传输整数并抛出BufferOverflowException

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

        换句话说,调用dst.put(src)形式的此方法与dst.put(src)具有完全相同的效果

          while (src.hasRemaining())         dst.put(src.get()); 
        除了它首先检查此缓冲区中是否有足够的空间,它可能更有效。
        参数
        src - 要读取整数的源缓冲区; 一定不能是这个缓冲区
        结果
        这个缓冲区
        异常
        BufferOverflowException - 如果此缓冲区中没有足够的空间用于源缓冲区中的剩余int
        IllegalArgumentException - 如果源缓冲区是此缓冲区
        ReadOnlyBufferException - 如果此缓冲区是只读的
      • put

        public IntBuffer put​(int[] src,                     int offset,                     int length)
        相对批量放置方法(可选操作)

        此方法将ints从给定的源数组传输到此缓冲区。 如果要从数组中复制的内容多于保留在此缓冲区中的内容,即length > remaining() ,则不会传输整数并抛出BufferOverflowException

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

        换句话说,调用dst.put(src, off, len)形式的此方法与dst.put(src, off, len)具有完全相同的效果

           for (int i = off; i < off + len; i++) dst.put(a[i]);  
        除了它首先检查此缓冲区中是否有足够的空间,它可能更有效。
        参数
        src - 要读取整数的数组
        offset - 要读取的第一个int的数组内的偏移量; 必须是非负数且不大于array.length
        length - 从给定数组中读取的整数数; 必须是非负数且不大于array.length - offset
        结果
        这个缓冲区
        异常
        BufferOverflowException - 如果此缓冲区中没有足够的空间
        IndexOutOfBoundsException - 如果 offsetlength参数的前置条件不成立
        ReadOnlyBufferException - 如果此缓冲区是只读的
      • put

        public final IntBuffer put​(int[] src)
        相对批量放置方法(可选操作)

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

          dst.put(a, 0, a.length) 
        参数
        src - 源数组
        结果
        这个缓冲区
        异常
        BufferOverflowException - 如果此缓冲区中没有足够的空间
        ReadOnlyBufferException - 如果此缓冲区是只读的
      • hasArray

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

        如果此方法返回true则可以安全地调用arrayarrayOffset方法。

        Specified by:
        hasArray在类 Buffer
        结果
        true当且仅当此缓冲区由数组支持且不是只读时
      • array

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

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

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

        Specified by:
        arrayBuffer
        结果
        支持此缓冲区的数组
        异常
        ReadOnlyBufferException - 如果此缓冲区由数组支持但是只读
        UnsupportedOperationException - 如果此缓冲区未由可访问的阵列支持
      • arrayOffset

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

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

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

        Specified by:
        arrayOffsetBuffer
        结果
        缓冲区第一个元素的缓冲区数组中的偏移量
        异常
        ReadOnlyBufferException - 如果此缓冲区由数组支持但是只读
        UnsupportedOperationException - 如果此缓冲区未由可访问的阵列支持
      • compact

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

        缓冲区当前位置与其限制之间的整数(如果有)将复制到缓冲区的开头。 也就是说,索引p = position()处的int被复制到索引0,索引p + 1处的int被复制到索引1,依此类推,直到索引limit()处的int被复制到索引n = limit() - 1 - p 然后将缓冲区的位置设置为n + 1,并将其限制设置为其容量。 标记(如果已定义)将被丢弃。

        缓冲区的位置设置为复制的int数,而不是零,因此可以通过调用另一个相对put方法立即调用此方法。

        结果
        这个缓冲区
        异常
        ReadOnlyBufferException - 如果此缓冲区是只读的
      • isDirect

        public abstract boolean isDirect()
        判断此int缓冲区是否是直接的。
        Specified by:
        isDirectBuffer
        结果
        true是否且仅当此缓冲区是直接的
      • toString

        public String toString()
        返回总结此缓冲区状态的字符串。
        重写:
        toString在类 Object
        结果
        摘要字符串
      • hashCode

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

        int缓冲区的哈希码仅取决于其剩余的元素; 即,当从元件position()直到并包括,在元件limit() - 1

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

        重写:
        hashCode在类 Object
        结果
        此缓冲区的当前哈希码
        另请参见:
        Object.equals(java.lang.Object)System.identityHashCode(java.lang.Object)
      • equals

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

        两个int缓冲区是相等的,当且仅当,

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

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

        3. 与其起始位置无关地考虑的两个剩余元素序列是逐点相等的。

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

        重写:
        equalsObject
        参数
        ob - 要与此缓冲区进行比较的对象
        结果
        true当且仅当此缓冲区等于给定对象时
        另请参见:
        Object.hashCode()HashMap
      • compareTo

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

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

        int缓冲区与任何其他类型的对象都不具有可比性。

        Specified by:
        compareToComparable<IntBuffer>
        参数
        that - 要比较的对象。
        结果
        此缓冲区小于,等于或大于给定缓冲区的负整数,零或正整数
      • mismatch

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

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

        参数
        that - 要测试与此缓冲区不匹配的字节缓冲区
        结果
        此与给定缓冲区之间的第一个不匹配的相对索引,否则为-1,如果没有不匹配。
        从以下版本开始:
        11
      • order

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

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

        结果
        This buffer's byte order