compact1, compact2, compact3

java.nio

Class FloatBuffer

java.lang.Object

java.nio.Buffer

java.nio.FloatBuffer

All Implemented Interfaces:

Comparable < FloatBuffer >

public abstract class FloatBuffer
extends Buffer
implements Comparable<FloatBuffer>

一个浮动缓冲区。

这个类在浮动缓冲区上定义了四类操作：

• 绝对和相对get和put读写单个浮点数的方法;

• 相对bulk get方法将相邻序列的浮点数从该缓冲区传输到数组中; 和

• 相对bulk put方法，将浮点数的浮点数或其他浮点缓冲区的连续序列传输到此缓冲区中; 和

• 方法compacting ， duplicating和slicing float缓冲区。

浮动缓冲区可以由allocation创建，它为缓冲区的内容分配空间，通过wrapping将现有的浮点数组分配到缓冲区中，或者通过创建现有字节缓冲区的view 。

像一个字节缓冲区一样，浮点缓冲区是direct or non-direct 。 通过这个类的wrap方法创建的浮动缓冲区将是非直接的。 作为字节缓冲区视图创建的浮动缓冲区将是直接的，只有当字节缓冲区本身是直接的。 浮动缓冲区是否直接可以通过调用isDirect方法来确定。

指定此类中没有值返回值的方法返回调用它们的缓冲区。 这允许方法调用被链接。

从以下版本开始：

1.4

方法摘要

Modifier and Type	Method and Description
static FloatBuffer	allocate(int capacity) 分配一个新的浮动缓冲区。
float[]	array() 返回支持此缓冲区的float数组 （可选操作） 。
int	arrayOffset() 返回该缓冲区的缓冲区的第一个元素的背衬数组中的偏移量 （可选操作） 。
abstract FloatBuffer	asReadOnlyBuffer() 创建一个新的只读浮动缓冲区，共享此缓冲区的内容。
abstract FloatBuffer	compact() 压缩此缓冲区 （可选操作） 。
int	compareTo(FloatBuffer that) 将此缓冲区与另一个缓冲区进行比较。
abstract FloatBuffer	duplicate() 创建一个新的浮动缓冲区，共享此缓冲区的内容。
boolean	equals(Object ob) 告诉这个缓冲区是否等于另一个对象。
abstract float	get() 相对 获取方法。
FloatBuffer	get(float[] dst) 相对批量 获取方法。
FloatBuffer	get(float[] dst, int offset, int length) 相对批量 获取方法。
abstract float	get(int index) 绝对 获取方法。
boolean	hasArray() 告诉这个缓冲区是否由可访问的浮点数组支持。
int	hashCode() 返回此缓冲区的当前哈希码。
abstract boolean	isDirect() 告诉这个浮动缓冲区是否直接。
abstract ByteOrder	order() 检索此缓冲区的字节顺序。
abstract FloatBuffer	put(float f) 相对 放置法 （可选操作） 。
FloatBuffer	put(float[] src) 相对大容量 put方法 （可选操作） 。
FloatBuffer	put(float[] src, int offset, int length) 相对大容量 put方法 （可选操作） 。
FloatBuffer	put(FloatBuffer src) 相对大容量 put方法 （可选操作） 。
abstract FloatBuffer	put(int index, float f) 绝对 put方法 （可选操作） 。
abstract FloatBuffer	slice() 创建一个新的浮动缓冲区，其内容是此缓冲区内容的共享子序列。
String	toString() 返回一个汇总此缓冲区状态的字符串。
static FloatBuffer	wrap(float[] array) 将一个浮点数组放入缓冲区。
static FloatBuffer	wrap(float[] 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 FloatBuffer allocate(int capacity)

分配一个新的浮动缓冲区。

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

参数

capacity - 新的缓冲区的容量，在浮点数

结果

新的浮动缓冲区

异常

IllegalArgumentException - 如果 capacity是负整数

wrap

public static FloatBuffer wrap(float[] array,
                               int offset,
                               int length)

将一个浮点数组放入缓冲区。

新的缓冲区将由给定的float数组支持; 也就是说，对缓冲区的修改将导致数组被修改，反之亦然。 新增缓存的容量将为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 FloatBuffer wrap(float[] array)

将一个浮点数组放入缓冲区。

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

参数

array - 将返回此缓冲区的数组

结果

新的浮动缓冲区

slice

public abstract FloatBuffer slice()

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

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

新缓冲区的位置将为零，其容量和限制将是此缓冲区中剩余的浮点数，其标记将不定义。 如果只有这个缓冲区是直接的，并且只有当这个缓冲区是只读的时，这个缓冲区将是只读的。

结果

新的浮动缓冲区

duplicate

public abstract FloatBuffer duplicate()

创建一个新的浮动缓冲区，共享此缓冲区的内容。

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

新缓冲区的容量，限制，位置和标记值将与此缓冲区的容量，限制，位置和标记值相同。 如果只有这个缓冲区是直接的，并且只有当这个缓冲区是只读的时，这个缓冲区将是只读的。

结果

新的浮动缓冲区

asReadOnlyBuffer

public abstract FloatBuffer asReadOnlyBuffer()

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

新缓冲区的内容将是这个缓冲区的内容。 这个缓冲区内容的更改将在新的缓冲区中显示; 然而，新的缓冲区本身将是只读的，不允许修改共享内容。 两个缓冲区的位置，极限和标记值将是独立的。

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

如果这个缓冲区本身是只读的，那么这个方法的行为与duplicate方法完全相同。

结果

新的只读浮动缓冲区

get

public abstract float get()

相对获取方法。 在此缓冲区的当前位置读取浮点数，然后增加该位置。

结果

浮点在缓冲区的当前位置

异常

BufferUnderflowException - 如果缓冲区的当前位置不小于其限制

put

public abstract FloatBuffer put(float f)

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

将给定的浮点数写入当前位置的缓冲区，然后增加位置。

参数

f - f的浮动

结果

这个缓冲区

异常

BufferOverflowException - 如果此缓冲区的当前位置不小于其限制

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

get

public abstract float get(int index)

绝对获取方法。 读取给定索引的浮点数。

参数

index - 读取浮点数的索引

结果

给定索引的浮点数

异常

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

put

public abstract FloatBuffer put(int index,
                                float f)

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

将给定的浮点数写入给定索引的缓冲区。

参数

index - 将写入浮点数的索引

f - 要写入的浮点值

结果

这个缓冲区

异常

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

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

get

public FloatBuffer get(float[] 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 FloatBuffer get(float[] dst)

相对批量获取方法。

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

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

参数

dst - 目的地阵列

结果

这个缓冲区

异常

BufferUnderflowException - 如果此缓冲区中 剩余的浮点数少于 length个浮点数

put

public FloatBuffer put(FloatBuffer src)

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

此方法将给定源缓冲区中剩余的浮点数传输到此缓冲区。 如果源缓冲区中剩余的浮点数比缓冲区多，也就是说，如果src.remaining() > remaining() ，则不会传输浮点数并抛出BufferOverflowException 。

否则，该方法将n = src.remaining()从给定缓冲区浮动到这个缓冲区，从每个缓冲区的当前位置开始。 然后将两个缓冲器的位置递增n 。

换言之，所述表格dst.put(src)的这种方法的调用具有完全一样的环相同的效果

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

除了它首先检查这个缓冲区中是否有足够的空间，并且它可能更有效率。

参数

src - 要读取浮点数的源缓冲区; 不能是这个缓冲区

结果

这个缓冲区

异常

BufferOverflowException - 如果缓冲区中的剩余浮点数在源缓冲区中没有足够的空间

IllegalArgumentException - 如果源缓冲区是这个缓冲区

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

put

public FloatBuffer put(float[] src,
                       int offset,
                       int length)

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

该方法将浮点数从给定的源数组传输到该缓冲区。 如果从数组中复制的浮点数多于保留在此缓冲区中的浮点数，也就是说，如果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 FloatBuffer put(float[] src)

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

此方法将给定源float数组的整个内容传输到此缓冲区。 调用此方法的形式为dst.put(a)的行为方式与调用完全相同

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

参数

src - 源数组

结果

这个缓冲区

异常

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

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

hasArray

public final boolean hasArray()

告诉这个缓冲区是否由可访问的浮点数组支持。

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

Specified by:

hasArray在 Buffer

结果

true如果且仅当此缓冲区由数组支持并且不是只读的

array

public final float[] array()

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

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

在调用此方法之前调用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 FloatBuffer compact()

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

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

缓冲区的位置设置为复制的浮点数，而不是为零，因此可以通过调用另一个相对put方法来立即调用此方法。

结果

这个缓冲区

异常

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. 独立于其起始位置的剩余元素的两个序列是相等的。 该方法考虑两个浮动元件a和b是如果相等(a == b) || (Float.isNaN(a) && Float.isNaN(b)) 。 值-0.0和+0.0被认为是相等的，不像Float.equals(Object) 。

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

重写：

equals在 Object

参数

ob - 要比较此缓冲区的对象

结果

true如果，只有这个缓冲区等于给定的对象

另请参见：

Object.hashCode() ， HashMap

compareTo

public int compareTo(FloatBuffer that)

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

通过将词汇的剩余元素序列进行比较来比较两个浮动缓冲区，而不考虑其相应缓冲区内每个序列的起始位置。 对对float元素进行比较，仿佛通过调用Float.compare(float,float) ，除了-0.0和0.0被认为是相等的。 Float.NaN被认为是等于自己和大于所有其他float值（包括Float.POSITIVE_INFINITY ）。

浮动缓冲区与任何其他类型的对象无法比较。

Specified by:

compareTo在接口 Comparable<FloatBuffer>

参数

that - 要比较的对象。

结果

负整数，零或正整数，因为此缓冲区小于，等于或大于给定的缓冲区

order

public abstract ByteOrder order()

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

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

结果

这个缓冲区的字节顺序