DoubleBuffer (Java Platform SE 8 )

java.lang.Object
- java.nio.Buffer
- - java.nio.DoubleBuffer

All Implemented Interfaces:

Comparable DoubleBuffer > <
```
public abstract class DoubleBuffer
extends Buffer
implements Comparable<DoubleBuffer>
```
双缓冲区。
这个类定义了双缓冲区中的四类操作：
- 绝对和相对get和put方法读写单双打；
- 相对bulk get方法转移双打连续序列从这个缓冲区数组；和
- 相对bulk put方法转移双打连续序列的双数组或其他一些双缓冲区到缓冲区；和
- 方法compacting，duplicating，和slicing双缓冲。
双缓冲区可以创建由allocation，分配的缓冲区的内容空间，通过wrapping现有双数组读入缓冲区，或创建一个view现有的字节缓冲区。

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

在这个类中，不以其他方式有一个返回的值被指定返回它们被调用的缓冲区。这允许方法调用被。
从以下版本开始：

一点四

方法摘要

所有方法静态方法接口方法抽象方法具体的方法
Modifier and Type	Method and Description
`static DoubleBuffer`	`allocate(int capacity)` 分配一个新的双缓冲区。
`double[]`	`array()` 返回双阵列，支持这一缓冲（可选操作）。
`int`	`arrayOffset()` 返回在缓冲第一元这个缓冲区支持数组的偏移（可选操作）。
`abstract DoubleBuffer`	`asReadOnlyBuffer()` 创建一个新的，只读的双缓冲区，共享这个缓冲区的内容。
`abstract DoubleBuffer`	`compact()` 契约这个缓冲区（可选操作）。
`int`	`compareTo(DoubleBuffer that)` 将此缓冲区与另一缓冲区。
`abstract DoubleBuffer`	`duplicate()` 创建一个新的双缓冲区，共享此缓冲区的内容。
`boolean`	`equals(Object ob)` 告诉是否这个缓冲区是否等于另一个对象。
`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()` 告诉是否这个双缓冲区是直接的。
`abstract ByteOrder`	`order()` 检索此缓冲区的字节顺序。
`abstract DoubleBuffer`	`put(double d)` 相对放方法（可选操作）。
`DoubleBuffer`	`put(double[] src)` 相对体积放方法（可选操作）。
`DoubleBuffer`	`put(double[] src, int offset, int length)` 相对体积放方法（可选操作）。
`DoubleBuffer`	`put(DoubleBuffer src)` 相对体积放方法（可选操作）。
`abstract DoubleBuffer`	`put(int index, double d)` 绝对放方法（可选操作）。
`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, clear, flip, hasRemaining, isReadOnly, limit, limit, mark, position, position, remaining, reset, rewind

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

- 方法详细信息
  - allocate
```
public static DoubleBuffer allocate(int capacity)
```
    分配一个新的双缓冲区。
    新的缓冲区的位置将是零，它的限制将是它的容量，它的标记将是不确定的，它的每一个元素都将被初始化为零。这将有一个backing array，及其array offset将零。
    
    参数
    
    capacity -新的缓冲区的容量，在双打
    
    结果
    
    新的双缓冲区
    
    异常
    
    IllegalArgumentException -如果 capacity是负整数
  - wrap
```
public static DoubleBuffer wrap(double[] array,
                                int offset,
                                int length)
```
    将一个双数组封装到一个缓冲区中。
    新的缓冲区将由给定的双数组支持，也就是说，对缓冲区的修改将导致数组被修改，反之亦然。新的缓冲区的容量将array.length，其位置将offset，极限将offset + length，其标志将是不确定的。其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，其位置将为零，其标志将是不确定的。其backing array将给定的数组，并将其array offset>零。
    
    参数
    
    array的阵列，将该缓冲区
    
    结果
    
    新的双缓冲区
  - slice
```
public abstract DoubleBuffer slice()
```
    创建一个新的双缓冲区的内容是一个共享的子缓冲区的内容。
    新的缓冲区的内容将从这个缓冲区的当前位置开始。这个缓冲区的内容的变化将在新的缓冲区中可见，反之亦然；两个缓冲区的位置，限制和标记值将是独立的。
    
    新的缓冲区的位置将是零，它的容量和它的限制将是在这个缓冲区的数量的双打，和它的标记将是不确定的。新的缓冲区将是直接的，如果，只有当这个缓冲区是直接的，它将是只读的，只有当，这个缓冲区是只读的。
    
    结果
    
    新的双缓冲区
  - duplicate
```
public abstract DoubleBuffer duplicate()
```
    创建一个新的双缓冲区，共享此缓冲区的内容。
    新的缓冲区的内容将是这个缓冲区的内容。这个缓冲区的内容的变化将在新的缓冲区中可见，反之亦然；两个缓冲区的位置，限制和标记值将是独立的。
    
    新的缓冲区的容量、限制、位置和标记值将与此缓冲区相同。新的缓冲区将是直接的，如果，只有当这个缓冲区是直接的，它将是只读的，只有当，这个缓冲区是只读的。
    
    结果
    
    新的双缓冲区
  - asReadOnlyBuffer
```
public abstract DoubleBuffer asReadOnlyBuffer()
```
    创建一个新的，只读的双缓冲区，共享这个缓冲区的内容。
    新的缓冲区的内容将是这个缓冲区的内容。对该缓冲区的内容的更改将在新的缓冲区中可见；但是，新的缓冲区本身将是只读的，不会允许共享内容被修改。这两个缓冲区的位置，限制，和标记值将是独立的。
    
    新的缓冲区的容量、限制、位置和标记值将与此缓冲区相同。
    
    如果这个缓冲区本身是只读那么这个方法的行为一样的duplicate方法。
    
    结果
    
    新的，只读的双缓冲区
  - get
```
public abstract double get()
```
    相对得到方法。读取这个缓冲区的当前位置的双，然后增量位置。
    
    结果
    
    在缓冲区的当前位置的双
    
    异常
    
    BufferUnderflowException -如果缓冲区的当前位置不小于其极限
  - put
```
public abstract DoubleBuffer put(double d)
```
    相对放方法（可选操作）。
    将给定的双到当前位置的缓冲区中，然后将该位置增量。
    
    参数
    
    d -要写双
    
    结果
    
    这个缓冲区
    
    异常
    
    BufferOverflowException -如果这个缓冲区的当前位置不小于其极限
    
    ReadOnlyBufferException -如果这个缓冲区是只读的
  - get
```
public abstract double get(int index)
```
    绝对得到方法。读取给定索引中的双。
    
    参数
    
    index -指数从这双会读
    
    结果
    
    给定索引中的双
    
    异常
    
    IndexOutOfBoundsException -如果 index是负面或不小于缓冲区的限制
  - put
```
public abstract DoubleBuffer put(int index,
                                 double d)
```
    绝对放方法（可选操作）。
    在给定的索引中写入给定的双到这个缓冲区中。
    
    参数
    
    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 -偏移在一双数组要写；必须是非负的且不大于 dst.length
    
    length -双打的最大数目要写入给定的数组；必须是非负的且不大于 dst.length - offset
    
    结果
    
    这个缓冲区
    
    异常
    
    BufferUnderflowException -如果有少于 length双打留在这个缓冲区
    
    IndexOutOfBoundsException -如果在 offset和 length参数的前提条件不成立
  - get
```
public DoubleBuffer get(double[] dst)
```
    相对体积得到方法。
    此方法将此缓冲区的两倍传输到给定的目标阵列。这种形式的src.get(a)方法调用的行为一样，调用
```
SRC。得到（一，0，a.length）
```
    参数
    
    dst -目标数组
    
    结果
    
    这个缓冲区
    
    异常
    
    BufferUnderflowException -如果有少于 length双打留在这个缓冲区
  - put
```
public DoubleBuffer put(DoubleBuffer src)
```
    相对体积放方法（可选操作）。
    此方法将给定的源缓冲区中的两倍传输到该缓冲区中。如果有更多的双打中剩余的源缓冲区比这个缓冲区，即如果src.remaining() > remaining()，然后没有双打转移和BufferOverflowException抛出。
    
    否则，此方法复制N = src.remaining()双打从给定的缓冲区到缓冲区，开始在每个缓冲区的当前位置。这两个缓冲区的位置，然后加N.
    
    换句话说，这种形式的dst.put(src)方法调用作为循环具有完全相同的效果
```
而（SRC。hasremaining()）DST。把（SRC。get()）；
```
    除外，它首先检查这个缓冲区有足够的空间，这可能是更有效的。
    参数
    
    src -源缓冲区的双打是读；不得这个缓冲区
    
    结果
    
    这个缓冲区
    
    异常
    
    BufferOverflowException -如果没有足够的空间在这个缓冲区在源缓冲区剩余的双打
    
    IllegalArgumentException -如果源缓冲区缓冲区
    
    ReadOnlyBufferException -如果这个缓冲区是只读的
  - put
```
public DoubleBuffer put(double[] src,
                        int offset,
                        int length)
```
    相对体积放方法（可选操作）。
    这种方法传输到这个缓冲区的一倍，从给定的源阵列。如果有更多的双打被复制从阵列比保持在这个缓冲区，即如果length > remaining()，然后没有双打转移和BufferOverflowException抛出。
    
    否则，此方法复制length双打从给定的数组到缓冲区，从给定的数组中，该缓冲区的当前位置偏移。这个缓冲区的位置，再加length。
    
    换句话说，这种形式的dst.put(src, off, len)方法调用作为循环具有完全相同的效果
```
     for (int i = off; i < off + len; i++)
         dst.put(a[i]);
 
```
    除外，它首先检查这个缓冲区有足够的空间，这可能是更有效的。
    参数
    
    src的阵列，双打要读的
    
    offset -偏移在一双数组读入；必须是非负的且不大于 array.length
    
    length -双打的数目可以从给定的数组中读取的；必须是非负的且不大于 array.length - offset
    
    结果
    
    这个缓冲区
    
    异常
    
    BufferOverflowException -如果在这个缓冲区中没有足够的空间
    
    IndexOutOfBoundsException -如果在 offset和 length参数的前提条件不成立
    
    ReadOnlyBufferException -如果这个缓冲区是只读的
  - put
```
public final DoubleBuffer put(double[] src)
```
    相对体积放方法（可选操作）。
    此方法将给定源的双数组的整个内容转换到这个缓冲区中。这种形式的dst.put(a)方法调用的行为一样，调用
```
DST。把（一，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 -如果这个缓冲区不是由访问阵列支持
  - compact
```
public abstract DoubleBuffer compact()
```
    契约这个缓冲区（可选操作）。
    缓冲器的当前位置和它的极限之间的一倍，如果有的话，被复制到缓冲区的开始。那就是，在指数P = position()双拷贝到指数为零，在指数P + 1双是复制指数，等等，直到指数limit() - 1双拷贝到指数n = limit() - 1 - P.缓冲区的位置，然后设置为n + 1的限制设置为它的能力。标记，如果定义，将被丢弃。
    
    缓冲区的位置设置为数加倍复制，而不是零，所以，此方法的调用可以紧接着另一个相对放方法调用。
    
    结果
    
    这个缓冲区
    
    异常
    
    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)
```
    告诉是否这个缓冲区是否等于另一个对象。
    两个双缓冲器是相等的，如果，并且只有，
    1. 他们有相同的元素类型，
    2. 他们有相同数量的剩余元素，和
    3. 两序列的其余元素，认为是独立的，他们的立场出发，逐点等。该方法考虑了双元素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一字节缓冲区是字节缓冲区目前创建视图。
    
    结果
    
    此缓冲区的字节顺序

Submit a bug or feature
For further API reference and developer documentation, see Java SE Documentation. That documentation contains more detailed, developer-targeted descriptions, with conceptual overviews, definitions of terms, workarounds, and working code examples.
Copyright © 1993, 2014, Oracle and/or its affiliates. All rights reserved.

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

compact

isDirect

toString

hashCode

equals

compareTo

order