模块  java.base
软件包  java.nio

Class LongBuffer

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

    public abstract class LongBufferextends Bufferimplements Comparable<LongBuffer>
    一个长缓冲区。

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

    • 绝对和相对getput读取和写入单个longs的方法;

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

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

    • 一种用于compacting长缓冲区的方法。

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

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

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

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

      • allocate

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

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

        参数
        capacity - 新缓冲区的容量,以longs为单位
        结果
        新的长缓冲区
        异常
        IllegalArgumentException - 如果 capacity是负整数
      • wrap

        public static LongBuffer wrap​(long[] 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 - 如果 offsetlength参数的前提条件不成立
      • wrap

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

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

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

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

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

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

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

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

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

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

        Specified by:
        duplicateBuffer
        结果
        新的长缓冲区
      • asReadOnlyBuffer

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

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

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

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

        结果
        新的只读长缓冲区
      • get

        public abstract long get()
        相对get方法。 读取此缓冲区当前位置的长整数,然后递增位置。
        结果
        缓冲区当前位置的长度
        异常
        BufferUnderflowException - 如果缓冲区的当前位置不小于其限制
      • put

        public abstract LongBuffer put​(long l)
        相对put方法(可选操作)

        将给定的long写入当前位置的缓冲区,然后递增位置。

        参数
        l - l的长篇
        结果
        这个缓冲区
        异常
        BufferOverflowException - 如果此缓冲区的当前位置不小于其限制
        ReadOnlyBufferException - 如果此缓冲区是只读的
      • get

        public abstract long get​(int index)
        绝对获取方法。 读取给定索引处的长整数。
        参数
        index - 将从中读取long的索引
        结果
        给定指数的长期
        异常
        IndexOutOfBoundsException - 如果 index为负数或不小于缓冲区的限制
      • put

        public abstract LongBuffer put​(int index,                               long l)
        绝对(可选操作)

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

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

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

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

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

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

           for (int i = off; i < off + len; i++) dst[i] = src.get();  
        除了它首先检查此缓冲区中是否有足够的长度并且它可能更有效。
        参数
        dst - 要写入long的数组
        offset - 要写入的第一个long的数组内的偏移量; 必须是非负数且不大于dst.length
        length - 要写入给定数组的最大long数; 必须是非负数且不大于dst.length - offset
        结果
        这个缓冲区
        异常
        BufferUnderflowException - 如果此缓冲区中剩余的长度少于 length
        IndexOutOfBoundsException - 如果 offsetlength参数的前提条件不成立
      • get

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

        长缓冲区的哈希码仅取决于其剩余的元素; 也就是说,来自position()的元素,包括元素limit() - 1

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

        结果
        This buffer's byte order