Module java.base

Package java.nio

Class DoubleBuffer

java.lang.Object

java.nio.Buffer

java.nio.DoubleBuffer

所有已实现的接口:

Comparable<DoubleBuffer>

       public abstract sealed class DoubleBuffer extends Buffer implements Comparable<DoubleBuffer>
      

双倍缓冲区。

该类定义了双倍缓冲区的四类操作：

• 绝对和相对的get和put方法，用于读取和写入单个双精度数；

• 绝对和相对的bulk get方法，将连续的双精度数序列从该缓冲区传输到数组中；

• 绝对和相对的bulk put方法，将双精度数的连续序列从双精度数组或其他双倍缓冲区传输到该缓冲区；

• 用于压缩双倍缓冲区的方法。

双倍缓冲区可以通过分配空间来创建，通过将现有双精度数组包装成缓冲区，或者通过创建现有字节缓冲区的视图来创建。

与字节缓冲区一样，双倍缓冲区可以是直接或非直接的。通过该类的wrap方法创建的双倍缓冲区将是非直接的。如果双倍缓冲区是字节缓冲区的视图，则只有当字节缓冲区本身是直接的时，双倍缓冲区才是直接的。可以通过调用isDirect方法来确定双倍缓冲区是否是直接的。

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

可选操作

当在只读双倍缓冲区上调用被指定为可选操作的方法时，会抛出ReadOnlyBufferException异常。如果双倍缓冲区不是由可访问的双精度数组支持的，则array和arrayOffset方法会抛出UnsupportedOperationException异常。

自版本:

1.4

Method Summary

Modifier and Type	Method	Description
static DoubleBuffer	allocate(int capacity)	分配一个新的双倍缓冲区。
final double[]	array()	返回支持该缓冲区的双精度数组 (可选操作)。
final int	arrayOffset()	返回该缓冲区的支持数组中第一个元素的偏移量 (可选操作)。
abstract DoubleBuffer	asReadOnlyBuffer()	创建一个新的只读双倍缓冲区，共享该缓冲区的内容。
final DoubleBuffer	clear()	清除该缓冲区。
abstract DoubleBuffer	compact()	压缩该缓冲区 (可选操作)。
int	compareTo(DoubleBuffer that)	将该缓冲区与另一个缓冲区进行比较。
abstract DoubleBuffer	duplicate()	创建一个新的双倍缓冲区，共享该缓冲区的内容。
boolean	equals(Object ob)	判断该缓冲区是否等于另一个对象。
final DoubleBuffer	flip()	翻转该缓冲区。
abstract double	get()	相对get方法。
DoubleBuffer	get(double[] dst)	相对批量get方法。
DoubleBuffer	get(double[] dst, int offset, int length)	相对批量get方法。
abstract double	get(int index)	绝对get方法。
DoubleBuffer	get(int index, double[] dst)	绝对批量get方法。
DoubleBuffer	get(int index, double[] dst, int offset, int length)	绝对批量get方法。
final boolean	hasArray()	判断该缓冲区是否由可访问的双精度数组支持。
int	hashCode()	返回该缓冲区的当前哈希码。
abstract boolean	isDirect()	判断该双倍缓冲区是否是直接的。
final DoubleBuffer	limit(int newLimit)	设置该缓冲区的限制。
final DoubleBuffer	mark()	在位置设置该缓冲区的标记。
int	mismatch(DoubleBuffer that)	查找并返回该缓冲区与给定缓冲区之间第一个不匹配的相对索引。
abstract ByteOrder	order()	检索该缓冲区的字节顺序。
final DoubleBuffer	position(int newPosition)	设置该缓冲区的位置。
abstract DoubleBuffer	put(double d)	相对put方法 (可选操作)。
final DoubleBuffer	put(double[] src)	相对批量put方法 (可选操作)。
DoubleBuffer	put(double[] src, int offset, int length)	相对批量put方法 (可选操作)。
abstract DoubleBuffer	put(int index, double d)	绝对put方法 (可选操作)。
DoubleBuffer	put(int index, double[] src)	绝对批量put方法 (可选操作)。
DoubleBuffer	put(int index, double[] src, int offset, int length)	绝对批量put方法 (可选操作)。
DoubleBuffer	put(int index, DoubleBuffer src, int offset, int length)	绝对批量put方法 (可选操作)。
DoubleBuffer	put(DoubleBuffer src)	相对批量put方法 (可选操作)。
final DoubleBuffer	reset()	将该缓冲区的位置重置为先前标记的位置。
final DoubleBuffer	rewind()	倒带该缓冲区。
abstract DoubleBuffer	slice()	创建一个新的双倍缓冲区，其内容是该缓冲区内容的共享子序列。
abstract DoubleBuffer	slice(int index, int length)	创建一个新的双倍缓冲区，其内容是该缓冲区内容的共享子序列。
String	toString()	返回总结该缓冲区状态的字符串。
static DoubleBuffer	wrap(double[] array)	将双精度数组包装成缓冲区。
static DoubleBuffer	wrap(double[] array, int offset, int length)	将双精度数组包装成缓冲区。

Methods declared in class java.nio.Buffer

capacity, hasRemaining, isReadOnly, limit, position, remaining

Methods declared in class java.lang.Object

clone, finalize, getClass, notify, notifyAll, wait, wait, wait

Method Details

allocate

             public static DoubleBuffer allocate(int capacity)
            

分配一个新的双倍缓冲区。

新缓冲区的位置将为零，限制将为其容量，标记将为未定义，每个元素将初始化为零，并且字节顺序将是底层硬件的本机顺序。它将有一个支持数组，其数组偏移将为零。

参数:

capacity - 新缓冲区的容量，以双精度数计

返回:

新的双倍缓冲区

抛出:

IllegalArgumentException - 如果capacity是负整数

wrap

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

将双精度数组包装成缓冲区。

新缓冲区将由给定的双精度数组支持；也就是说，对缓冲区的修改将导致数组被修改，反之亦然。新缓冲区的容量将为array.length，其位置将为offset，其限制将为offset + length，其标记将为未定义，并且字节顺序将是底层硬件的本机顺序。其支持数组将是给定数组，并且其数组偏移将为零。

参数:

array - 将支持新缓冲区的数组

offset - 要使用的子数组的偏移量；必须是非负数且不大于array.length。新缓冲区的位置将设置为此值。

length - 要使用的子数组的长度；必须是非负数且不大于array.length - offset。新缓冲区的限制将设置为offset + length。

返回:

新的双倍缓冲区

抛出:

IndexOutOfBoundsException - 如果offset和length参数的前提条件不成立

wrap

             public static DoubleBuffer wrap(double[] array)
            

将双精度数组包装成缓冲区。

新缓冲区将由给定的双精度数组支持；也就是说，对缓冲区的修改将导致数组被修改，反之亦然。新缓冲区的容量和限制将为array.length，其位置将为零，其标记将为未定义，并且字节顺序将是底层硬件的本机顺序。其支持数组将是给定数组，并且其数组偏移将为零。

参数:

array - 将支持此缓冲区的数组

返回:

新的双倍缓冲区

slice

             public abstract DoubleBuffer slice()
            

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

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

新缓冲区的位置将为零，其容量和限制将是该缓冲区中剩余双精度数的数量，其标记将为未定义，并且字节顺序将与该缓冲区相同。如果该缓冲区是直接的，则新缓冲区也将是直接的，如果该缓冲区是只读的，则新缓冲区也将是只读的。

指定者:

slice 在类 Buffer中

返回:

新的双倍缓冲区

slice

             public abstract DoubleBuffer slice(int index, int length)
            

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

新缓冲区的内容将从该缓冲区的位置index开始，并包含length个元素。对该缓冲区内容的更改将在新缓冲区中可见，反之亦然；两个缓冲区的位置、限制和标记值将是独立的。

新缓冲区的位置将为零，其容量和限制将为length，其标记将为未定义，并且字节顺序将与该缓冲区相同。如果该缓冲区是直接的，则新缓冲区也将是直接的，如果该缓冲区是只读的，则新缓冲区也将是只读的。

指定者:

slice 在类 Buffer中

参数:

index - 新缓冲区内容开始的位置；必须是非负的且不大于limit()

length - 新缓冲区包含的元素数量；必须是非负的且不大于limit() - index

返回:

新缓冲区

抛出:

IndexOutOfBoundsException - 如果index为负或大于limit()，length为负，或length > limit() - index

自:

13

duplicate

             public abstract DoubleBuffer duplicate()
            

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

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

新缓冲区的容量、限制、位置、标记值和字节顺序将与此缓冲区相同。如果此缓冲区是直接的，则新缓冲区也将是直接的；如果此缓冲区是只读的，则新缓冲区也将是只读的。

指定者:

duplicate 在类 Buffer中

返回:

新双精度缓冲区

asReadOnlyBuffer

             public abstract DoubleBuffer asReadOnlyBuffer()
            

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

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

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

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

返回:

新的只读双精度缓冲区

get

             public abstract double get()
            

相对get方法。读取此缓冲区当前位置处的双精度值，然后增加位置。

返回:

缓冲区当前位置处的双精度值

抛出:

BufferUnderflowException - 如果缓冲区当前位置不小于其限制

put

             public abstract DoubleBuffer put(double d)
            

相对put方法 (可选操作)。

将给定的双精度值写入此缓冲区的当前位置，然后增加位置。

参数:

d - 要写入的双精度值

返回:

此缓冲区

抛出:

BufferOverflowException - 如果此缓冲区的当前位置不小于其限制

ReadOnlyBufferException - 如果此缓冲区是只读的

get

             public abstract double get(int index)
            

绝对get方法。读取给定索引处的双精度值。

参数:

index - 要读取双精度值的索引

返回:

给定索引处的双精度值

抛出:

IndexOutOfBoundsException - 如果index为负或不小于缓冲区的限制

put

             public abstract DoubleBuffer put(int index, double d)
            

绝对put方法 (可选操作)。

将给定的双精度值写入此缓冲区的给定索引处。

参数:

index - 要写入双精度值的索引

d - 要写入的双精度值

返回:

此缓冲区

抛出:

IndexOutOfBoundsException - 如果index为负或不小于缓冲区的限制

ReadOnlyBufferException - 如果此缓冲区是只读的

get

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

相对批量get方法。

此方法将双精度值从此缓冲区传输到给定的目标数组。如果缓冲区中剩余的双精度值少于请求的数量，即，如果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)
            

相对批量get方法。

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

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

参数:

dst - 目标数组

返回:

此缓冲区

抛出:

BufferUnderflowException - 如果此缓冲区中剩余的双精度值少于length个

get

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

绝对批量get方法。

此方法将length个双精度值从此缓冲区传输到给定数组，从此缓冲区中的给定索引开始，在数组中的给定偏移量开始。此缓冲区的位置不变。

形式为src.get(index, dst, offset, length)的此方法的调用与以下循环具有完全相同的效果，只是它首先检查所提供参数的一致性，并且可能更有效：

    for (int i = offset, j = index; i < offset + length; i++, j++)
        dst[i] = src.get(j);

参数:

index - 从中读取第一个双精度值的此缓冲区中的索引；必须是非负的且小于limit()

dst - 目标数组

offset - 要写入的第一个双精度值在数组中的偏移量；必须是非负的且小于dst.length

length - 要写入给定数组的双精度值数量；必须是非负的且不大于limit() - index和dst.length - offset中较小的值

返回:

此缓冲区

抛出:

IndexOutOfBoundsException - 如果index、offset和length参数的前提条件不成立

自:

13

get

             public DoubleBuffer get(int index, double[] dst)
            

绝对批量get方法。

此方法将双精度值从此缓冲区传输到给定的目标数组。此缓冲区的位置不变。形式为src.get(index, dst)的此方法的调用行为与以下调用完全相同：

    src.get(index, dst, 0, dst.length)

参数:

index - 从中读取第一个双精度值的此缓冲区中的索引；必须是非负的且小于limit()

dst - 目标数组

返回:

此缓冲区

抛出:

IndexOutOfBoundsException - 如果index为负、不小于limit()，或limit() - index < dst.length

自:

13

put

             public DoubleBuffer put(DoubleBuffer src)
            

相对批量 put 方法 (可选操作)。

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

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

换句话说，调用形式为 dst.put(src) 的此方法与循环

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

具有完全相同的效果，只是它首先检查此缓冲区中是否有足够的空间，并且可能更有效率。如果此缓冲区和源缓冲区共享相同的后备数组或内存，则结果将是源元素首先被复制到中间位置，然后写入此缓冲区。

参数:

src - 要读取双精度值的源缓冲区；不能是此缓冲区

返回:

此缓冲区

抛出:

BufferOverflowException - 如果此缓冲区中没有足够的空间来容纳源缓冲区中剩余的双精度值

IllegalArgumentException - 如果源缓冲区是此缓冲区

ReadOnlyBufferException - 如果此缓冲区是只读的

put

             public DoubleBuffer put(int index, DoubleBuffer src, int offset, int length)
            

绝对批量 put 方法 (可选操作)。

此方法从给定源缓冲区中的给定 offset 和此缓冲区中的给定 index 开始，将 length 个双精度值传输到此缓冲区中。两个缓冲区的位置保持不变。

换句话说，调用形式为 dst.put(index, src, offset, length) 的此方法与循环

    for (int i = offset, j = index; i < offset + length; i++, j++)
        dst.put(j, src.get(i));

具有完全相同的效果，只是它首先检查所提供参数的一致性，并且可能更有效率。如果此缓冲区和源缓冲区共享相同的后备数组或内存，则结果将是源元素首先被复制到中间位置，然后写入此缓冲区。

参数:

index - 将写入第一个双精度值的此缓冲区中的索引；必须是非负数且小于 limit()

src - 要读取双精度值的缓冲区

offset - 要读取的第一个双精度值在源数组中的索引；必须是非负数且小于 src.limit()

length - 要从给定缓冲区中读取的双精度值数量；必须是非负数且不大于 limit() - index 和 src.limit() - offset 中较小的值

返回:

此缓冲区

抛出:

IndexOutOfBoundsException - 如果 index、offset 和 length 参数的前提条件不成立

ReadOnlyBufferException - 如果此缓冲区是只读的

自:

16

put

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

相对批量 put 方法 (可选操作)。

此方法从给定源数组中传输双精度值到此缓冲区中。如果要从数组中复制的双精度值多于此缓冲区中剩余的双精度值，即如果 length > remaining()，则不会传输任何双精度值，并抛出 BufferOverflowException。

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

换句话说，调用形式为 dst.put(src, off, len) 的此方法与循环

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

具有完全相同的效果，只是它首先检查此缓冲区中是否有足够的空间，并且可能更有效率。

参数:

src - 要读取双精度值的数组

offset - 要读取的第一个双精度值在数组中的偏移量；必须是非负数且不大于 src.length

length - 要从给定数组中读取的双精度值数量；必须是非负数且不大于 src.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 - 如果此缓冲区是只读的

put

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

绝对批量 put 方法 (可选操作)。

此方法从给定数组中的给定偏移量和此缓冲区中的给定索引开始传输 length 个双精度值到此缓冲区中。此缓冲区的位置保持不变。

调用形式为 dst.put(index, src, offset, length) 的此方法与以下循环具有完全相同的效果，只是它首先检查所提供参数的一致性，并且可能更有效率：

    for (int i = offset, j = index; i < offset + length; i++, j++)
        dst.put(j, src[i]);

参数:

index - 将写入第一个双精度值的此缓冲区中的索引；必须是非负数且小于 limit()

src - 要读取双精度值的数组

offset - 要读取的第一个双精度值在数组中的偏移量；必须是非负数且小于 src.length

length - 要从给定数组中读取的双精度值数量；必须是非负数且不大于 limit() - index 和 src.length - offset 中较小的值

返回:

此缓冲区

抛出:

IndexOutOfBoundsException - 如果 index、offset 和 length 参数的前提条件不成立

ReadOnlyBufferException - 如果此缓冲区是只读的

自:

13

put

             public DoubleBuffer put(int index, double[] src)
            

绝对批量 put 方法 (可选操作)。

此方法从给定源数组中复制双精度值到此缓冲区中。此缓冲区的位置保持不变。调用形式为 dst.put(index, src) 的此方法的行为与调用相同：

    dst.put(index, src, 0, src.length);

参数:

index - 将第一个双精度数写入该缓冲区的索引；必须是非负数且小于limit()

src - 要读取双精度数的数组

返回:

此缓冲区

抛出:

IndexOutOfBoundsException - 如果index为负数，不小于limit()，或limit() - index < src.length

ReadOnlyBufferException - 如果此缓冲区是只读的

自从:

13

hasArray

             public final boolean hasArray()
            

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

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

指定者:

hasArray 在类中 Buffer

返回:

如果此缓冲区由数组支持且不是只读，则返回true

array

             public final double[] array()
            

返回支持此缓冲区的双精度数组 (可选操作)。

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

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

指定者:

array 在类中 Buffer

返回:

支持此缓冲区的数组

抛出:

ReadOnlyBufferException - 如果此缓冲区由数组支持但是只读的

UnsupportedOperationException - 如果此缓冲区不由可访问的数组支持

arrayOffset

             public final int arrayOffset()
            

返回此缓冲区支持数组中第一个元素的偏移量 (可选操作)。

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

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

指定者:

arrayOffset 在类中 Buffer

返回:

此缓冲区数组中第一个元素的偏移量

抛出:

ReadOnlyBufferException - 如果此缓冲区由数组支持但是只读的

UnsupportedOperationException - 如果此缓冲区不由可访问的数组支持

position

             public final DoubleBuffer position(int newPosition)
            

设置此缓冲区的位置。如果标记已定义且大于新位置，则将其丢弃。

覆盖:

position 在类中 Buffer

参数:

newPosition - 新的位置值；必须是非负数且不大于当前限制

返回:

此缓冲区

自从:

9

limit

             public final DoubleBuffer limit(int newLimit)
            

设置此缓冲区的限制。如果位置大于新限制，则将其设置为新限制。如果标记已定义且大于新限制，则将其丢弃。

覆盖:

limit 在类中 Buffer

参数:

newLimit - 新的限制值；必须是非负数且不大于此缓冲区的容量

返回:

此缓冲区

自从:

9

mark

             public final DoubleBuffer mark()
            

设置此缓冲区的标记为其位置。

覆盖:

mark 在类中 Buffer

返回:

此缓冲区

自从:

9

reset

             public final DoubleBuffer reset()
            

将此缓冲区的位置重置为先前标记的位置。

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

覆盖:

reset 在类中 Buffer

返回:

此缓冲区

自从:

9

clear

             public final DoubleBuffer clear()
            

清除此缓冲区。位置设置为零，限制设置为容量，并丢弃标记。

在使用一系列通道读取或put操作填充此缓冲区之前，请调用此方法。例如：

    buf.clear();     // 准备缓冲区进行读取
    in.read(buf);    // 读取数据

此方法实际上不会擦除缓冲区中的数据，但命名为这样是因为它通常在可能需要擦除数据的情况下使用。

覆盖:

clear 在类中 Buffer

返回:

此缓冲区

自从:

9

flip

             public final DoubleBuffer flip()
            

翻转此缓冲区。限制设置为当前位置，然后位置设置为零。如果标记已定义，则将其丢弃。

在一系列通道读取或put操作之后，调用此方法以准备进行一系列通道写入或相对get操作。例如：

    buf.put(magic);    // 在头部添加
    in.read(buf);      // 将数据读入缓冲区的其余部分
    buf.flip();        // 翻转缓冲区
    out.write(buf);    // 将头部+数据写入通道

compact方法一起在将数据从一个地方传输到另一个地方时使用。

覆盖:

flip 在类中 Buffer

返回:

此缓冲区

自从:

9

rewind

             public final DoubleBuffer rewind()
            

倒带此缓冲区。位置设置为零，标记丢弃。

在一系列通道写入或get操作之前，请调用此方法，假设限制已经适当设置。例如：

    out.write(buf);    // 写入剩余数据
    buf.rewind();      // 倒带缓冲区
    buf.get(array);    // 将数据复制到数组中

覆盖:

rewind 在类中 Buffer

返回:

此缓冲区

自从:

9

compact

             public abstract DoubleBuffer compact()
            

压缩此缓冲区 (可选操作)。

在缓冲区当前位置和限制之间的双精度数（如果有）将被复制到缓冲区的开头。也就是说，索引为p = position()的双精度数将被复制到索引零，索引为p + 1的双精度数将被复制到索引一，依此类推，直到索引limit() - 1的双精度数被复制到索引n = limit() - 1 - p。然后，缓冲区的位置设置为n+1，其限制设置为其容量。如果定义了标记，则将其丢弃。

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

返回:

此缓冲区

抛出:

ReadOnlyBufferException - 如果此缓冲区是只读的

isDirect

             public abstract boolean isDirect()
            

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

指定者:

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）。

双精度缓冲区与任何其他类型的对象都不可比较。

指定者:

compareTo 在接口 Comparable<DoubleBuffer>

参数:

that - 要比较的对象。

返回:

如果此缓冲区小于、等于或大于给定缓冲区，则为负整数、零或正整数

mismatch

             public int mismatch(DoubleBuffer that)
            

查找并返回此缓冲区与给定缓冲区之间第一个不匹配的相对索引。索引是相对于每个缓冲区的 position，将在 0（包括）到每个缓冲区中剩余元素的较小值（不包括）的范围内。

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

参数:

that - 要与此缓冲区进行不匹配测试的字节缓冲区

返回:

此缓冲区与给定缓冲区之间第一个不匹配的相对索引，否则如果没有不匹配则为 -1。

自:

11

order

             public abstract ByteOrder order()
            

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

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

返回:

此缓冲区的字节顺序