DoubleBuffer

allocate

DoubleBuffer allocate (int capacity)

分配一个新的双缓冲区。

新的缓冲区的位置将为零，其限制将是其容量，其标记将是未定义的，并且其每个元素将被初始化为零。 它将有一个 backing array ，其 array offset将为零。

array

double[] array ()

返回支持此缓冲区的双数组 （可选操作） 。

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

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

arrayOffset

int arrayOffset ()

返回缓冲区第一个元素 （可选操作）的此缓冲区的后备数组内的偏移量。

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

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

asReadOnlyBuffer

DoubleBuffer asReadOnlyBuffer ()

创建一个共享此缓冲区内容的新的只读双缓冲区。

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

新缓冲区的容量，限制，位置和标记值将与该缓冲区的相同。

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

compact

DoubleBuffer compact ()

压缩此缓冲区 （可选操作） 。

缓冲区当前位置与其限制之间的双打（如果有）被复制到缓冲区的开始位置。 即，在索引p = position()双复制到索引为零，在索引处索引limit()双P + 1被复制到索引1，依此类推，直到双- 1被复制到索引n = limit() - 1 - p 。 然后将缓冲区的位置设置为n + 1，并将其限制设置为其容量。 标记（如果已定义）将被丢弃。

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

compareTo

int compareTo (DoubleBuffer that)

将此缓冲区与另一个进行比较。

通过按照字典顺序比较剩余元素的序列来比较两个双缓冲区，而不考虑每个序列在其相应缓冲区内的开始位置。 对double元素进行比较，就好像通过调用compare(double, double) ，除了-0.0和0.0被认为是相等的。 该方法认为Double.NaN等于自身并且大于所有其他double值（包括Double.POSITIVE_INFINITY ）。

双缓冲区不能与其他类型的对象相比较。

duplicate

DoubleBuffer duplicate ()

创建一个共享此缓冲区内容的新双缓冲区。

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

新缓冲区的容量，限制，位置和标记值将与该缓冲区的相同。 当且仅当此缓冲区是直接的时，新缓冲区才是直接的，并且只有在此缓冲区是只读的情况下，它才会是只读的。

equals

boolean equals (Object ob)

告诉这个缓冲区是否等于另一个对象。

Two double buffers are equal if, and only if,

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

2. 他们有相同数量的剩余元素，并且

3. 独立于其起始位置考虑的剩余元素的两个序列是逐点相等的。 该方法认为两个双元件a和b是如果等于(a == b) || (Double.isNaN(a) && Double.isNaN(b)) 。 值-0.0和+0.0被认为是相等的，不像equals(Object) 。

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

get

double get ()

相对获得方法。 在此缓冲区的当前位置读取double，然后增加位置。

get

DoubleBuffer get (double[] dst, 
                int offset, 
                int length)

相对批量 获取方法。

此方法将双缓冲区从此缓冲区传输到给定的目标数组中。 如果缓冲区中剩余的双重比满足请求所需要的更少，也就是说，如果length > remaining() ，则不会传送双打，并且会抛出BufferUnderflowException 。

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

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

     for (int i = off; i < off + len; i++)
         dst[i] = src.get(); 

get

DoubleBuffer get (double[] dst)

相对批量 获取方法。

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

     src.get(a, 0, a.length) 

get

double get (int index)

绝对get方法。 读取给定索引处的double。

hasArray

boolean hasArray ()

告诉这个缓冲区是否由可访问的双数组支持。

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

hashCode

int hashCode ()

返回此缓冲区的当前哈希码。

双缓冲区的哈希码仅依赖于其余的元素; 也就是说，从position()到limit() - 1的元素并包括该元素。

由于缓冲区散列码与内容相关，因此除非知道其内容不会改变，否则在散列映射或类似数据结构中使用缓冲区作为键是不可取的。

isDirect

boolean isDirect ()

告诉这个双缓冲区是否是直接的。

order

ByteOrder order ()

检索此缓冲区的字节顺序。

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

put

DoubleBuffer put (DoubleBuffer src)

相对批量 放置方法 （可选操作） 。

此方法将剩余在给定源缓冲区中的双精度转移到此缓冲区中。 如果源缓冲区中剩余更多的双重比在此缓冲区中，也就是说，如果src.remaining() > remaining() ，则不会传输双打，并且会抛出BufferOverflowException 。

否则，这种方法从给定缓冲区复制n = src.remaining()双倍数据到这个缓冲区，从每个缓冲区的当前位置开始。 然后两个缓冲器的位置增加n 。

换句话说，调用表单 dst.put(src)的这种方法与 循环具有完全相同的效果

     while (src.hasRemaining())
         dst.put(src.get()); 

put

DoubleBuffer put (double[] src, 
                int offset, 
                int length)

相对批量 放置方法 （可选操作） 。

该方法将来自给定源数组的双精度转移到此缓冲区中。 如果从阵列中复制的双数多于保留在此缓冲区中的数量，也就是说，如果length > remaining() ，那么不会传输双精度数据并引发BufferOverflowException 。

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

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

     for (int i = off; i < off + len; i++)
         dst.put(a[i]); 

put

DoubleBuffer put (double d)

相对 放置方法 （可选操作） 。

Writes the given double into this buffer at the current position, and then increments the position.

put

DoubleBuffer put (double[] src)

相对批量 放置方法 （可选操作） 。

此方法将给定源双数组的全部内容传输到此缓冲区。 表单dst.put(a)的这种方法的调用的行为方式与调用完全相同

     dst.put(a, 0, a.length) 

put

DoubleBuffer put (int index, 
                double d)

绝对 放置方法 （可选操作） 。

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

slice

DoubleBuffer slice ()

创建一个新的双缓冲区，其内容是此缓冲区内容的共享子序列。

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

The new buffer's position will be zero, its capacity and its limit will be the number of doubles remaining in this buffer, and its mark will be undefined. The new buffer will be direct if, and only if, this buffer is direct, and it will be read-only if, and only if, this buffer is read-only.

toString

String toString ()

返回汇总此缓冲区状态的字符串。

wrap

DoubleBuffer wrap (double[] array)

将双数组包装到缓冲区中。

新缓冲区将由给定的双数组支持; 也就是说，修改缓冲区将导致数组被修改，反之亦然。 新缓冲区的容量和限制将为array.length ，其位置将为零，并且其标记将不确定。 其 backing array将是给定的阵列，其 array offset将为零。

wrap

DoubleBuffer wrap (double[] array, 
                int offset, 
                int length)

将双数组包装到缓冲区中。

新缓冲区将由给定的双数组支持; 也就是说，修改缓冲区将导致数组被修改，反之亦然。 新缓冲区容量为array.length ，位置为offset ，限制为offset + length ，其标记为未定义。 它的 backing array将是给定的数组，其 array offset将为零。