LongBuffer (Java Platform SE 8 )

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

All Implemented Interfaces:

Comparable LongBuffer > <
```
public abstract class LongBuffer
extends Buffer
implements Comparable<LongBuffer>
```
长缓冲区。
这个类定义了长缓冲区上的四类操作：
- 绝对和相对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 LongBuffer`	`allocate(int capacity)` 分配一个新的长缓冲区。
`long[]`	`array()` 返回长阵列，支持这一缓冲（可选操作）。
`int`	`arrayOffset()` 返回在缓冲第一元这个缓冲区支持数组的偏移（可选操作）。
`abstract LongBuffer`	`asReadOnlyBuffer()` 创建一个新的、只读的长缓冲区，共享该缓冲区的内容。
`abstract LongBuffer`	`compact()` 契约这个缓冲区（可选操作）。
`int`	`compareTo(LongBuffer that)` 将此缓冲区与另一缓冲区。
`abstract LongBuffer`	`duplicate()` 创建一个新的长缓冲区，共享该缓冲区的内容。
`boolean`	`equals(Object ob)` 告诉是否这个缓冲区是否等于另一个对象。
`abstract long`	`get()` 相对得到方法。
`abstract long`	`get(int index)` 绝对得到方法。
`LongBuffer`	`get(long[] dst)` 相对体积得到方法。
`LongBuffer`	`get(long[] dst, int offset, int length)` 相对体积得到方法。
`boolean`	`hasArray()` 告诉是否这个缓冲区是由一个可访问的长数组支持的。
`int`	`hashCode()` 返回此缓冲区的当前哈希代码。
`abstract boolean`	`isDirect()` 告诉是否这个长的缓冲区是直接的。
`abstract ByteOrder`	`order()` 检索此缓冲区的字节顺序。
`abstract LongBuffer`	`put(int index, long l)` 绝对放方法（可选操作）。
`abstract LongBuffer`	`put(long l)` 相对放方法（可选操作）。
`LongBuffer`	`put(long[] src)` 相对体积放方法（可选操作）。
`LongBuffer`	`put(long[] src, int offset, int length)` 相对体积放方法（可选操作）。
`LongBuffer`	`put(LongBuffer src)` 相对体积放方法（可选操作）。
`abstract LongBuffer`	`slice()` 创建一个新的长的缓冲其内容是共享的子缓冲区的内容。
`String`	`toString()` 返回一个总结该缓冲区的状态的字符串。
`static LongBuffer`	`wrap(long[] array)` 将一个长数组封装到一个缓冲区中。
`static LongBuffer`	`wrap(long[] 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 LongBuffer allocate(int capacity)
```
    分配一个新的长缓冲区。
    新的缓冲区的位置将是零，它的限制将是它的容量，它的标记将是不确定的，它的每一个元素都将被初始化为零。这将有一个backing array，及其array offset将零。
    
    参数
    
    capacity -新的缓冲区的容量，在渴望
    
    结果
    
    新长缓冲区
    
    异常
    
    IllegalArgumentException -如果 capacity是负整数
  - wrap
```
public static LongBuffer wrap(long[] 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 LongBuffer wrap(long[] array)
```
    将一个长数组封装到一个缓冲区中。
    新的缓冲区将由给定的长数组支持，也就是说，对缓冲区的修改将导致数组进行修改，反之亦然。新的缓冲区的容量和限制将array.length，其位置将为零，其标志将是不确定的。其backing array将给定的数组，并将其array offset>零。
    
    参数
    
    array的阵列，将该缓冲区
    
    结果
    
    新长缓冲区
  - slice
```
public abstract LongBuffer slice()
```
    创建一个新的长的缓冲其内容是共享的子缓冲区的内容。
    新的缓冲区的内容将从这个缓冲区的当前位置开始。这个缓冲区的内容的变化将在新的缓冲区中可见，反之亦然；两个缓冲区的位置，限制和标记值将是独立的。
    
    新的缓冲区的位置将是零，它的容量和它的限制将是在这个缓冲区中的剩余的数量，它的标记将是不确定的。新的缓冲区将是直接的，如果，只有当这个缓冲区是直接的，它将是只读的，只有当，这个缓冲区是只读的。
    
    结果
    
    新长缓冲区
  - duplicate
```
public abstract LongBuffer duplicate()
```
    创建一个新的长缓冲区，共享该缓冲区的内容。
    新的缓冲区的内容将是这个缓冲区的内容。这个缓冲区的内容的变化将在新的缓冲区中可见，反之亦然；两个缓冲区的位置，限制和标记值将是独立的。
    
    新的缓冲区的容量、限制、位置和标记值将与此缓冲区相同。新的缓冲区将是直接的，如果，只有当这个缓冲区是直接的，它将是只读的，只有当，这个缓冲区是只读的。
    
    结果
    
    新长缓冲区
  - asReadOnlyBuffer
```
public abstract LongBuffer asReadOnlyBuffer()
```
    创建一个新的、只读的长缓冲区，共享该缓冲区的内容。
    新的缓冲区的内容将是这个缓冲区的内容。对该缓冲区的内容的更改将在新的缓冲区中可见；但是，新的缓冲区本身将是只读的，不会允许共享内容被修改。这两个缓冲区的位置，限制，和标记值将是独立的。
    
    新的缓冲区的容量、限制、位置和标记值将与此缓冲区相同。
    
    如果这个缓冲区本身是只读那么这个方法的行为一样的duplicate方法。
    
    结果
    
    新的，只读的长缓冲区
  - get
```
public abstract long get()
```
    相对得到方法。读取这个缓冲区的当前位置的长，然后将该位置。
    
    结果
    
    长在缓冲区的当前位置
    
    异常
    
    BufferUnderflowException -如果缓冲区的当前位置不小于其极限
  - put
```
public abstract LongBuffer put(long l)
```
    相对放方法（可选操作）。
    将给定的长到当前位置的缓冲区写入该缓冲区，然后将该位置增量。
    
    参数
    
    l -要写长
    
    结果
    
    这个缓冲区
    
    异常
    
    BufferOverflowException -如果这个缓冲区的当前位置不小于其极限
    
    ReadOnlyBufferException -如果这个缓冲区是只读的
  - get
```
public abstract long get(int index)
```
    绝对得到方法。在给定的索引中读取长的。
    
    参数
    
    index -指数从长期将读
    
    结果
    
    长在给定的指数
    
    异常
    
    IndexOutOfBoundsException -如果 index是负面或不小于缓冲区的限制
  - put
```
public abstract LongBuffer put(int index,
                               long l)
```
    绝对放方法（可选操作）。
    在给定的索引中写入给定的长到该缓冲区中的。
    
    参数
    
    index -指数在长期会写
    
    l -要写长值
    
    结果
    
    这个缓冲区
    
    异常
    
    IndexOutOfBoundsException -如果 index是负面或不小于缓冲区的限制
    
    ReadOnlyBufferException -如果这个缓冲区是只读的
  - get
```
public LongBuffer get(long[] 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 LongBuffer get(long[] dst)
```
    相对体积得到方法。
    这种方法将从这个缓冲区转移到给定的目标数组中。这种形式的src.get(a)方法调用的行为一样，调用
```
SRC。得到（一，0，a.length）
```
    参数
    
    dst -目标数组
    
    结果
    
    这个缓冲区
    
    异常
    
    BufferUnderflowException -如果有少于 length渴望留在这个缓冲区
  - put
```
public LongBuffer put(LongBuffer src)
```
    相对体积放方法（可选操作）。
    此方法将在给定源缓冲区中的多头剩余转换为该缓冲区。如果有更多的渴望留在源缓冲区比这个缓冲区，即如果src.remaining() > remaining()，然后不再转移和BufferOverflowException抛出。
    
    否则，此方法复制N = src.remaining()渴望从给定的缓冲区到缓冲区，开始在每个缓冲区的当前位置。这两个缓冲区的位置，然后加N.
    
    换句话说，这种形式的dst.put(src)方法调用作为循环具有完全相同的效果
```
而（SRC。hasremaining()）DST。把（SRC。get()）；
```
    除外，它首先检查这个缓冲区有足够的空间，这可能是更有效的。
    参数
    
    src -从源缓冲区的渴望要读；不得这个缓冲区
    
    结果
    
    这个缓冲区
    
    异常
    
    BufferOverflowException -如果没有足够的空间在这个缓冲区剩余的渴望在源缓冲区
    
    IllegalArgumentException -如果源缓冲区缓冲区
    
    ReadOnlyBufferException -如果这个缓冲区是只读的
  - put
```
public LongBuffer put(long[] 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 LongBuffer put(long[] 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 long[] 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 LongBuffer 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. 两序列的其余元素，认为是独立的，他们的立场出发，逐点等。
    长缓冲区不等于任何其他类型的对象。
    重写：
    
    equals 方法重写，继承类 Object
    
    参数
    
    ob -对象，这个缓冲区是比较
    
    结果
    
    true如果，如果，这等于给定对象的缓冲区
    
    另请参见：
    
    Object.hashCode()， HashMap
  - compareTo
```
public int compareTo(LongBuffer that)
```
    将此缓冲区与另一缓冲区。
    通过比较两长缓冲区剩余元素的字典序序列相比，不考虑每个序列的起始位置在其相应的缓冲区。对long元素对相比仿佛被调用Long.compare(long,long)。
    
    长缓冲区不与任何其他类型的对象相媲美。
    
    Specified by:
    
    compareTo 接口 Comparable<LongBuffer>
    
    参数
    
    that要比较的对象。
    
    结果
    
    一个负整数，零，或一个正整数，因为这个缓冲区小于，等于或大于给定的缓冲区
  - order
```
public abstract ByteOrder order()
```
    检索此缓冲区的字节顺序。
    一个长的缓冲包装现有的long阵列底层硬件的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 LongBuffer

方法摘要

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