LongBuffer - [ Java参考文档 ] - 在线原生手册

目录搜索

文字

概述

软件包

类

使用

树

已过时

索引

帮助

Java^TM 2 Platform
Standard Ed. 6

上一个类 下一个类

框架 无框架

摘要：嵌套 | 字段 | 构造方法 | 方法

详细信息：字段 | 构造方法 | 方法

java.nio
类 LongBuffer

java.lang.Object
  java.nio.Buffer
      java.nio.LongBuffer

所有已实现的接口：: Comparable<LongBuffer>

public abstract class LongBuffer
extends Buffer
implements Comparable<LongBuffer>

long 缓冲区。

此类定义了 long 缓冲区上的四类操作：

读写单个 long 的绝对和相对 get 和 put 方法；

将此缓冲区的连续 long 序列传输到数组中的相对 批量 get 方法；

将 long 数组或其他 long 缓冲区中的连续 long 序列传输到此缓冲区的相对 批量 put 方法；以及

long 缓冲区的 compacting 、 duplicating 和 slicing 方法。

long 缓冲区可以通过 allocation 创建，此方法通过 wrapping 将一个现有 long 数组包装到缓冲区中来为缓冲区内容分配空间，或者通过创建现有字节缓冲区的视图来创建。

像字节缓冲区一样，long 缓冲区要么是 直接的，要么是非直接的 。通过此类的 wrap 方法创建的 long 缓冲区将是非直接的。当且仅当字节缓冲区本身为直接时，作为字节缓冲区的视图创建的 long 缓冲区才是直接的。通过调用 isDirect 方法可以确定 long 缓冲区是否为直接的。

指定此类中的方法（它们不返回其他值），以返回这些方法被调用时所在的缓冲区。这允许对方法调用进行链接。

从以下版本开始：: 1.4

方法摘要
`static LongBuffer`	`allocate(int capacity)` 分配新的 long 缓冲区。
`long[]`	`array()` 返回实现此缓冲区的 long 数组（可选操作）。
`int`	`arrayOffset()` 返回此缓冲区中第一个元素在缓冲区的支持数组中的偏移量（可选操作）。
`abstract LongBuffer`	`asReadOnlyBuffer()` 创建共享此缓冲区内容的新的只读 long 缓冲区。
`abstract LongBuffer`	`compact()` 压缩此缓冲区（可选操作）。
`int`	`compareTo(LongBuffer that)` 将此缓冲区与另一个缓冲区进行比较。
`abstract LongBuffer`	`duplicate()` 创建共享此缓冲区内容的新的 long 缓冲区。
`boolean`	`equals(Object ob)` 判断此缓冲区是否与另一个对象相同。
`abstract long`	`get()` 相对 get 方法。
`abstract long`	`get(int index)` 绝对 get 方法。
`LongBuffer`	`get(long[] dst)` 相对批量 get 方法。
`LongBuffer`	`get(long[] dst, int offset, int length)` 相对批量 get 方法。
`boolean`	`hasArray()` 判断是否可通过一个可访问的 long 数组实现此缓冲区。
`int`	`hashCode()` 返回此缓冲区的当前哈希码。
`abstract boolean`	`isDirect()` 判断此 long 缓冲区是否为直接的。
`abstract ByteOrder`	`order()` 获取此缓冲区的字节顺序。
`abstract LongBuffer`	`put(int index, long l)` 绝对 put 方法（可选操作）。
`abstract LongBuffer`	`put(long l)` 相对 put 方法（可选操作）。
`LongBuffer`	`put(long[] src)` 相对批量 put 方法（可选操作）。
`LongBuffer`	`put(long[] src, int offset, int length)` 相对批量 put 方法（可选操作）。
`LongBuffer`	`put(LongBuffer src)` 相对批量 put 方法（可选操作）。
`abstract LongBuffer`	`slice()` 创建新的 long 缓冲区，其内容是此缓冲区内容的共享子序列。
`String`	`toString()` 返回总结了此缓冲区状态的字符串。
`static LongBuffer`	`wrap(long[] array)` 将 long 数组包装到缓冲区中。
`static LongBuffer`	`wrap(long[] array, int offset, int length)` 将 long 数组包装到缓冲区中。

从类 java.nio.Buffer 继承的方法
`capacity, clear, flip, hasRemaining, isReadOnly, limit, limit, mark, position, position, remaining, reset, rewind`

从类 java.lang.Object 继承的方法
`clone, finalize, getClass, notify, notifyAll, wait, wait, wait`

方法详细信息

allocate

public static LongBuffer allocate(int capacity)

分配新的 long 缓冲区。

新缓冲区的位置将为零，其界限将为其容量，其标记是未定义的。它将具有一个底层实现数组，且其数组偏移量将为零。

参数：: capacity - 新缓冲区的容量，以 long 为单位
返回：: 新的 long 缓冲区
抛出：: IllegalArgumentException - 如果 capacity 为负整数

wrap

public static LongBuffer wrap(long[] array,
                              int offset,
                              int length)

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

给定 long 数组将支持新缓冲区；即缓冲区修改将导致数组修改，反之亦然。新缓冲区的容量将为 array.length，其位置将为 offset，其界限将为 offset + length，其标记是未定义的。其底层实现数组将为给定数组，并且其数组偏移量将为零。

参数：: array - 支持新缓冲区的数组; offset - 要使用的子数组的偏移量；必须为非负且不大于 array.length。将新缓冲区的位置设置为此值。; length - 要使用的子数组的长度；必须为非负且不大于 array.length - offset。将新缓冲区的界限设置为 offset + length。

返回：

新的 long 缓冲区

抛出：

IndexOutOfBoundsException - 如果关于 offset 和 length 参数的前提不成立

wrap

public static LongBuffer wrap(long[] array)

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

给定 long 数组将支持新缓冲区；即缓冲区修改将导致数组修改，反之亦然。新缓冲区的容量和界限将为 array.length，其位置将为零，其标记是未定义的。其底层实现数组将为给定数组，并且其数组偏移量将为零。

参数：: array - 实现此缓冲区的数组
返回：: 新的 long 缓冲区

slice

public abstract LongBuffer slice()

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

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

新缓冲区的位置将为零，其容量和界限将为此缓冲区中所剩余的 long 数量，其标记是未定义的。当且仅当此缓冲区为直接时，新缓冲区才是直接的，当且仅当此缓冲区为只读时，新缓冲区才是只读的。

返回：: 新的 long 缓冲区

duplicate

public abstract LongBuffer duplicate()

创建共享此缓冲区内容的新的 long 缓冲区。

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

新缓冲区的容量、界限、位置和标记值将与此缓冲区相同。当且仅当此缓冲区为直接时，新缓冲区才是直接的，当且仅当此缓冲区为只读时，新缓冲区才是只读的。

返回：: 新的 long 缓冲区

asReadOnlyBuffer

public abstract LongBuffer asReadOnlyBuffer()

创建共享此缓冲区内容的新的只读 long 缓冲区。

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

新缓冲区的容量、界限、位置和标记值将与此缓冲区相同。

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

返回：: 新的只读 long 缓冲区

get

public abstract long get()

相对 get 方法。读取此缓冲区当前位置的 long，然后该位置递增。

返回：: 缓冲区当前位置的 long
抛出：: BufferUnderflowException - 如果缓冲区当前位置不小于其界限

put

public abstract LongBuffer put(long l)

相对 put 方法（可选操作）。

将给定 long 写入此缓冲区的当前位置，然后该位置递增。

参数：: l - 要写入的 long
返回：: 此缓冲区
抛出：: BufferOverflowException - 如果此缓冲区的当前位置不小于界限; ReadOnlyBufferException - 如果此缓冲区是只读的

get

public abstract long get(int index)

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

参数：: index - 将读取 long 的位置的索引
返回：: 给定索引处的 long
抛出：: IndexOutOfBoundsException - 如果 index 为负或不小于缓冲区界限

put

public abstract LongBuffer put(int index,
                               long l)

绝对 put 方法（可选操作）。

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

参数：: index - 将在该位置写入 long; l - 要写入的 long 值

返回：

此缓冲区

抛出：

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

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

get

public LongBuffer get(long[] dst,
                      int offset,
                      int length)

相对批量 get 方法。

此方法将此缓冲区的 long 传输到给定的目标数组中。如果缓冲区中剩余的 long 少于满足请求所需的 long，即如果 length > remaining()，则不传输 long 且抛出 BufferUnderflowException。

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

换句话说，调用此方法的形式为 src.get(dst, off, len)，效果与以下循环语句完全相同：

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

区别在于它首先检查此缓冲区中是否具有足够的 long，这样可能效率更高。

参数：: dst - 将写入 long 的数组; offset - 要写入的第一个 long 在数组中的偏移量；必须为非负且不大于 dst.length; length - 要写入给定数组中的 long 的最大数量；必须为非负且不大于 dst.length - offset

返回：

此缓冲区

抛出：

BufferUnderflowException - 如果此缓冲区中的剩余 long 少于 length

IndexOutOfBoundsException - 如果关于 offset 和 length 参数的前提不成立

get

public LongBuffer get(long[] dst)

相对批量 get 方法。

此方法将此缓冲区的 long 传输到给定的目标数组中。调用此方法的形式为 src.get(a)，该调用与以下调用完全相同：

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

返回：: 此缓冲区
抛出：: BufferUnderflowException - 如果此缓冲区中的剩余 long 少于 length

put

public LongBuffer put(LongBuffer src)

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

此方法将给定源缓冲区中的剩余 long 传输到此缓冲区中。如果源缓冲区中的剩余 long 多于此缓冲区中的剩余 long 空间，即 src.remaining() > remaining()，则不传输 long 且抛出 BufferOverflowException。

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

换句话说，调用此方法的形式为 dst.put(src)，效果与以下循环语句完全相同：

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

区别在于它首先检查此缓冲区中是否具有足够的空间，这样可能效率更高。

参数：: src - 要从中读取 long 的源缓冲区；不能为此缓冲区
返回：: 此缓冲区
抛出：: BufferOverflowException - 如果对于源缓冲区中剩余的 long，此缓冲区没有足够空间; IllegalArgumentException - 如果源缓冲区是此缓冲区; ReadOnlyBufferException - 如果此缓冲区是只读的

put

public LongBuffer put(long[] src,
                      int offset,
                      int length)

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

此方法将给定源数组中的 long 传输到此缓冲区中。如果要从数组复制的 long 多于此缓冲区中的剩余 long 空间，即如果 length > remaining()，则不传输 long 且抛出 BufferOverflowException。

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

换句话说，调用此方法的形式为 dst.put(src, off, len)，效果与以下循环语句完全相同：

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

区别在于它首先检查此缓冲区中是否具有足够的空间，这样可能效率更高。

参数：: src - 要从中读取 long 的数组; offset - 要读取的第一个 long 在数组中的偏移量；必须为非负且不大于 array.length; length - 要从给定数组读取的 long 数量；必须为非负且不大于 array.length - offset

返回：

此缓冲区

抛出：

BufferOverflowException - 如果此缓冲区没有足够空间

IndexOutOfBoundsException - 如果关于 offset 和 length 参数的前提不成立

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

put

public final LongBuffer put(long[] src)

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

此方法将给定源 long 数组中的所有内容传输到此缓冲区中。调用此方法的形式为 dst.put(a)，该调用与以下调用完全相同：

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

返回：: 此缓冲区
抛出：: BufferOverflowException - 如果此缓冲区没有足够空间; ReadOnlyBufferException - 如果此缓冲区是只读的

hasArray

public final boolean hasArray()

判断是否可通过一个可访问的 long 数组实现此缓冲区。

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

指定者：: 类 Buffer 中的 hasArray

返回：: 当且仅当存在实现此缓冲区的数组，并且此缓冲区不是只读缓冲区时，返回 true

array

public final long[] array()

返回实现此缓冲区的 long 数组（可选操作）。

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

调用此方法之前要调用 hasArray 方法，以确保此缓冲区具有可访问的底层实现数组。

指定者：: 类 Buffer 中的 array

返回：: 实现此缓冲区的数组
抛出：: ReadOnlyBufferException - 如果存在实现此缓冲区的数组，但缓冲区是只读的; UnsupportedOperationException - 如果不存在某个可访问的数组实现此缓冲区

arrayOffset

public final int arrayOffset()

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

如果存在实现此缓冲区的数组，则缓冲区位置 p 对应于数组索引 p + arrayOffset()。

调用此方法之前要调用 hasArray 方法，以确保此缓冲区具有可访问的底层实现数组。

指定者：: 类 Buffer 中的 arrayOffset

返回：: 此缓冲区的第一个元素在缓冲区数组中的偏移量
抛出：: ReadOnlyBufferException - 如果存在实现此缓冲区的数组，但缓冲区是只读的; UnsupportedOperationException - 如果不存在某个可访问的数组实现此缓冲区

compact

public abstract LongBuffer compact()

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

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

将缓冲区的位置设置为复制的 long 的数量，而不是零，以便调用此方法后可以紧接着调用另一个相对 put 方法。

返回：: 此缓冲区
抛出：: ReadOnlyBufferException - 如果此缓冲区是只读的

isDirect

public abstract boolean isDirect()

判断此 long 缓冲区是否为直接的。

指定者：: 类 Buffer 中的 isDirect

返回：: 当且仅当此缓冲区为直接时，返回 true

toString

public String toString()

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

覆盖：: 类 Object 中的 toString

返回：: 一个总结字符串

hashCode

public int hashCode()

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

long 缓冲区的哈希码只取决于其剩余元素；即取决于从 position() 开始一直到（包括）limit() - 1 处的元素。

因为缓冲区哈希码与内容有关，因此建议不要在哈希映射或类似数据结构中将缓冲区用作键，除非知道它们的内容不会发生更改。

覆盖：: 类 Object 中的 hashCode

返回：: 此缓冲区的当前哈希码
另请参见：: Object.equals(java.lang.Object), Hashtable

equals

public boolean equals(Object ob)

判断此缓冲区是否与另一个对象相同。

两个 long 缓冲区是相同的，当且仅当：

它们具有相同的元素类型，
它们具有相同数量的剩余元素，并且
两个剩余元素序列（与它们的起始位置无关）逐点相同。

long 缓冲区与任何其他类型的对象都不同。

覆盖：: 类 Object 中的 equals

参数：: ob - 此缓冲区要比较的对象
返回：: 当且仅当此缓冲区与给定对象相同时，返回 true
另请参见：: Object.hashCode(), Hashtable

compareTo

public int compareTo(LongBuffer that)

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

比较两个 long 缓冲区的方法是按字典顺序比较它们的剩余元素序列，而不考虑每个序列在其对应缓冲区中的起始位置。

long 缓冲区不能与其他类型的对象进行比较。

指定者：: 接口 Comparable<LongBuffer> 中的 compareTo

参数：: that - 要比较的对象。
返回：: 如果此缓冲区小于、等于或大于给定缓冲区，则相应返回负整数、零或正整数

order

public abstract ByteOrder order()

获取此缓冲区的字节顺序。

通过分配或通过包装现有 long 数组而创建的 long 缓冲区的字节顺序是底层硬件的本机顺序。作为字节缓冲区的视图而创建的 long 缓冲区的字节顺序是创建视图时字节缓冲区的字节顺序。

返回：: 此缓冲区的字节顺序

概述

软件包

类

使用

树

已过时

索引

帮助

Java^TM 2 Platform
Standard Ed. 6

上一个类 下一个类

框架 无框架

摘要：嵌套 | 字段 | 构造方法 | 方法

详细信息：字段 | 构造方法 | 方法

提交错误或意见
有关更多的 API 参考资料和开发人员文档，请参阅 Java 2 SDK SE 开发人员文档。该文档包含更详细的、面向开发人员的描述，以及总体概述、术语定义、使用技巧和工作代码示例。

java.nio 类 LongBuffer

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

java.nio
类 LongBuffer