LongBuffer

allocate

LongBuffer allocate (int capacity)

分配一个新的长缓冲区。

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

array

long[] array ()

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

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

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

arrayOffset

int arrayOffset ()

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

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

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

asReadOnlyBuffer

LongBuffer asReadOnlyBuffer ()

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

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

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

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

compact

LongBuffer compact ()

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

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

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

compareTo

int compareTo (LongBuffer that)

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

通过按照字典顺序比较剩余元素的序列来比较两个长缓冲区，而不考虑每个序列在其相应缓冲区内的开始位置。 对long元素进行比较，就好像调用compare(long, long) 。

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

duplicate

LongBuffer duplicate ()

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

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

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

equals

boolean equals (Object ob)

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

两个长缓冲区相等，当且仅当，

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

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

3. 独立于其起始位置考虑的剩余元素的两个序列是逐点相等的。

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

get

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

相对批量 获取方法。

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

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

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

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

get

LongBuffer get (long[] dst)

相对批量 获取方法。

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

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

get

long get ()

相对获得方法。 在此缓冲区的当前位置读取长整数，然后递增该位置。

get

long get (int index)

绝对get方法。 在指定的索引处读取长整数。

hasArray

boolean hasArray ()

告诉这个缓冲区是否由一个可访问的长阵列支持。

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

hashCode

int hashCode ()

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

长缓冲区的哈希码仅取决于其余的元素; 也就是说，从position()到元素limit() - 1的元素。

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

isDirect

boolean isDirect ()

Tells whether or not this long buffer is direct.

order

ByteOrder order ()

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

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

put

LongBuffer put (long l)

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

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

put

LongBuffer put (LongBuffer src)

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

此方法将剩余在给定源缓冲区中的长整型转移到此缓冲区中。 如果源缓冲区中剩余的长度超过此缓冲区中的长度，也就是说，如果src.remaining() > remaining() ，则不传输长BufferOverflowException并且抛出BufferOverflowException 。

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

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

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

put

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

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

此方法将long从给定的源数组传递到此缓冲区。 如果从阵列中复制的剩余 长度多于保留在此缓冲区中的长度，也就是说，如果length > remaining() ，则不传输长BufferOverflowException并且抛出BufferOverflowException 。

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

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

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

put

LongBuffer put (int index, 
                long l)

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

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

put

LongBuffer put (long[] src)

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

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

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

slice

LongBuffer slice ()

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

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

新缓冲区的位置将为零，其容量和限制将是此缓冲区中剩余长度的数量，其标记将是未定义的。 当且仅当此缓冲区是直接的时，新缓冲区才是直接的，并且只有在此缓冲区是只读的情况下，它才会是只读的。

toString

String toString ()

Returns a string summarizing the state of this buffer.

wrap

LongBuffer wrap (long[] array)

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

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

wrap

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

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

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