模块  java.base
软件包  java.nio

Class DoubleBuffer

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

    public abstract class DoubleBuffer
    extends Buffer
    implements Comparable<DoubleBuffer>
    双缓冲。

    该类在双缓冲区上定义了四类操作:

    • 绝对和相对getput方法读写单个双精度;

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

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

    • compacting双缓冲区的方法。

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

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

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

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

      • allocate

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

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

        参数
        capacity - 新缓冲区的容量,以双精度计
        结果
        新的双缓冲区
        异常
        IllegalArgumentException - 如果 capacity是负整数
      • wrap

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

        新缓冲区将由给定的double数组支持; 也就是说,对缓冲区的修改将导致数组被修改,反之亦然。 新缓冲区的容量将为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 DoubleBuffer wrap​(double[] array)
        将双数组包装到缓冲区中。

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

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

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

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

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

        Specified by:
        slice在类 Buffer
        结果
        新的双缓冲区
      • duplicate

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

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

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

        Specified by:
        duplicate在类 Buffer
        结果
        新的双缓冲区
      • asReadOnlyBuffer

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

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

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

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

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

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

        public abstract DoubleBuffer put​(double d)
        相对put方法(可选操作)

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

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

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

        public abstract DoubleBuffer put​(int index,
                                         double d)
        绝对(可选操作)

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

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

        public DoubleBuffer get​(double[] 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 - 要写入的第一个double的数组中的偏移量; 必须是非负数且不大于dst.length
        length - 要写入给定数组的最大双精度数; 必须是非负数且不大于dst.length - offset
        结果
        这个缓冲区
        异常
        BufferUnderflowException - 如果此缓冲区中剩余的双打少于 length
        IndexOutOfBoundsException - 如果 offsetlength参数的前提条件不成立
      • get

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

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

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

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

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

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

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

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

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

        此方法将双精度从给定的源数组传输到此缓冲区。 如果从阵列中复制的双精度数多于保留在此缓冲区中的length > remaining() ,即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 - 要读取的第一个double的数组中的偏移量; 必须是非负数且不大于array.length
        length - 从给定数组中读取的双精度数; 必须是非负数且不大于array.length - offset
        结果
        这个缓冲区
        异常
        BufferOverflowException - 如果此缓冲区中没有足够的空间
        IndexOutOfBoundsException - 如果 offsetlength参数的前提条件不成立
        ReadOnlyBufferException - 如果此缓冲区是只读的
      • put

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

        3. 与其起始位置无关地考虑的两个剩余元素序列是逐点相等的。 如果(a == b) || (Double.isNaN(a) && Double.isNaN(b))该方法认为两个双元素ab相等。 -0.0+0.0被认为是相等的,不像Double.equals(Object)

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

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

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

        通过按字典顺序比较它们的剩余元素序列来比较两个双缓冲液,而不考虑每个序列在其相应缓冲液内的起始位置。 通过调用Double.compare(double,double)比较成对的double元素,但-0.00.0被认为是相等的。 此方法认为Double.NaN等于其自身且大于所有其他double值(包括Double.POSITIVE_INFINITY )。

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

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

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

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

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

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

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

        结果
        This buffer's byte order