IntBuffer (Java Platform SE 8 )

java.lang.Object
- java.nio.Buffer
- - java.nio.IntBuffer

All Implemented Interfaces:

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

像一个字节的缓冲区，缓冲区是direct or non-direct int。一个int缓冲区通过创建这个类的wrap方法将非直接。一个int类型的缓冲区创建为一个字节的缓冲区将直接如果，仅仅是如果，这本身就是直接字节缓冲区。是否一个int缓冲区是直接可以通过调用isDirect法测定。

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

一点四

方法摘要

所有方法静态方法接口方法抽象方法具体的方法
Modifier and Type	Method and Description
`static IntBuffer`	`allocate(int capacity)` 分配一个新的int缓冲。
`int[]`	`array()` 返回数组的缓冲区，支持这（可选操作）。
`int`	`arrayOffset()` 返回在缓冲第一元这个缓冲区支持数组的偏移（可选操作）。
`abstract IntBuffer`	`asReadOnlyBuffer()` 创建一个新的只读缓冲区，缓冲区在股份的内容。
`abstract IntBuffer`	`compact()` 契约这个缓冲区（可选操作）。
`int`	`compareTo(IntBuffer that)` 将此缓冲区与另一缓冲区。
`abstract IntBuffer`	`duplicate()` 创建一个新的诠释，这股缓冲区的内容缓存。
`boolean`	`equals(Object ob)` 告诉是否这个缓冲区是否等于另一个对象。
`abstract int`	`get()` 相对得到方法。
`abstract int`	`get(int index)` 绝对得到方法。
`IntBuffer`	`get(int[] dst)` 相对体积得到方法。
`IntBuffer`	`get(int[] dst, int offset, int length)` 相对体积得到方法。
`boolean`	`hasArray()` 告诉是否这个缓冲区是访问数组的支持。
`int`	`hashCode()` 返回此缓冲区的当前哈希代码。
`abstract boolean`	`isDirect()` 告诉这是否在缓冲区是直接的。
`abstract ByteOrder`	`order()` 检索此缓冲区的字节顺序。
`abstract IntBuffer`	`put(int i)` 相对放方法（可选操作）。
`IntBuffer`	`put(int[] src)` 相对体积放方法（可选操作）。
`IntBuffer`	`put(int[] src, int offset, int length)` 相对体积放方法（可选操作）。
`IntBuffer`	`put(IntBuffer src)` 相对体积放方法（可选操作）。
`abstract IntBuffer`	`put(int index, int i)` 绝对放方法（可选操作）。
`abstract IntBuffer`	`slice()` 创建一个新的int缓冲其内容是共享的子缓冲区的内容。
`String`	`toString()` 返回一个总结该缓冲区的状态的字符串。
`static IntBuffer`	`wrap(int[] array)` 把一个int数组读入缓冲区。
`static IntBuffer`	`wrap(int[] array, int offset, int length)` 把一个int数组读入缓冲区。

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 IntBuffer allocate(int capacity)
```
    分配一个新的int缓冲。
    新的缓冲区的位置将是零，它的限制将是它的容量，它的标记将是不确定的，它的每一个元素都将被初始化为零。这将有一个backing array，及其array offset将零。
    
    参数
    
    capacity -新的缓冲区的容量，在整数
    
    结果
    
    新的缓冲指针
    
    异常
    
    IllegalArgumentException -如果 capacity是负整数
  - wrap
```
public static IntBuffer wrap(int[] array,
                             int offset,
                             int length)
```
    把一个int数组读入缓冲区。
    新的缓冲区将被给定的数组的支持；即缓冲区的修改会导致阵列进行修改，反之亦然。新的缓冲区的容量将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 IntBuffer wrap(int[] array)
```
    把一个int数组读入缓冲区。
    新的缓冲区将被给定的数组的支持；即缓冲区的修改会导致阵列进行修改，反之亦然。新的缓冲区的容量和限制将array.length，其位置将为零，其标志将是不确定的。其backing array将给定的数组，并将其array offset>零。
    
    参数
    
    array的阵列，将该缓冲区
    
    结果
    
    新的缓冲指针
  - slice
```
public abstract IntBuffer slice()
```
    创建一个新的int缓冲其内容是共享的子缓冲区的内容。
    新的缓冲区的内容将从这个缓冲区的当前位置开始。这个缓冲区的内容的变化将在新的缓冲区中可见，反之亦然；两个缓冲区的位置，限制和标记值将是独立的。
    
    新缓冲区的位置将为零，其容量和限制将留在这个缓冲区对象的数量，其标志将是不确定的。新的缓冲区将是直接的，如果，只有当这个缓冲区是直接的，它将是只读的，只有当，这个缓冲区是只读的。
    
    结果
    
    新的缓冲指针
  - duplicate
```
public abstract IntBuffer duplicate()
```
    创建一个新的诠释，这股缓冲区的内容缓存。
    新的缓冲区的内容将是这个缓冲区的内容。这个缓冲区的内容的变化将在新的缓冲区中可见，反之亦然；两个缓冲区的位置，限制和标记值将是独立的。
    
    新的缓冲区的容量、限制、位置和标记值将与此缓冲区相同。新的缓冲区将是直接的，如果，只有当这个缓冲区是直接的，它将是只读的，只有当，这个缓冲区是只读的。
    
    结果
    
    新的缓冲指针
  - asReadOnlyBuffer
```
public abstract IntBuffer asReadOnlyBuffer()
```
    创建一个新的只读缓冲区，缓冲区在股份的内容。
    新的缓冲区的内容将是这个缓冲区的内容。对该缓冲区的内容的更改将在新的缓冲区中可见；但是，新的缓冲区本身将是只读的，不会允许共享内容被修改。这两个缓冲区的位置，限制，和标记值将是独立的。
    
    新的缓冲区的容量、限制、位置和标记值将与此缓冲区相同。
    
    如果这个缓冲区本身是只读那么这个方法的行为一样的duplicate方法。
    
    结果
    
    新的，只读缓冲指针
  - get
```
public abstract int get()
```
    相对得到方法。读取这个缓冲区的当前位置的整数，然后增量的位置。
    
    结果
    
    在缓冲区中的当前位置的int
    
    异常
    
    BufferUnderflowException -如果缓冲区的当前位置不小于其极限
  - put
```
public abstract IntBuffer put(int i)
```
    相对放方法（可选操作）。
    写入给定的int到缓冲区的当前位置，然后将位置。
    
    参数
    
    i - int要写
    
    结果
    
    这个缓冲区
    
    异常
    
    BufferOverflowException -如果这个缓冲区的当前位置不小于其极限
    
    ReadOnlyBufferException -如果这个缓冲区是只读的
  - get
```
public abstract int get(int index)
```
    绝对得到方法。读取给定索引处的int。
    
    参数
    
    index -指数从int会读
    
    结果
    
    给定索引处的int
    
    异常
    
    IndexOutOfBoundsException -如果 index是负面或不小于缓冲区的限制
  - put
```
public abstract IntBuffer put(int index,
                              int i)
```
    绝对放方法（可选操作）。
    写入给定的int到缓冲区在给定的索引。
    
    参数
    
    index -指数在int会写
    
    i -要写入的int值
    
    结果
    
    这个缓冲区
    
    异常
    
    IndexOutOfBoundsException -如果 index是负面或不小于缓冲区的限制
    
    ReadOnlyBufferException -如果这个缓冲区是只读的
  - get
```
public IntBuffer get(int[] dst,
                     int offset,
                     int length)
```
    相对体积得到方法。
    这种方法将对象从这个缓冲区到给定的目标数组。如果有较少的整数留在缓冲区比需要满足的要求，那就是，如果length > remaining()，然后没有int转移和BufferUnderflowException抛出。
    
    否则，此方法复制length整数从这个缓冲区到给定的数组，从这个缓冲区的当前位置和在给定的数组中的偏移量。这个缓冲区的位置，再加length。
    
    换句话说，这种形式的src.get(dst, off, len)方法调用作为循环具有完全相同的效果
```
     for (int i = off; i < off + len; i++)
         dst[i] = src.get():
 
```
    除外，它首先检查这个缓冲区有足够的整数，它可能是更有效的。
    参数
    
    dst -数组为int要写
    
    offset -偏移中第一个int数组要写；必须是非负的且不大于 dst.length
    
    length -整数的最大数量被写入给定的数组；必须是非负的且不大于 dst.length - offset
    
    结果
    
    这个缓冲区
    
    异常
    
    BufferUnderflowException -如果有少于 length整数剩余在这个缓冲区
    
    IndexOutOfBoundsException -如果在 offset和 length参数的前提条件不成立
  - get
```
public IntBuffer get(int[] dst)
```
    相对体积得到方法。
    这种方法将对象从这个缓冲区到给定的目标数组。这种形式的src.get(a)方法调用的行为一样，调用
```
SRC。得到（一，0，a.length）
```
    参数
    
    dst -目标数组
    
    结果
    
    这个缓冲区
    
    异常
    
    BufferUnderflowException -如果有少于 length整数剩余在这个缓冲区
  - put
```
public IntBuffer put(IntBuffer src)
```
    相对体积放方法（可选操作）。
    该方法将所有剩余的在给定的源缓冲区到缓冲区。如果有更多的元素，保留在源缓冲区比这个缓冲区，即如果src.remaining() > remaining()，然后没有int转移和BufferOverflowException抛出。
    
    否则，此方法复制N = src.remaining() int值从给定的缓冲区到缓冲区，开始在每个缓冲区的当前位置。这两个缓冲区的位置，然后加N.
    
    换句话说，这种形式的dst.put(src)方法调用作为循环具有完全相同的效果
```
而（SRC。hasremaining()）DST。把（SRC。get()）；
```
    除外，它首先检查这个缓冲区有足够的空间，这可能是更有效的。
    参数
    
    src -源缓冲区从int来阅读；不得这个缓冲区
    
    结果
    
    这个缓冲区
    
    异常
    
    BufferOverflowException -如果没有足够的空间在这个缓冲区在源缓冲区剩余的整数
    
    IllegalArgumentException -如果源缓冲区缓冲区
    
    ReadOnlyBufferException -如果这个缓冲区是只读的
  - put
```
public IntBuffer put(int[] src,
                     int offset,
                     int length)
```
    相对体积放方法（可选操作）。
    这种方法将整数到缓冲区从给定的源阵列。如果有更多的元素被复制从阵列比保持在这个缓冲区，即如果length > remaining()，然后没有int转移和BufferOverflowException抛出。
    
    否则，此方法复制length整数从给定的数组到缓冲区，从给定的数组中，该缓冲区的当前位置偏移。这个缓冲区的位置，再加length。
    
    换句话说，这种形式的dst.put(src, off, len)方法调用作为循环具有完全相同的效果
```
     for (int i = off; i < off + len; i++)
         dst.put(a[i]);
 
```
    除外，它首先检查这个缓冲区有足够的空间，这可能是更有效的。
    参数
    
    src -数组，int是读
    
    offset -偏移中第一个int数组读入；必须是非负的且不大于 array.length
    
    length -整数的数目可以从给定的数组中读取的；必须是非负的且不大于 array.length - offset
    
    结果
    
    这个缓冲区
    
    异常
    
    BufferOverflowException -如果在这个缓冲区中没有足够的空间
    
    IndexOutOfBoundsException -如果在 offset和 length参数的前提条件不成立
    
    ReadOnlyBufferException -如果这个缓冲区是只读的
  - put
```
public final IntBuffer put(int[] 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 int[] 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 IntBuffer compact()
```
    契约这个缓冲区（可选操作）。
    整数缓冲区的当前位置和极限，如果有的话，复制到缓冲区的开始。那就是，在指数P = position() int是复制指数为零，在指数P + 1 int是复制指数，等等，直到指数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()
```
    返回此缓冲区的当前哈希代码。
    一个int缓冲的哈希代码仅取决于其剩余的元素；即在元素position()最多，并包括在limit() - 1元素。
    
    因为缓冲哈希码内容相关的，它是利用缓冲区作为哈希表或类似数据结构键不可取的除非它是已知的，他们的内容将不会被改变。
    
    重写：
    
    hashCode 方法重写，继承类 Object
    
    结果
    
    此缓冲区的当前哈希代码
    
    另请参见：
    
    Object.equals(java.lang.Object)， System.identityHashCode(java.lang.Object)
  - equals
```
public boolean equals(Object ob)
```
    告诉是否这个缓冲区是否等于另一个对象。
    两个int型缓冲器是平等的如果，只要，
    1. 他们有相同的元素类型，
    2. 他们有相同数量的剩余元素，和
    3. 两序列的其余元素，认为是独立的，他们的立场出发，逐点等。
    一个int缓冲不等于任何其他类型的对象。
    重写：
    
    equals 方法重写，继承类 Object
    
    参数
    
    ob -对象，这个缓冲区是比较
    
    结果
    
    true如果，如果，这等于给定对象的缓冲区
    
    另请参见：
    
    Object.hashCode()， HashMap
  - compareTo
```
public int compareTo(IntBuffer that)
```
    将此缓冲区与另一缓冲区。
    通过比较两个int缓冲区剩余元素的字典序序列相比，不考虑每个序列的起始位置在其相应的缓冲区。对int元素对相比仿佛被调用Integer.compare(int,int)。
    
    一个int缓冲区不与任何其他类型的对象。
    
    Specified by:
    
    compareTo 接口 Comparable<IntBuffer>
    
    参数
    
    that要比较的对象。
    
    结果
    
    一个负整数，零，或一个正整数，因为这个缓冲区小于，等于或大于给定的缓冲区
  - order
```
public abstract ByteOrder order()
```
    检索此缓冲区的字节顺序。
    一个int缓冲包装现有的int阵列底层硬件的native order分配或创建的字节顺序。字节顺序一个int缓冲区创建一个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 IntBuffer

方法摘要

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