FloatBuffer (Java Platform SE 8 )

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浮动缓冲。
浮动缓冲区可以创建由allocation，分配的缓冲区的内容空间，通过wrapping现有浮点数组读入缓冲区，或创建一个view现有的字节缓冲区。

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

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

一点四

方法摘要

所有方法静态方法接口方法抽象方法具体的方法
Modifier and Type	Method and Description
`static FloatBuffer`	`allocate(int capacity)` 分配一个新的浮动缓冲区。
`float[]`	`array()` 返回浮点数组缓冲区，背（可选操作）。
`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)` 相对体积放方法（可选操作）。
`FloatBuffer`	`put(float[] src, int offset, int length)` 相对体积放方法（可选操作）。
`FloatBuffer`	`put(FloatBuffer src)` 相对体积放方法（可选操作）。
`abstract FloatBuffer`	`put(int index, float f)` 绝对放方法（可选操作）。
`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)
```
    将一个浮动数组封装到一个缓冲区中。
    新的缓冲区将由给定的浮点数组支持；也就是说，对缓冲区的修改将导致数组被修改，反之亦然。新的缓冲区的容量将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)
```
    将一个浮动数组封装到一个缓冲区中。
    新的缓冲区将由给定的浮点数组支持；也就是说，对缓冲区的修改将导致数组被修改，反之亦然。新的缓冲区的容量和限制将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 -浮来写的
    
    结果
    
    这个缓冲区
    
    异常
    
    BufferOverflowException -如果这个缓冲区的当前位置不小于其极限
    
    ReadOnlyBufferException -如果这个缓冲区是只读的
  - get
```
public abstract float get(int index)
```
    绝对得到方法。读取给定索引中的浮动。
    
    参数
    
    index -指数的浮动将读
    
    结果
    
    给定索引中的浮动
    
    异常
    
    IndexOutOfBoundsException -如果 index是负面或不小于缓冲区的限制
  - put
```
public abstract FloatBuffer put(int index,
                                float f)
```
    绝对放方法（可选操作）。
    在给定的索引处将给定的浮点到这个缓冲区中。
    
    参数
    
    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。得到（一，0，a.length）
```
    参数
    
    dst -目标数组
    
    结果
    
    这个缓冲区
    
    异常
    
    BufferUnderflowException -如果有少于 length漂浮在这剩下的缓冲
  - put
```
public FloatBuffer put(FloatBuffer src)
```
    相对体积放方法（可选操作）。
    这种方法将在给定的源缓冲区中的剩余的浮动转换为这个缓冲区。如果有更多的漂浮物残留在源缓冲区比这个缓冲区，即如果src.remaining() > remaining()，然后没有漂浮转移和BufferOverflowException抛出。
    
    否则，此方法复制N = src.remaining()花车从给定的缓冲区到缓冲区，开始在每个缓冲区的当前位置。这两个缓冲区的位置，然后加N.
    
    换句话说，这种形式的dst.put(src)方法调用作为循环具有完全相同的效果
```
而（SRC。hasremaining()）DST。把（SRC。get()）；
```
    除外，它首先检查这个缓冲区有足够的空间，这可能是更有效的。
    参数
    
    src -源缓冲区的彩车要读；不得这个缓冲区
    
    结果
    
    这个缓冲区
    
    异常
    
    BufferOverflowException -如果没有足够的空间在这个缓冲区在源缓冲区剩余的漂浮
    
    IllegalArgumentException -如果源缓冲区缓冲区
    
    ReadOnlyBufferException -如果这个缓冲区是只读的
  - put
```
public FloatBuffer put(float[] 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 FloatBuffer put(float[] 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 float[] 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 FloatBuffer 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. 两序列的其余元素，认为是独立的，他们的立场出发，逐点等。该方法考虑了两个浮动元素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阵列底层硬件的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 FloatBuffer

方法摘要

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