public abstract class ByteBuffer extends Buffer implements Comparable<ByteBuffer>
这个类定义了字节缓冲区中的六类操作:
相对bulk get
方法传输连续的字节序列从这个缓冲区数组;
相对bulk put
方法传输连续的字节序列从一个字节数组或其他一些字节缓冲区到缓冲区;
创建视图缓冲区的方法,它允许一个字节缓冲区被视为一个包含其他一些原始类型的值的缓冲区;和
对于compacting
,duplicating
方法,和slicing
字节缓冲区。
字节缓冲区可以创建由allocation
,分配的缓冲区的内容空间,或wrapping
现有的字节数组读入缓冲区。
一个字节的缓冲区是直接的或非直接。给定一个直接字节缓冲区,java虚拟机将尽最大努力完成本地I/O操作直接在其。也就是说,它将试图避免复制缓冲区的内容(或从)一个中间缓冲区之前(或之后)每次调用的底层操作系统的原生I / O操作。
直接字节缓冲区可以通过调用该类的allocateDirect
工厂方法创建。此方法返回的缓冲区通常比非直接缓冲区的分配和释放成本有点高。直接缓冲区的内容可能驻留在正常的垃圾收集堆之外,因此它们对应用程序内存占用的影响可能不明显。因此,建议直接分配的直接缓冲器主要用于大型,长寿命的缓冲区,是受底层系统的原生I / O操作。一般来说这是最好的分配直接缓冲区只有当他们屈服在程序性能的增益。
直接字节缓冲区也可以通过mapping
区域文件直接进入内存。java平台的一个实现可以支持直接字节缓冲区从本地代码中创建通过JNI。如果这些类型的缓冲区中的一个实例是指一个无法访问的区域的内存,然后试图访问该区域将不会改变缓冲区的内容,并会导致一个未指定的异常被抛出在访问的时间或在稍后的时间。
无论是直接或非直接字节缓冲区可以通过调用其isDirect
法测定。此方法提供了这样的显式缓冲区管理,可以在性能关键代码。
这个类定义了阅读和写作的所有其他原始类型的值的方法,除了boolean。原始值转换为(或)根据缓冲区的当前字节顺序的字节序列,可以检索并通过order
方法改进。特定的字节顺序是由ByteOrder
类的实例表示。一个字节缓冲区的初始顺序总是BIG_ENDIAN
。
访问异构的二进制数据,即对不同类型的值的序列,这个类定义了一系列的绝对和相对的每种类型得到和放方法。对于32位浮点值,例如,这个类定义:
floatgetFloat()
floatgetFloat(int index)
voidputFloat(float f)
voidputFloat(int index, float f)
相应的方法是char定义类型,short,int,long,和double。绝对的得到放方法和指标参数是以字节而不是类型正在读或写。
为了获得均匀的二进制数据,即相同类型的值的序列,这类定义的方法可以创建意见给定字节缓冲区。一个视图缓冲区只是另一个缓冲区的内容是由字节缓冲区支持。对字节缓冲区的内容的更改将在视图缓冲区中可见,反之亦然;两个缓冲区的位置、限制和标记值是独立的。例如,asFloatBuffer
方法,创建一个实例的FloatBuffer
类,是由字节缓冲区的方法被调用。相应的视图创建方法的类型char,定义short,int,long,和double。
视图缓冲区有特定类型的得到和放方法上述三科的重要优势:
视图缓冲区的索引不是以字节为单位的,而是根据它的值的类型特定大小来进行索引的;
视图缓冲区提供了相对体积得到和放方法可以转移缓冲数组或同类型的其他一些缓冲的值之间连续的序列;和
视图缓冲区是潜在的更有效的,因为它将是直接的,如果,只有当它的支持字节缓冲区是直接的。
视图缓冲区的字节顺序是固定的,它是在创建视图时它的字节缓冲区的顺序的。
在这个类中,不以其他方式有一个返回的值被指定返回它们被调用的缓冲区。这允许方法调用被。语句序列
可以,例如,由单个语句bb.putInt(0xCAFEBABE); bb.putShort(3); bb.putShort(45);
取代bb.putInt(0xCAFEBABE).putShort(3).putShort(45);
Modifier and Type | Method and Description |
---|---|
static ByteBuffer |
allocate(int capacity)
分配一个新的字节缓冲区。
|
static ByteBuffer |
allocateDirect(int capacity)
分配一个新的直接字节缓冲区。
|
byte[] |
array()
返回的字节数组,支持这个缓冲区 (可选操作)。
|
int |
arrayOffset()
返回在缓冲 第一元这个缓冲区支持数组的偏移(可选操作)。
|
abstract CharBuffer |
asCharBuffer()
创建这个字节缓冲区的视图作为一个字符缓冲区。
|
abstract DoubleBuffer |
asDoubleBuffer()
创建此字节缓冲区的一个双缓冲区。
|
abstract FloatBuffer |
asFloatBuffer()
创建这个字节缓冲区的一个视图作为浮动缓冲区。
|
abstract IntBuffer |
asIntBuffer()
创建此字节缓冲区的视图作为int缓冲。
|
abstract LongBuffer |
asLongBuffer()
创建此字节缓冲区的一个视图,作为一个长缓冲区。
|
abstract ByteBuffer |
asReadOnlyBuffer()
创建一个新的只读字节缓冲区,该缓冲区共享该缓冲区的内容。
|
abstract ShortBuffer |
asShortBuffer()
创建此字节缓冲区的一个缓冲区,作为一个缓冲区。
|
abstract ByteBuffer |
compact()
契约这个缓冲区 (可选操作)。
|
int |
compareTo(ByteBuffer that)
将此缓冲区与另一缓冲区。
|
abstract ByteBuffer |
duplicate()
创建一个新的字节缓冲区,共享该缓冲区的内容。
|
boolean |
equals(Object ob)
告诉是否这个缓冲区是否等于另一个对象。
|
abstract byte |
get()
相对得到方法。
|
ByteBuffer |
get(byte[] dst)
相对体积得到方法。
|
ByteBuffer |
get(byte[] dst, int offset, int length)
相对体积得到方法。
|
abstract byte |
get(int index)
绝对得到方法。
|
abstract char |
getChar()
阅读一个char值相对得到方法。
|
abstract char |
getChar(int index)
阅读一个char值绝对得到方法。
|
abstract double |
getDouble()
阅读一双价值相对得到方法。
|
abstract double |
getDouble(int index)
阅读一双价值绝对得到方法。
|
abstract float |
getFloat()
阅读一个float值相对得到方法。
|
abstract float |
getFloat(int index)
阅读一个float值绝对得到方法。
|
abstract int |
getInt()
阅读一个int值的相对得到方法。
|
abstract int |
getInt(int index)
阅读一个int值的绝对得到方法。
|
abstract long |
getLong()
阅读长值相对得到方法。
|
abstract long |
getLong(int index)
阅读长值绝对得到方法。
|
abstract short |
getShort()
阅读短值相对得到方法。
|
abstract short |
getShort(int index)
阅读短值绝对得到方法。
|
boolean |
hasArray()
告诉是否这个缓冲区是由一个可访问的字节数组所支持的。
|
int |
hashCode()
返回此缓冲区的当前哈希代码。
|
abstract boolean |
isDirect()
告诉是否这个字节缓冲区是直接的。
|
ByteOrder |
order()
检索此缓冲区的字节顺序。
|
ByteBuffer |
order(ByteOrder bo)
修改此缓冲区的字节顺序。
|
abstract ByteBuffer |
put(byte b)
相对放方法 (可选操作)。
|
ByteBuffer |
put(byte[] src)
相对体积放方法 (可选操作)。
|
ByteBuffer |
put(byte[] src, int offset, int length)
相对体积放方法 (可选操作)。
|
ByteBuffer |
put(ByteBuffer src)
相对体积放方法 (可选操作)。
|
abstract ByteBuffer |
put(int index, byte b)
绝对放方法 (可选操作)。
|
abstract ByteBuffer |
putChar(char value)
写一个char值 相对放方法(可选操作)。
|
abstract ByteBuffer |
putChar(int index, char value)
写一个char值 绝对放方法(可选操作)。
|
abstract ByteBuffer |
putDouble(double value)
一个写作的双重价值 相对放方法(可选操作)。
|
abstract ByteBuffer |
putDouble(int index, double value)
一个写作的双重价值 绝对放方法(可选操作)。
|
abstract ByteBuffer |
putFloat(float value)
写一个float值 相对放方法(可选操作)。
|
abstract ByteBuffer |
putFloat(int index, float value)
写一个float值 绝对放方法(可选操作)。
|
abstract ByteBuffer |
putInt(int value)
写一个int值 相对放方法(可选操作)。
|
abstract ByteBuffer |
putInt(int index, int value)
写一个int值 绝对放方法(可选操作)。
|
abstract ByteBuffer |
putLong(int index, long value)
写长值 绝对放方法(可选操作)。
|
abstract ByteBuffer |
putLong(long value)
写长值 相对放方法(可选操作)。
|
abstract ByteBuffer |
putShort(int index, short value)
写一个短的价值 绝对放方法(可选操作)。
|
abstract ByteBuffer |
putShort(short value)
写一个短的价值 相对放方法(可选操作)。
|
abstract ByteBuffer |
slice()
创建一个新的字节缓冲区的内容是一个共享的子缓冲区的内容。
|
String |
toString()
返回一个总结该缓冲区的状态的字符串。
|
static ByteBuffer |
wrap(byte[] array)
将一个字节数组封装到一个缓冲区中。
|
static ByteBuffer |
wrap(byte[] array, int offset, int length)
将一个字节数组封装到一个缓冲区中。
|
public static ByteBuffer allocateDirect(int capacity)
新的缓冲区的位置将是零,它的限制将是它的容量,它的标记将是不确定的,它的每一个元素都将被初始化为零。是否有backing array
不详。
capacity
-新的缓冲容量,以字节为单位
IllegalArgumentException
-如果
capacity是负整数
public static ByteBuffer allocate(int capacity)
新的缓冲区的位置将是零,它的限制将是它的容量,它的标记将是不确定的,它的每一个元素都将被初始化为零。这将有一个backing array
,及其array offset
将零。
capacity
-新的缓冲容量,以字节为单位
IllegalArgumentException
-如果
capacity是负整数
public static ByteBuffer wrap(byte[] 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参数的前提条件不成立
public static ByteBuffer wrap(byte[] array)
新的缓冲区将由给定的字节数组支持;也就是说,对缓冲区的修改将导致数组进行修改,反之亦然。新的缓冲区的容量和限制将array.length,其位置将为零,其标志将是不确定的。其backing array
将给定的数组,并将其array offset>
零。
array
的阵列,将该缓冲区
public abstract ByteBuffer slice()
新的缓冲区的内容将从这个缓冲区的当前位置开始。这个缓冲区的内容的变化将在新的缓冲区中可见,反之亦然;两个缓冲区的位置,限制和标记值将是独立的。
新的缓冲区的位置将为零,它的容量和它的限制将是在这个缓冲区中剩余的字节数,它的标记将是不确定的。新的缓冲区将是直接的,如果,只有当这个缓冲区是直接的,它将是只读的,只有当,这个缓冲区是只读的。
public abstract ByteBuffer duplicate()
新的缓冲区的内容将是这个缓冲区的内容。这个缓冲区的内容的变化将在新的缓冲区中可见,反之亦然;两个缓冲区的位置,限制和标记值将是独立的。
新的缓冲区的容量、限制、位置和标记值将与此缓冲区相同。新的缓冲区将是直接的,如果,只有当这个缓冲区是直接的,它将是只读的,只有当,这个缓冲区是只读的。
public abstract ByteBuffer asReadOnlyBuffer()
新的缓冲区的内容将是这个缓冲区的内容。对该缓冲区的内容的更改将在新的缓冲区中可见;但是,新的缓冲区本身将是只读的,不会允许共享内容被修改。这两个缓冲区的位置,限制,和标记值将是独立的。
新的缓冲区的容量、限制、位置和标记值将与此缓冲区相同。
如果这个缓冲区本身是只读那么这个方法的行为一样的duplicate
方法。
public abstract byte get()
BufferUnderflowException
-如果缓冲区的当前位置不小于其极限
public abstract ByteBuffer put(byte b)
将指定的字节写入当前位置的缓冲区中,然后将该位置增量。
b
的字节被写入
BufferOverflowException
-如果这个缓冲区的当前位置不小于其极限
ReadOnlyBufferException
-如果这个缓冲区是只读的
public abstract byte get(int index)
index
-指数从该字节被读取
IndexOutOfBoundsException
-如果
index是负面或不小于缓冲区的限制
public abstract ByteBuffer put(int index, byte b)
在给定的索引处将给定的字节写入该缓冲区中。
index
-索引的字节将被写入
b
-要写入的字节值
IndexOutOfBoundsException
-如果
index是负面或不小于缓冲区的限制
ReadOnlyBufferException
-如果这个缓冲区是只读的
public ByteBuffer get(byte[] 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参数的前提条件不成立
public ByteBuffer get(byte[] dst)
此方法将此缓冲区传输到给定的目标数组中的字节数。这种形式的src.get(a)方法调用的行为一样,调用
SRC。得到(一,0,a.length)
dst
-目标数组
BufferUnderflowException
-如果有少于
length字节留在这个缓冲区
public ByteBuffer put(ByteBuffer src)
此方法将在给定源缓冲区中的字节转移到该缓冲区中。如果有多个字节中剩余的源缓冲区比这个缓冲区,即如果src.remaining() > remaining(),然后没有字节传输和BufferOverflowException
抛出。
否则,此方法复制N = src.remaining()字节从给定的缓冲区到缓冲区,开始在每个缓冲区的当前位置。这两个缓冲区的位置,然后加N.
换句话说,这种形式的dst.put(src)方法调用作为循环具有完全相同的效果
而(SRC。hasremaining())DST。把(SRC。get());除外,它首先检查这个缓冲区有足够的空间,这可能是更有效的。
src
-源缓冲区字节被读取;不得这个缓冲区
BufferOverflowException
-如果没有足够的空间在这个缓冲区在源缓冲区剩余字节
IllegalArgumentException
-如果源缓冲区缓冲区
ReadOnlyBufferException
-如果这个缓冲区是只读的
public ByteBuffer put(byte[] 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
-如果这个缓冲区是只读的
public final ByteBuffer put(byte[] src)
此方法将给定的源字节数组的整个内容转移到这个缓冲区中。这种形式的dst.put(a)方法调用的行为一样,调用
DST。把(一,0,a.length)
src
-源阵列
BufferOverflowException
-如果在这个缓冲区中没有足够的空间
ReadOnlyBufferException
-如果这个缓冲区是只读的
public final boolean hasArray()
如果此方法返回true然后array
和arrayOffset
方法可以被调用。
public final byte[] array()
此缓冲区的内容的修改将导致返回的数组的内容进行修改,反之亦然。
调用hasArray
方法调用该方法以确保缓冲区有一个可访问的支持,前阵。
array
方法重写,继承类
Buffer
ReadOnlyBufferException
-如果这个缓冲区有一个数组不过是只读的
UnsupportedOperationException
-如果这个缓冲区不是由访问阵列支持
public final int arrayOffset()
如果这个缓冲区是一个数组缓冲区位置P对应的数组索引P + arrayOffset()支持。
调用hasArray
方法调用该方法以确保缓冲区有一个可访问的支持,前阵。
arrayOffset
方法重写,继承类
Buffer
ReadOnlyBufferException
-如果这个缓冲区有一个数组不过是只读的
UnsupportedOperationException
-如果这个缓冲区不是由访问阵列支持
public abstract ByteBuffer compact()
缓冲区当前位置和它的极限之间的字节数,如果有的话,被复制到缓冲区的开始。那就是,在指数P = position()字节复制到指数为零,在指数P + 1字节复制到指数,等等,直到指数limit() - 1字节复制到指数n = limit() - 1 - P.缓冲区的位置,然后设置为n + 1的限制设置为它的能力。标记,如果定义,将被丢弃。
缓冲区的位置设置为字节拷贝数,而不是零,所以,此方法的调用可以紧接着另一个相对放方法调用。
在从缓冲区中写入数据后,调用此方法,以写不完整。下面的循环,例如,拷贝字节从一个通道到另一个通过缓冲buf:
buf.clear(); // Prepare buffer for use while (in.read(buf) >= 0 || buf.position != 0) { buf.flip(); out.write(buf); buf.compact(); // In case of partial write }
ReadOnlyBufferException
-如果这个缓冲区是只读的
public abstract boolean isDirect()
public int hashCode()
一个字节缓冲区的哈希代码仅取决于其剩余的元素;即,在从position()最多,元素,包括在limit() - 1元素。
因为缓冲哈希码内容相关的,它是利用缓冲区作为哈希表或类似数据结构键不可取的除非它是已知的,他们的内容将不会被改变。
hashCode
方法重写,继承类
Object
Object.equals(java.lang.Object)
,
System.identityHashCode(java.lang.Object)
public boolean equals(Object ob)
两个字节的缓冲区是相等的,如果,只有如果,
他们有相同的元素类型,
他们有相同数量的剩余元素,和
两序列的其余元素,认为是独立的,他们的立场出发,逐点等。
字节缓冲区不等于任何其他类型的对象。
equals
方法重写,继承类
Object
ob
-对象,这个缓冲区是比较
Object.hashCode()
,
HashMap
public int compareTo(ByteBuffer that)
通过比较两字节缓冲区剩余元素的字典序序列相比,不考虑每个序列的起始位置在其相应的缓冲区。对byte
元素对相比仿佛被调用Byte.compare(byte,byte)
。
字节缓冲区不与任何其他类型的对象相媲美。
compareTo
接口
Comparable<ByteBuffer>
that
要比较的对象。
public final ByteOrder order()
字节顺序是用来读取或写入字节值时,创建的缓冲区,这个字节缓冲区的视图时。一个新创建的字节缓冲区的顺序总是BIG_ENDIAN
。
public final ByteBuffer order(ByteOrder bo)
bo
-新的字节顺序,要么
BIG_ENDIAN
或
LITTLE_ENDIAN
public abstract char getChar()
读取当前缓冲区当前位置的下两个字节,并根据当前的字节顺序将它们组合成一个字符值,然后通过两个。
BufferUnderflowException
-如果有少于两字节中剩余的缓冲区
public abstract ByteBuffer putChar(char value)
写入包含给定的字符值的两个字节,在当前的字节顺序中,在当前位置进入该缓冲区,然后由两个位置增量。
value
-要写入的字符值
BufferOverflowException
-如果有少于两字节中剩余的缓冲区
ReadOnlyBufferException
-如果这个缓冲区是只读的
public abstract char getChar(int index)
在指定的索引处读取两个字节,根据当前的字节顺序将它们组合成一个字符值。
index
-索引的字节将被读取
IndexOutOfBoundsException
-如果
index是负面或不小于缓冲区的限制,减一
public abstract ByteBuffer putChar(int index, char value)
写入包含给定的字符值的两个字节,在当前字节顺序中,在给定索引处进入该缓冲区中。
index
的指标,将被写入字节
value
-要写入的字符值
IndexOutOfBoundsException
-如果
index是负面或不小于缓冲区的限制,减一
ReadOnlyBufferException
-如果这个缓冲区是只读的
public abstract CharBuffer asCharBuffer()
新的缓冲区的内容将从这个缓冲区的当前位置开始。这个缓冲区的内容的变化将在新的缓冲区中可见,反之亦然;两个缓冲区的位置,限制和标记值将是独立的。
新的缓冲区的位置将是零,它的容量和它的限制将是在这个缓冲区除以两个字节的数量,它的标记将是不确定的。新的缓冲区将是直接的,如果,只有当这个缓冲区是直接的,它将是只读的,只有当,这个缓冲区是只读的。
public abstract short getShort()
读取当前缓冲区当前位置的下两个字节,根据当前字节顺序将它们组合成一个很短的值,然后通过两个。
BufferUnderflowException
-如果有少于两字节中剩余的缓冲区
public abstract ByteBuffer putShort(short value)
写入包含给定的短值的两个字节,在当前字节顺序中,到当前位置的这个缓冲区,然后通过两个增量位置。
value
-写短的价值
BufferOverflowException
-如果有少于两字节中剩余的缓冲区
ReadOnlyBufferException
-如果这个缓冲区是只读的
public abstract short getShort(int index)
在给定的索引中读取两个字节,根据当前的字节顺序将它们组合成一个短值。
index
-索引的字节将被读取
IndexOutOfBoundsException
-如果
index是负面或不小于缓冲区的限制,减一
public abstract ByteBuffer putShort(int index, short value)
写入包含给定的短值的两个字节,在当前字节顺序中,在给定索引处进入该缓冲区中。
index
的指标,将被写入字节
value
-写短的价值
IndexOutOfBoundsException
-如果
index是负面或不小于缓冲区的限制,减一
ReadOnlyBufferException
-如果这个缓冲区是只读的
public abstract ShortBuffer asShortBuffer()
新的缓冲区的内容将从这个缓冲区的当前位置开始。这个缓冲区的内容的变化将在新的缓冲区中可见,反之亦然;两个缓冲区的位置,限制和标记值将是独立的。
新的缓冲区的位置将是零,它的容量和它的限制将是在这个缓冲区除以两个字节的数量,它的标记将是不确定的。新的缓冲区将是直接的,如果,只有当这个缓冲区是直接的,它将是只读的,只有当,这个缓冲区是只读的。
public abstract int getInt()
读取下一个四字节的缓冲区的当前位置,组合成一个int值根据当前的字节顺序,然后加四的位置。
BufferUnderflowException
-如果有少于四个字节中剩余的缓冲区
public abstract ByteBuffer putInt(int value)
写四个字节包含给定的int值,在当前的字节顺序,在当前位置到缓冲区,再加四的位置。
value
-要写入的int值
BufferOverflowException
-如果有少于四个字节中剩余的缓冲区
ReadOnlyBufferException
-如果这个缓冲区是只读的
public abstract int getInt(int index)
读取四字节给定索引处,组合成一个int值根据当前的字节顺序。
index
-索引的字节将被读取
IndexOutOfBoundsException
-如果
index是负面或不小于缓冲区的限制,减三
public abstract ByteBuffer putInt(int index, int value)
写四个字节包含给定的int值,在当前的字节顺序,在给定的索引缓冲区。
index
的指标,将被写入字节
value
-要写入的int值
IndexOutOfBoundsException
-如果
index是负面或不小于缓冲区的限制,减三
ReadOnlyBufferException
-如果这个缓冲区是只读的
public abstract IntBuffer asIntBuffer()
新的缓冲区的内容将从这个缓冲区的当前位置开始。这个缓冲区的内容的变化将在新的缓冲区中可见,反之亦然;两个缓冲区的位置,限制和标记值将是独立的。
新的缓冲区的位置将为零,它的容量和它的限制将是在这个缓冲区除以四的字节数,它的标记将是不确定的。新的缓冲区将是直接的,如果,只有当这个缓冲区是直接的,它将是只读的,只有当,这个缓冲区是只读的。
public abstract long getLong()
读取当前缓冲区当前位置的下一个八字节,并根据当前的字节顺序将它们组合成一个长值,然后将该位置增量为八。
BufferUnderflowException
-如果有少于八个字节中剩余的缓冲区
public abstract ByteBuffer putLong(long value)
写入包含给定长值的八个字节,在当前字节顺序中,在当前位置进入该缓冲区,然后将该位置增量为八。
value
-要写长值
BufferOverflowException
-如果有少于八个字节中剩余的缓冲区
ReadOnlyBufferException
-如果这个缓冲区是只读的
public abstract long getLong(int index)
在给定的索引处读取八个字节,根据当前的字节顺序将它们组合成一个长的值。
index
-索引的字节将被读取
IndexOutOfBoundsException
-如果
index是负面或不小于缓冲区的限制,减七
public abstract ByteBuffer putLong(int index, long value)
写入包含给定的长值的八个字节,在当前字节顺序中,在给定的索引处进入该缓冲区中。
index
的指标,将被写入字节
value
-要写长值
IndexOutOfBoundsException
-如果
index是负面或不小于缓冲区的限制,减七
ReadOnlyBufferException
-如果这个缓冲区是只读的
public abstract LongBuffer asLongBuffer()
新的缓冲区的内容将从这个缓冲区的当前位置开始。这个缓冲区的内容的变化将在新的缓冲区中可见,反之亦然;两个缓冲区的位置,限制和标记值将是独立的。
新的缓冲区的位置将为零,它的容量和它的限制将是在这个缓冲区除以八的字节数,它的标记将是不确定的。新的缓冲区将是直接的,如果,只有当这个缓冲区是直接的,它将是只读的,只有当,这个缓冲区是只读的。
public abstract float getFloat()
读取当前缓冲区当前位置的下一个四字节,并根据当前的字节顺序将它们组合成一个浮点值,然后将该位置增量为四。
BufferUnderflowException
-如果有少于四个字节中剩余的缓冲区
public abstract ByteBuffer putFloat(float value)
写入包含给定的浮点值的四个字节,在当前字节顺序中,在当前位置进入该缓冲区,然后将该位置增量为四。
value
-被写入浮点值
BufferOverflowException
-如果有少于四个字节中剩余的缓冲区
ReadOnlyBufferException
-如果这个缓冲区是只读的
public abstract float getFloat(int index)
在给定的索引处读取四个字节,根据当前的字节顺序将它们组合成一个浮点值。
index
-索引的字节将被读取
IndexOutOfBoundsException
-如果
index是负面或不小于缓冲区的限制,减三
public abstract ByteBuffer putFloat(int index, float value)
写入包含给定的浮点值的四个字节,在当前字节顺序中,在给定的索引处进入该缓冲区中。
index
的指标,将被写入字节
value
-被写入浮点值
IndexOutOfBoundsException
-如果
index是负面或不小于缓冲区的限制,减三
ReadOnlyBufferException
-如果这个缓冲区是只读的
public abstract FloatBuffer asFloatBuffer()
新的缓冲区的内容将从这个缓冲区的当前位置开始。这个缓冲区的内容的变化将在新的缓冲区中可见,反之亦然;两个缓冲区的位置,限制和标记值将是独立的。
新的缓冲区的位置将为零,它的容量和它的限制将是在这个缓冲区除以四的字节数,它的标记将是不确定的。新的缓冲区将是直接的,如果,只有当这个缓冲区是直接的,它将是只读的,只有当,这个缓冲区是只读的。
public abstract double getDouble()
读取该缓冲区当前位置的下一个八字节,根据当前字节顺序将它们组合成一个双值,然后将该位置增量为八。
BufferUnderflowException
-如果有少于八个字节中剩余的缓冲区
public abstract ByteBuffer putDouble(double value)
写入包含给定的双值的八个字节,在当前字节顺序中,在当前位置进入该缓冲区,然后将该位置增量为八。
value
-要写入的双重价值
BufferOverflowException
-如果有少于八个字节中剩余的缓冲区
ReadOnlyBufferException
-如果这个缓冲区是只读的
public abstract double getDouble(int index)
读取给定索引中的八个字节,根据当前字节顺序将它们组合成一个双值。
index
-索引的字节将被读取
IndexOutOfBoundsException
-如果
index是负面或不小于缓冲区的限制,减七
public abstract ByteBuffer putDouble(int index, double value)
写入包含给定的双值的八个字节,在当前字节顺序中,在给定的索引中进入该缓冲区中。
index
的指标,将被写入字节
value
-要写入的双重价值
IndexOutOfBoundsException
-如果
index是负面或不小于缓冲区的限制,减七
ReadOnlyBufferException
-如果这个缓冲区是只读的
public abstract DoubleBuffer asDoubleBuffer()
新的缓冲区的内容将从这个缓冲区的当前位置开始。这个缓冲区的内容的变化将在新的缓冲区中可见,反之亦然;两个缓冲区的位置,限制和标记值将是独立的。
新的缓冲区的位置将为零,它的容量和它的限制将是在这个缓冲区除以八的字节数,它的标记将是不确定的。新的缓冲区将是直接的,如果,只有当这个缓冲区是直接的,它将是只读的,只有当,这个缓冲区是只读的。
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.