Module  java.base
软件包  java.nio

Class ShortBuffer

  • All Implemented Interfaces:
    Comparable<ShortBuffer>


    public abstract class ShortBuffer
    extends Buffer
    implements Comparable<ShortBuffer>
    一个短暂的缓冲。

    此类定义了缓冲区中的四类操作:

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

    • 相对bulk get方法将连续的短片序列从该缓冲区传送到数组中;

    • 相对的bulk put方法,将短阵列的连续序列或一些其他短缓冲区传输到该缓冲区中;

    • 一个compacting一个短缓冲区的方法。

    短缓冲区可以由allocation创建,它为缓冲区的内容分配空间wrapping现有的短阵列到缓冲区中,或通过创建现有字节缓冲区的view

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

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

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

      • allocate

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

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

        参数
        capacity - 新的缓冲区的容量,短裤
        结果
        新的缓冲区
        异常
        IllegalArgumentException - 如果 capacity是负整数
      • wrap

        public static ShortBuffer wrap​(short[] 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 ShortBuffer wrap​(short[] array)
        将一个短阵列包装到缓冲区中。

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

        参数
        array - 将返回此缓冲区的数组
        结果
        新的缓冲区
      • slice

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

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

        新缓冲区的位置将为零,其容量和限制将是此缓冲区中剩余的短路数,其标记将不定义,并且其字节顺序将与此缓冲区的字节顺序相同。 如果只有这个缓冲区是直接的,并且只有当这个缓冲区是只读的时,这个缓冲区将是只读的。

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

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

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

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

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

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

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

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

        如果这个缓冲区本身是只读的,那么这个方法的行为与duplicate方法完全相同。

        结果
        新的只读缓冲区
      • get

        public abstract short get​()
        相对获取方法。 读取该缓冲区当前位置的短路,然后增加位置。
        结果
        缓冲区当前位置的短路
        异常
        BufferUnderflowException - 如果缓冲区的当前位置不小于其限制
      • put

        public abstract ShortBuffer put​(short s)
        相对放置(可选操作)

        将给定的短文写入当前位置的缓冲区,然后增加位置。

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

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

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

        将给定的短文写入给定索引的缓冲区。

        参数
        index - 短信将被写入的指数
        s - s的短价值
        结果
        这个缓冲区
        异常
        IndexOutOfBoundsException - 如果 index为负数或不小于缓冲区限制
        ReadOnlyBufferException - 如果这个缓冲区是只读的
      • get

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

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

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

        换句话说,这种形式为src.get(dst, off, len)方法的调用与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 - 如果 offsetlength参数的前提条件不成立
      • get

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

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

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

        public ShortBuffer put​(ShortBuffer src)
        相对大容量put方法(可选操作)

        此方法将给定源缓冲区中剩余的短路传输到此缓冲区。 如果源缓冲区中存在比在此缓冲区中更多的短路,也就是说,如果src.remaining() > remaining() ,则不传输短路,并抛出BufferOverflowException

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

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

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

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

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

        否则,该方法将length从给定的数组中的短裤复制到此缓冲区中,从阵列中的给定偏移量和此缓冲区的当前位置开始。 然后将该缓冲区的位置增加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 - 要读取的第一个short的数组内的偏移量; 必须是非负数,不得大于array.length
        length - 从给定数组读取的短裤数量; 必须是非负数,不得大于array.length - offset
        结果
        这个缓冲区
        异常
        BufferOverflowException - 如果此缓冲区中没有足够的空间
        IndexOutOfBoundsException - 如果 offsetlength参数的前提条件不成立
        ReadOnlyBufferException - 如果此缓冲区是只读的
      • put

        public final ShortBuffer put​(short[] src)
        相对大容量put方法(可选操作)

        此方法将给定源短数组的整个内容传输到此缓冲区。 这种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 short[] array​()
        返回支持此缓冲区的短数组(可选操作)

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

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

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

        public final int arrayOffset​()
        返回该缓冲区的缓冲区的第一个元素的背衬数组中的偏移量(可选操作)

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

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

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

        public final ShortBuffer position​(int newPosition)
        设置这个缓冲区的位置。 如果标记被定义并且大于新位置,则它被丢弃。
        重写:
        positionBuffer
        参数
        newPosition - 新的位置值; 必须是非负数,不得大于当前限制
        结果
        这个缓冲区
      • limit

        public final ShortBuffer limit​(int newLimit)
        设置此缓冲区的限制。 如果位置大于新的限制,那么它被设置为新的限制。 如果标记被定义并且大于新限制,则它被丢弃。
        重写:
        limitBuffer
        参数
        newLimit - 新限制值 必须是非负数,不大于此缓冲区的容量
        结果
        这个缓冲区
      • mark

        public final ShortBuffer mark​()
        将此缓冲区的标记设置在其位置。
        重写:
        mark中的 Buffer
        结果
        这个缓冲区
      • reset

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

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

        重写:
        resetBuffer
        结果
        这个缓冲区
      • clear

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

        在使用一系列通道读取或放置操作填充此缓冲区之前调用此方法。 例如:

         buf.clear();     // Prepare buffer for reading
         in.read(buf);    // Read data

        该方法实际上并不会清除缓冲区中的数据,而是将其命名为它的确因为它最常用于情况也是如此。

        重写:
        clearBuffer
        结果
        这个缓冲区
      • flip

        public final ShortBuffer flip​()
        翻转这个缓冲区。 该限制设置为当前位置,然后将该位置设置为零。 如果标记被定义,则它被丢弃。

        在通道读取或放置操作的序列之后,调用此方法来准备一系列通道写入或相对获取操作。 例如:

         buf.put(magic);    // Prepend header
         in.read(buf);      // Read data into rest of buffer
         buf.flip();        // Flip buffer
         out.write(buf);    // Write header + data to channel

        当将数据从一个地方传输到另一个地址时,该方法通常与compact方法结合使用。

        重写:
        flipBuffer
        结果
        这个缓冲区
      • rewind

        public final ShortBuffer rewind​()
        倒带这个缓冲区。 位置设置为零,标记被丢弃。

        在通道写入或获取操作的序列之前调用此方法,假设已经设置了相应的限制。 例如:

         out.write(buf);    // Write remaining data
         buf.rewind();      // Rewind buffer
         buf.get(array);    // Copy data into array
        重写:
        rewindBuffer
        结果
        这个缓冲区
      • compact

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

        缓冲区当前位置与其限制(如果有的话)之间的短路将被复制到缓冲区的开头。 即,短于索引p = position()复制到索引零,短于索引p + 1被复制到索引1,依此类推,直到短的索引limit() - 1被复制到索引n = limit() - 1 - p 然后将缓冲区的位置设置为n + 1,并将其限制设置为其容量。 标记如果被定义,则被丢弃。

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

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

        public abstract boolean isDirect​()
        告诉这个短缓冲区是否直接。
        Specified by:
        isDirectBuffer
        结果
        true如果,只有这个缓冲区是直接的
      • toString

        public String toString​()
        返回一个汇总此缓冲区状态的字符串。
        重写:
        toStringObject
        结果
        摘要字符串
      • 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​(ShortBuffer that)
        将此缓冲区与另一个缓冲区进

        通过将词汇的剩余元素的序列进行比较来比较两个短的缓冲区,而不考虑其相应缓冲区内每个序列的起始位置。 short元素进行比较,仿佛通过调用Short.compare(short,short)

        短暂的缓冲区与任何其他类型的对象都不相称。

        Specified by:
        compareTo在接口 Comparable<ShortBuffer>
        参数
        that - 要比较的对象。
        结果
        负整数,零或正整数,因为此缓冲区小于,等于或大于给定的缓冲区
      • order

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

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

        结果
        这个缓冲区的字节顺序