java中的float缓冲区FloatBuffer

一、概述：

java.lang.Object
  java.nio.Buffer
      java.nio.FloatBuffer
public abstract class FloatBuffer extends Buffer implements Comparable<FloatBuffer>

此类定义了 float 缓冲区上的四类操作：

  • 读写单个 float 的绝对和相对 get 和put 方法；
  • 将此缓冲区中的连续 float 序列传输到数组中的相对批量 get 方法；
  • 将 float 数组或其他 float 缓冲区中的连续 float 序列传输到此缓冲区的相对批量 put 方法；以及
  • float 缓冲区的 compacting、duplicating 和slicing
    方法。

float 缓冲区可以通过 allocation 创建，此方法通过wrapping 将一个现有 float 数组包装到缓冲区中来为缓冲区内容分配空间,或者通过创建现有字节缓冲区的视图来创建

像字节缓冲区一样，float 缓冲区要么是直接的，要么是非直接的。通过此类的wrap 方法创建的 float 缓冲区将是非直接的。当且仅当字节缓冲区本身为直接时，作为字节缓冲区的视图创建的 float 缓冲区才是直接的。通过调用isDirect
方法可以确定 float 缓冲区是否为直接的。

指定此类中的方法（它们不返回其他值）以返回这些方法被调用时所在的缓冲区。这允许对方法调用进行链接。

二、方法详细

1、public static FloatBufferallocate(int capacity)
 分配新的 float 缓冲区。


新缓冲区的位置将为零，其界限将为其容量，其标记是未定义的。它将具有一个底层实现数组，且其数组偏移量将为零。

参数：
capacity - 新缓冲区的容量，以 float 为单位
返回：
新的 float 缓冲区
抛出：
IllegalArgumentException - 如果capacity 为负整数

2、public static FloatBufferwrap(float[] array, int offset,int length)

将 float 数组包装到缓冲区中。

给定 float 数组将支持新缓冲区；即缓冲区修改将导致数组修改，反之亦然。新缓冲区的容量将为 array.length，其位置将为
offset，其界限将为 offset + length，其标记是未定义的。其底层实现数组将为给定数组，并且其数组偏移量将为零。

参数：
array - 支持新缓冲区的数组
offset - 要使用的子数组的偏移量；必须为非负且不大于 array.length。将新缓冲区的位置设置为此值。
length - 要使用的子数组的长度；必须为非负且不大于 array.length - offset。将新缓冲区的界限设置为offset + length。
返回：
新的 float 缓冲区
抛出：
IndexOutOfBoundsException - 如果关于offset 和
length 参数的前提不成立

3、public static FloatBufferwrap(float[] array)

将 float 数组包装到缓冲区中。

给定 float 数组将支持新缓冲区；即缓冲区修改将导致数组修改，反之亦然。新缓冲区的容量和界限将为 array.length，其位置将为零，其标记是未定义的。其底层实现数组将为给定数组，并且其数组偏移量将为零。

参数：
array - 实现此缓冲区的数组
返回：
新的 float 缓冲区

4、public abstract FloatBufferslice()

创建新的 float 缓冲区，其内容是此缓冲区内容的共享子序列。

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

新缓冲区的位置将为零，其容量和界限将为此缓冲区中所剩余的 float 数量，其标记是未定义的。当且仅当此缓冲区为直接时，新缓冲区才是直接的，当且仅当此缓冲区为只读时，新缓冲区才是只读的。

返回：
新的 float 缓冲区

5、public abstract FloatBufferduplicate()

创建共享此缓冲区内容的新的 float 缓冲区。

新缓冲区的内容将为此缓冲区的内容。此缓冲区内容的更改在新缓冲区中是可见的，反之亦然；这两个缓冲区的位置、界限和标记值是相互独立的。

新缓冲区的容量、界限、位置和标记值将与此缓冲区相同。当且仅当此缓冲区为直接时，新缓冲区才是直接的，当且仅当此缓冲区为只读时，新缓冲区才是只读的。

返回：
新的 float 缓冲区

6、public abstract FloatBufferasReadOnlyBuffer()

创建共享此缓冲区内容的新的只读 float 缓冲区。

新缓冲区的内容将为此缓冲区的内容。此缓冲区的更改在新缓冲区中是可见的，但新缓冲区将是只读的并且不允许修改共享内容。两个缓冲区的位置、界限和标记值是相互独立的。

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

如果此缓冲区本身是只读的，则此方法与 duplicate 方法完全相同。

返回：
新的只读 float 缓冲区

7、public abstract float get()

相对 get 方法。读取此缓冲区当前位置的 float，然后该位置递增。

返回：
缓冲区当前位置的 float
抛出：
BufferUnderflowException - 如果缓冲区当前位置不小于其界限

8、public abstract FloatBufferput(float f)

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

将给定 float 写入此缓冲区的当前位置，然后该位置递增。

参数：
f - 要写入的 float
返回：
此缓冲区
抛出：
BufferOverflowException - 如果此缓冲区的当前位置不小于界限
ReadOnlyBufferException - 如果此缓冲区是只读的

9、public abstract float get(int index)

绝对 get 方法。读取给定位置处的 float。

参数：
index - 将读取 float 的位置的索引
返回：
给定索引处的 float
抛出：
IndexOutOfBoundsException - 如果index 为负或不小于缓冲区界限

10、public abstract FloatBufferput(int index, float f)

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

将给定 float 写入此缓冲区的给定索引处。

参数：
index - 将在该位置写入 float
f - 要写入的 float 值
返回：
此缓冲区
抛出：
IndexOutOfBoundsException - 如果index 为负或不小于缓冲区界限
ReadOnlyBufferException - 如果此缓冲区是只读的

11、public FloatBufferget(float[] dst,
int offset,int length)

相对批量 get 方法。

此方法将此缓冲区的 float 传输到给定的目标数组中。如果缓冲区中剩余的 float 少于满足请求所需的 float，即如果 length > remaining()，则不传输 float 且抛出BufferUnderflowException。

否则，此方法此缓冲区中的 length 个 float 复制到给定数组中，从此缓冲区的当前位置和数组中的给定偏移量位置开始复制。然后此缓冲区的位置递增length。

换句话说，调用此方法的形式为 src.get(dst, off, len)，该调用与以下循环语句完全相同：

     for (int i = off; i < off + len; i++)
         dst[i] = src.get();

区别在于它首先检查此缓冲区中是否具有足够的 float，这样可能效率更高。

参数：
dst - 写入 float 的数组
offset - 要写入的第一个 float 在数组中的偏移量；必须为非负且不大于 dst.length
length - 要写入给定数组中的 float 的最大数量；必须为非负且不大于 dst.length - offset
返回：
此缓冲区
抛出：
BufferUnderflowException - 如果此缓冲区中的剩余 float 少于length
IndexOutOfBoundsException - 如果关于offset 和
length 参数的前提不成立

12、public FloatBufferget(float[] dst)

相对批量 get 方法。

此方法将此缓冲区的 float 传输到给定的目标数组中。调用此方法的形式为 src.get(a)，该调用与以下调用完全相同：

     src.get(a, 0, a.length)
返回：
此缓冲区
抛出：
BufferUnderflowException - 如果此缓冲区中的剩余 float 少于length

13、public FloatBufferput(FloatBuffer src)

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

此方法将给定源缓冲区中的剩余 float 传输到此缓冲区中。如果源缓冲区中的剩余 float 多于此缓冲区中的剩余 float 空间，即 src.remaining() > remaining()，则不传输 float 且抛出BufferOverflowException。

否则，此方法将给定缓冲区中的 n = src.remaining() 个 float 复制到此缓冲区中，从每个缓冲区的当前位置开始复制。然后这两个缓冲区的位置均递增n。

换句话说，调用此方法的形式为 dst.put(src)，效果与以下循环语句完全相同：

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

区别在于它首先检查此缓冲区中是否具有足够的空间，这样可能效率更高。

参数：
src - 要从中读取 float 的源缓冲区；不能为此缓冲区
返回：
此缓冲区
抛出：
BufferOverflowException - 如果对于源缓冲区中剩余的 float，此缓冲区没有足够空间
IllegalArgumentException - 如果源缓冲区是此缓冲区
ReadOnlyBufferException - 如果此缓冲区是只读的

14、public FloatBufferput(float[] src, int offset,int length)
 相对批量 put 方法（可选操作）。


此方法将给定源数组中的 float 传输此缓冲区中。如果要从数组复制的 float 多于此缓冲区中的剩余 float 空间，即如果 length > remaining()，则不传输 float 且抛出BufferOverflowException。

否则，此方法将给定数组中的 length 个 float 复制到此缓冲区中，从数组中给定偏移量位置和此缓冲区的当前位置开始复制。然后此缓冲区的位置递增length。

换句话说，调用此方法的形式为 dst.put(src, off, len)，效果与以下循环语句完全相同：

     for (int i = off; i < off + len; i++)
         dst.put(a[i]);

区别在于它首先检查此缓冲区中是否具有足够的空间，这样可能效率更高。

参数：
src - 要从中读取 float 的数组
offset - 要读取的第一个 float 在数组中的偏移量；必须为非负且不大于 array.length
length - 要从给定数组读取的 float 数量；必须为非负且不大于 array.length - offset
返回：
此缓冲区
抛出：
BufferOverflowException - 如果此缓冲区没有足够空间
IndexOutOfBoundsException - 如果关于offset 和
length 参数的前提不成立
ReadOnlyBufferException - 如果此缓冲区是只读的

15、 public finalFloatBufferput(float[] src)

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

此方法将给定源 float 数组中的所有内容传输到此缓冲区中。调用此方法的形式为 dst.put(a)，该调用与以下调用完全相同：

     dst.put(a, 0, a.length)
返回：
此缓冲区
抛出：
BufferOverflowException - 如果此缓冲区没有足够空间
ReadOnlyBufferException - 如果此缓冲区是只读的

16、public final booleanhasArray()

判断是否可通过一个可访问的 float 数组实现此缓冲区。

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

指定者：
类 Buffer 中的
hasArray
返回：
当且仅当存在实现此缓冲区的数组，并且此缓冲区不是只读缓冲区时，返回 true

17、public final float[]array()

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

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

调用此方法之前要调用 hasArray 方法，以确保此缓冲区具有可访问的底层实现数组。

指定者：
类 Buffer 中的
array
返回：
实现此缓冲区的数组
抛出：
ReadOnlyBufferException - 如果存在实现此缓冲区的数组，但缓冲区是只读的
UnsupportedOperationException - 如果不存在某个可访问的数组实现此缓冲区

18、public final intarrayOffset()

返回此缓冲区的第一个元素在缓冲区的底层实现数组中的偏移量（可选操作）。

如果存在实现此缓冲区的数组，则缓冲区位置 p 对应于数组索引 p + arrayOffset()。

调用此方法之前要调用 hasArray 方法，以确保此缓冲区具有可访问的底层实现数组。

指定者：
类 Buffer 中的
arrayOffset
返回：
此缓冲区的第一个元素在缓冲区数组中的偏移量
抛出：
ReadOnlyBufferException - 如果存在实现此缓冲区的数组，但缓冲区是只读的
UnsupportedOperationException - 如果不存在某个可访问的数组实现此缓冲区

19、public abstractFloatBuffercompact()

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

将缓冲区当前位置和界限之间的 float（如果有）复制到缓冲区的开始处。即将索引 p = position() 处的 float 复制到索引 0 处，将索引p + 1 处的 float 复制到索引 1 处，依此类推，直到将索引
limit() - 1 处的 float 复制到索引 n = limit() - 1 - p 处。然后将缓冲区的位置设置为
n+1，并将其界限设置为其容量。如果已定义了标记，则丢弃它。

将缓冲区的位置设置为复制的 float 的数量，而不是零，以便调用此方法后可以紧接着调用另一个相对 put 方法。

返回：
此缓冲区
抛出：
ReadOnlyBufferException - 如果此缓冲区是只读的

20、public abstract booleanisDirect() 判断此 float 缓冲区是否为直接的。

指定者：
类 Buffer 中的
isDirect
返回：
当且仅当此缓冲区为直接时，返回 true

21、public
StringtoString()

返回总结了此缓冲区状态的字符串。

覆盖：
类 Object 中的toString
返回：
一个总结字符串

22、public int
hashCode()

返回此缓冲区的哈希码。

float 缓冲区的哈希码只取决于其剩余元素；即取决于从 position() 开始一直到（包括） limit() - 1 处的元素。

因为缓冲区哈希码与内容有关，因此建议不要在哈希映射或类似数据结构中将缓冲区用作键，除非知道它们的内容不会发生更改。

覆盖：
类 Object 中的hashCode
返回：
此缓冲区的当前哈希码
另请参见：
Object.equals(java.lang.Object),
Hashtable

23、public booleanequals(Object ob)

判断此缓冲区是否与另一个对象相同。

两个 float 缓冲区是相同的，当且仅当：

  1. 它们具有相同的元素类型，
  2. 它们具有相同数量的剩余元素，并且
  3. 两个剩余元素序列（与它们的起始位置无关）逐点相同。

float 缓冲区与任何其他类型的对象都不同。

覆盖：
类 Object 中的equals
参数：
ob - 此缓冲区要比较的对象
返回：
当且仅当此缓冲区与给定对象相同时，返回 true

24、public int
compareTo(FloatBuffer that)

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

比较两个 float 缓冲区的方法是按字典顺序比较它们的剩余元素序列，而不考虑每个序列在其对应缓冲区中的起始位置。

float 缓冲区不能与任何其他类型的对象进行比较。

指定者：
接口 Comparable<FloatBuffer> 中的compareTo
参数：
that - 要比较的对象。
返回：
如果此缓冲区小于、等于或大于给定缓冲区，则相应返回负整数、零或正整数

25、public abstractByteOrderorder()
获取此缓冲区的字节顺序。


通过分配或通过包装现有 float 型数组而创建的 float 缓冲区的字节顺序是底层硬件的本机顺序。作为字节缓冲区的视图而创建的 float 缓冲区的字节顺序是创建视图时字节缓冲区的字节顺序。

返回：
此缓冲区的字节顺序
时间： 2024-11-08 15:02:04

java中的float缓冲区FloatBuffer的相关文章

java中int,float,long,double取值范围，内存泄露

java中int,float,long,double取值范围是多少? 写道 public class TestOutOfBound { public static void main(String[] args) { System.out.println(Integer.MAX_VALUE-(-Integer.MAX_VALUE)); //内存溢出System.out.println(Integer.MAX_VALUE); //2的31次方-1,10个数位,正的20亿左右,用在钱上面不一定够Sy

java中的字节缓冲区ByteBuffer

一.概述:字节缓冲区 类结构: java.lang.Object java.nio.Buffer java.nio.ByteBuffer 类声明: public abstract class ByteBuffer extends Buffer implements Comparable<ByteBuffer> 此类针对字节缓冲区定义了以下六类操作: 读写单个字节的绝对和相对 get 和 put 方法: 将此缓冲区的连续字节序列传输到数组中的相对批量 get 方法: 将 byte 数组或其他字节

如何理解IEEE 754标准对Java中float值和double值的规定

在Java语言中,我们可以使用float和double这两种基本数据类型来表示特定的数据. 这两种数据类型,本质上是浮点数(floating-point number),浮点是一种对于实数的近似值数值表现法,由一个有效数字加上幂数来表示. 之所以使用浮点数,是因为计算机在使用二进制运算的过程中,无法将所有的十进制小数准确的换算为二进制,只能使用近似值来表示. 使用浮点数表示数值的方法很多,在Java中,和C语言一样,float和double都采用了使用最为广泛的IEEE 754标准. IEEE

Java 中阻塞Io 以及非阻塞IO

在开始之前 关于本教程 新的输入/输出 (NIO) 库是在 JDK 1.4 中引入的.NIO 弥补了原来的 I/O 的不足,它在标准 Java 代码中提供了高速的.面向块的 I/O.通过定义包含数据的类,以及通过以块的形式处理这些数据,NIO 不用使用本机代码就可以利用低级优化,这是原来的 I/O 包所无法做到的. 在本教程中,我们将讨论 NIO 库的几乎所有方面,从高级的概念性内容到底层的编程细节.除了学习诸如缓冲区和通道这样的关键 I/O 元素外,您还有机会看到在更新后的库中标准 I/O 是

mysql对应java中常用的字段

varchar 不定长字符串 字符串或是没有合适类型时,可以选择它作为字段类型 对应Java中的String int bigint 数值 一般以int作为数字的默认选择,数值很大时使用bigint 对应Java中的Long char 定长字符串 适用于盐.md5加密后的密码等情况 对应Java中的String float double 浮点数 适用于各种小数,除非金额等情况,小数推荐使用double 各自对应Java中的Float,Double decimal 精确浮点数 适用于金额 对应Jav

Java中的简单浮点数类型float和double不能够进行精确运算

在java中,简单的浮点类型float和double是不能够进行运算.我们先看下面的两个程序代码: 代码一: import java.util.Scanner; class Circle { double radius; static final double PI=3.14; public Circle(){this.radius=0;} public Circle(double r){this.radius=r;} public double getArea(){return PI*this

【转】java中float与byte[]的互转 -- 不错

原文网址:http://tjmljw.iteye.com/blog/1767716 起因:想把一个float[]转换成内存数据,查了一下,下面两个方法可以将float转成byte[]. 方法一 Java代码   import java.nio.ByteBuffer; import java.util.ArrayList; float buffer = 0f; ByteBuffer bbuf = ByteBuffer.allocate(4); bbuf.putFloat(buffer); byte

精确计算java中float和double的精度

[本文相关的代码放在github上,地址为:https://github.com/VigourJiang/StructuredFloat] Java中double类型的格式是遵循IEEE 754标准的.尽管数学意义上的小数是连续的,但double仅仅能表示其中的一些离散点,把这些离散点组成的集合记为S,S的大小还是有限的.如果要保存的小数P刚好在集合S内,那么double类型就能精确的表示P:否则double类型只能从集合S中找一个与P最近的离散点P'代替P. 以上表述对于float也成立.IE

Java中要使用 BigDecimal(定点数) 进行小数的相关操作，避免使用float等浮点数

Java中要使用 BigDecimal(定点数) 进行小数的相关操作,避免使用float等浮点数,因为 float, double等浮点的存储和操作(比如:相加,相减...)存在误差(7.22f - 7.0f = 0.21999979 而不是 0.22). 下面以 BigDecimal 进行减法为例: /**  * 精确的减法  */ public static double subtract(double v1, double v2) { BigDecimal d1 = new BigDeci