All Implemented Interfaces:

Comparable<DoubleBuffer>
```
public abstract class DoubleBuffer
extends Buffer
implements Comparable<DoubleBuffer>
```
双缓冲。
此类定义了双缓冲区中的四类操作：
- 绝对和相对的get和put读和写双重的方法;
- 相对bulk get方法将连续的双倍序列从此缓冲区传输到数组中; 和
- 相对的bulk put方法，将来自双阵列或其他双缓冲区的连续双精度序列传输到该缓冲区中; 和
- 一种compacting双缓冲区的方法。
双缓冲区可以由allocation创建，它为缓冲区的内容分配空间wrapping现有的双阵列到缓冲区中，或通过创建现有字节缓冲区的view 。

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

指定此类中没有值返回值的方法返回调用它们的缓冲区。这允许方法调用被链接。
从以下版本开始：

1.4

方法摘要

所有方法静态方法接口方法抽象方法具体的方法
Modifier and Type	方法	描述
`static DoubleBuffer`	`allocate(int capacity)`	分配一个新的双缓冲区。
`double[]`	`array()`	返回支持此缓冲区的双数组（可选操作）。
`int`	`arrayOffset()`	返回该缓冲区的缓冲区的第一个元素的背衬数组中的偏移量（可选操作）。
`abstract DoubleBuffer`	`asReadOnlyBuffer()`	创建一个新的只读双缓冲区，共享此缓冲区的内容。
`DoubleBuffer`	`clear()`	清除此缓冲区。
`abstract DoubleBuffer`	`compact()`	压缩此缓冲区（可选操作）。
`int`	`compareTo(DoubleBuffer that)`	将此缓冲区与另一个缓冲区进
`abstract DoubleBuffer`	`duplicate()`	创建一个新的双缓冲区，共享此缓冲区的内容。
`boolean`	`equals(Object ob)`	告诉这个缓冲区是否等于另一个对象。
`DoubleBuffer`	`flip()`	翻转这个缓冲区。
`abstract double`	`get()`	相对获取方法。
`DoubleBuffer`	`get(double[] dst)`	相对批量获取方法。
`DoubleBuffer`	`get(double[] dst, int offset, int length)`	相对批量获取方法。
`abstract double`	`get(int index)`	绝对获取方法。
`boolean`	`hasArray()`	告诉这个缓冲区是否由可访问的双阵列支持。
`int`	`hashCode()`	返回此缓冲区的当前哈希码。
`abstract boolean`	`isDirect()`	告诉这个双缓冲区是否直接。
`DoubleBuffer`	`limit(int newLimit)`	设置此缓冲区的限制。
`DoubleBuffer`	`mark()`	将此缓冲区的标记设置在其位置。
`abstract ByteOrder`	`order()`	检索此缓冲区的字节顺序。
`DoubleBuffer`	`position(int newPosition)`	设置这个缓冲区的位置。
`abstract DoubleBuffer`	`put(double d)`	相对放置法（可选操作）。
`DoubleBuffer`	`put(double[] src)`	相对大容量 put方法（可选操作）。
`DoubleBuffer`	`put(double[] src, int offset, int length)`	相对大容量 put方法（可选操作）。
`abstract DoubleBuffer`	`put(int index, double d)`	绝对 put方法（可选操作）。
`DoubleBuffer`	`put(DoubleBuffer src)`	相对大容量 put方法（可选操作）。
`DoubleBuffer`	`reset()`	将此缓冲区的位置重置为先前标记的位置。
`DoubleBuffer`	`rewind()`	倒带这个缓冲区。
`abstract DoubleBuffer`	`slice()`	创建一个新的双缓冲区，其内容是此缓冲区内容的共享子序列。
`String`	`toString()`	返回一个汇总此缓冲区状态的字符串。
`static DoubleBuffer`	`wrap(double[] array)`	将双阵列包装到缓冲区中。
`static DoubleBuffer`	`wrap(double[] array, int offset, int length)`	将双阵列包装到缓冲区中。

Methods inherited from class java.nio.Buffer
capacity, hasRemaining, isReadOnly, limit, position, remaining

Methods inherited from class java.lang.Object
clone, finalize, getClass, notify, notifyAll, wait, wait, wait

- 方法详细信息
  - 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)
```
    将双阵列包装到缓冲区中。
    新缓冲区将由给定的双数组支持; 也就是说，对缓冲区的修改将导致数组被修改，反之亦然。新的缓冲区容量将为array.length ，其位置将为offset ，其限制将为offset + length ，其标记将不定义，其字节顺序将为底层硬件的native order 。其backing array将是给定的阵列，其array offset将为零。
    
    参数
    
    array - 将返回新缓冲区的数组
    
    offset - 要使用的子阵列的偏移量; 必须是非负数，不得大于array.length 。新缓冲区的位置将被设置为此值。
    
    length - 要使用的子阵列的长度; 必须是非负数，不得大于array.length - offset 。新缓冲区的限制将设置为offset + length 。
    
    结果
    
    新的双缓冲
    
    异常
    
    IndexOutOfBoundsException - 如果 offset和 length参数的前提条件不成立
  - wrap
```
public static DoubleBuffer wrap(double[] array)
```
    将双阵列包装到缓冲区中。
    新缓冲区将由给定的双数组支持; 也就是说，对缓冲区的修改将导致数组被修改，反之亦然。新的缓冲区的容量和限制将为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()
```
    相对获取方法。在此缓冲区的当前位置读取double，然后增加位置。
    
    结果
    
    缓冲区当前位置的双倍
    
    异常
    
    BufferUnderflowException - 如果缓冲区的当前位置不小于其限制
  - put
```
public abstract DoubleBuffer put(double d)
```
    相对放置法（可选操作） 。
    将给定的double写入到当前位置的缓冲区中，然后增加位置。
    
    参数
    
    d - d的双
    
    结果
    
    这个缓冲区
    
    异常
    
    BufferOverflowException - 如果此缓冲区的当前位置不小于其限制
    
    ReadOnlyBufferException - 如果此缓冲区是只读的
  - get
```
public abstract double get(int index)
```
    绝对获取方法。读取给定索引的双倍。
    
    参数
    
    index - 将从中读取双 index的索引
    
    结果
    
    给定指数的双倍
    
    异常
    
    IndexOutOfBoundsException - 如果 index为负值或不小于缓冲区限制
  - put
```
public abstract DoubleBuffer put(int index,
                                 double d)
```
    绝对put方法（可选操作） 。
    将给定的double写入给定索引的缓冲区。
    
    参数
    
    index - 将双面写入的索引
    
    d - 要写入的双重值
    
    结果
    
    这个缓冲区
    
    异常
    
    IndexOutOfBoundsException - 如果 index为负数或不小于缓冲区限制
    
    ReadOnlyBufferException - 如果此缓冲区是只读的
  - get
```
public 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():
    除了它首先检查这个缓冲区中是否有足够的双打，并且它可能更有效率。
    参数
    
    dst - 要写入双精度数组
    
    offset - 要写入的第一个double的数组中的偏移量; 必须是非负数，不得大于dst.length
    
    length - 要写入给定数组的最大双精度数; 必须是非负数，不得大于dst.length - offset
    
    结果
    
    这个缓冲区
    
    异常
    
    BufferUnderflowException - 如果此缓冲区中剩余的数字少于 length双倍
    
    IndexOutOfBoundsException - 如果 offset和 length参数的前提条件不成立
  - get
```
public DoubleBuffer get(double[] dst)
```
    相对批量获取方法。
    此方法将双缓冲区从该缓冲区传输到给定的目标数组。对这种src.get(a)形式的方法的调用与调用的方式完全相同
    
    src.get(a, 0, a.length)
    参数
    
    dst - 目的数组
    
    结果
    
    这个缓冲区
    
    异常
    
    BufferUnderflowException - 如果此缓冲区中剩余的数字少于 length双倍
  - put
```
public DoubleBuffer put(DoubleBuffer src)
```
    相对大容量put方法（可选操作） 。
    该方法将给定源缓冲区中剩余的双精度传输到此缓冲区。如果源缓冲区中剩余的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 - 如果源缓冲区中剩余的双精度缓冲区中没有足够的空间
    
    IllegalArgumentException - 如果源缓冲区是这个缓冲区
    
    ReadOnlyBufferException - 如果这个缓冲区是只读的
  - put
```
public DoubleBuffer put(double[] 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 - 要读取的第一个double数组中的偏移量; 必须是非负数，不得大于array.length
    
    length - 从给定数组读取的双精度数; 必须是非负数，不得大于array.length - offset
    
    结果
    
    这个缓冲区
    
    异常
    
    BufferOverflowException - 如果此缓冲区中没有足够的空间
    
    IndexOutOfBoundsException - 如果 offset和 length参数的前提条件不成立
    
    ReadOnlyBufferException - 如果此缓冲区是只读的
  - put
```
public final DoubleBuffer put(double[] src)
```
    相对大容量put方法（可选操作） 。
    此方法将给定源双数组的整个内容传输到此缓冲区。这种dst.put(a)形式的方法的调用与调用的方式完全相同
    
    dst.put(a, 0, a.length)
    参数
    
    src - 源数组
    
    结果
    
    这个缓冲区
    
    异常
    
    BufferOverflowException - 如果此缓冲区中没有足够的空间
    
    ReadOnlyBufferException - 如果此缓冲区是只读的
  - hasArray
```
public final boolean hasArray()
```
    告诉这个缓冲区是否由可访问的双阵列支持。
    如果此方法返回true则可以安全地调用array和arrayOffset方法。
    
    Specified by:
    
    hasArray在 Buffer
    
    结果
    
    true如果，且仅当此缓冲区由数组支持并且不是只读
  - array
```
public final double[] array()
```
    返回支持此缓冲区的双数组（可选操作） 。
    对此缓冲区内容的修改将导致返回的数组的内容被修改，反之亦然。
    
    在调用此方法之前调用hasArray方法，以确保此缓冲区具有可访问的后台阵列。
    
    Specified by:
    
    array在 Buffer
    
    结果
    
    支持这个缓冲区的数组
    
    异常
    
    ReadOnlyBufferException - 如果此缓冲区由数组支持但是只读
    
    UnsupportedOperationException - 如果此缓冲区不由可访问阵列支持
  - arrayOffset
```
public final int arrayOffset()
```
    返回该缓冲区的缓冲区的第一个元素的背衬数组中的偏移量（可选操作） 。
    如果此缓冲区由数组支持，则缓冲区位置p对应于数组索引p + arrayOffset() 。
    
    在调用此方法之前调用hasArray方法，以确保此缓冲区具有可访问的后备数组。
    
    Specified by:
    
    arrayOffset在 Buffer
    
    结果
    
    缓冲区的第一个元素的缓冲区数组中的偏移量
    
    异常
    
    ReadOnlyBufferException - 如果此缓冲区由数组支持但是只读
    
    UnsupportedOperationException - 如果此缓冲区未由可访问阵列支持
  - position
```
public final DoubleBuffer position(int newPosition)
```
    设置这个缓冲区的位置。如果标记被定义并且大于新位置，则它被丢弃。
    
    重写：
    
    position在 Buffer
    
    参数
    
    newPosition - 新位置值; 必须是非负数，不得大于当前限制
    
    结果
    
    这个缓冲区
  - limit
```
public final DoubleBuffer limit(int newLimit)
```
    设置此缓冲区的限制。如果位置大于新的限制，那么它被设置为新的限制。如果标记被定义并且大于新限制，则它被丢弃。
    
    重写：
    
    limit在类 Buffer
    
    参数
    
    newLimit - 新限制值必须是非负数，不大于此缓冲区的容量
    
    结果
    
    这个缓冲区
  - mark
```
public final DoubleBuffer mark()
```
    将此缓冲区的标记设置在其位置。
    
    重写：
    
    mark在类 Buffer
    
    结果
    
    这个缓冲区
  - reset
```
public final DoubleBuffer reset()
```
    将此缓冲区的位置重置为先前标记的位置。
    调用此方法既不会更改也不丢弃该标记的值。
    
    重写：
    
    reset在类 Buffer
    
    结果
    
    这个缓冲区
  - clear
```
public final DoubleBuffer clear()
```
    清除此缓冲区。位置设置为零，限制设置为容量，标记被丢弃。
    在使用一系列通道读取或放置操作填充此缓冲区之前调用此方法。例如：
    
    buf.clear(); // Prepare buffer for reading in.read(buf); // Read data
    
    该方法实际上并不会清除缓冲区中的数据，而是将其命名为它的确因为它最常用于情况也是如此。
    重写：
    
    clear在 Buffer
    
    结果
    
    这个缓冲区
  - flip
```
public final DoubleBuffer 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方法结合使用。
    重写：
    
    flip在 Buffer
    
    结果
    
    这个缓冲区
  - rewind
```
public final DoubleBuffer rewind()
```
    倒带这个缓冲区。位置设置为零，标记被丢弃。
    在通道写入或获取操作的序列之前调用此方法，假设已经设置了相应的限制。例如：
    
    out.write(buf); // Write remaining data buf.rewind(); // Rewind buffer buf.get(array); // Copy data into array
    重写：
    
    rewind在 Buffer
    
    结果
    
    这个缓冲区
  - compact
```
public abstract DoubleBuffer compact()
```
    压缩此缓冲区（可选操作） 。
    缓冲区的当前位置和其限制（如果有的话）之间的双精度被复制到缓冲区的开头。也就是说，索引p = position()被复制到索引零，索引p + 1处的double被复制到索引1，直到索引号limit()的double被复制到索引n = limit() - 1 - p 。然后将缓冲区的位置设置为n + 1，并将其限制设置为其容量。标记如果被定义，则被丢弃。
    
    缓冲区的位置设置为复制的双精度数，而不是零，因此可以通过调用另一个相对put方法来立即调用此方法。
    
    结果
    
    这个缓冲区
    
    异常
    
    ReadOnlyBufferException - 如果此缓冲区是只读的
  - isDirect
```
public abstract boolean isDirect()
```
    告诉这个双缓冲区是否直接。
    
    Specified by:
    
    isDirect在 Buffer
    
    结果
    
    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)
```
    告诉这个缓冲区是否等于另一个对象。
    两个双缓冲区是相等的，如果，只有如果，
    
    它们具有相同的元素类型，
    
    他们有相同数量的剩余元素，和
    
    独立于其起始位置的剩余元素的两个序列是相等的。该方法认为两个双元件a和b是如果等于(a == b) || (Double.isNaN(a) && Double.isNaN(b)) 。值-0.0和+0.0被认为是相等的，不像Double.equals(Object) 。
    
    双缓冲区不等于任何其他类型的对象。
    重写：
    
    equals在 Object
    
    参数
    
    ob - 要比较此缓冲区的对象
    
    结果
    
    true如果，并且只有当这个缓冲区等于给定的对象
    
    另请参见：
    
    Object.hashCode() ， HashMap
  - compareTo
```
public int compareTo(DoubleBuffer that)
```
    将此缓冲区与另一个缓冲区进
    将两个双缓冲区进行比较，比较其顺序的剩余元素的词典，而不考虑每个序列的起始位置在其相应的缓冲区内。对double元素进行比较，仿佛通过调用Double.compare(double,double) ，除了-0.0和0.0被认为是相等的。 Double.NaN被认为是等于自己和大于所有其他double值（包括Double.POSITIVE_INFINITY ）。
    
    双缓冲区与任何其他类型的对象无法比较。
    
    Specified by:
    
    compareTo在接口 Comparable<DoubleBuffer>
    
    参数
    
    that - 要比较的对象。
    
    结果
    
    负整数，零或正整数，因为此缓冲区小于，等于或大于给定的缓冲区
  - order
```
public abstract ByteOrder order()
```
    检索此缓冲区的字节顺序。
    通过分配或通过包装现有的double阵列创建的双缓冲区的字节顺序是底层硬件的native order 。创建为字节缓冲区view的双缓冲区的字节顺序是创建视图时的字节缓冲区的字节顺序。
    
    结果
    
    这个缓冲区的字节顺序

Class DoubleBuffer

方法摘要

Methods inherited from class java.nio.Buffer

Methods inherited from class java.lang.Object

方法详细信息

allocate

wrap

wrap

slice

duplicate

asReadOnlyBuffer

get

put

get

put

get

get

put

put

put

hasArray

array

arrayOffset

position

limit

mark

reset

clear

flip

rewind

compact

isDirect

toString

hashCode

equals

compareTo

order