zoukankan html css js c++ java

java中的ShortBuffer

一、概述

java.lang.Object
  java.nio.Buffer
      java.nio.ShortBuffer

public abstract class ShortBuffer extends Buffer implements Comparable<ShortBuffer>

short 缓冲区。

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

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

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

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

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

二、概述

1、public static ShortBuffer allocate(int capacity)

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

參数：
capacity - 新缓冲区的容量。以 short 为单位
返回：
新的 short 缓冲区
抛出：
IllegalArgumentException - 假设 capacity 为负整数

2、public static ShortBuffer wrap(short[] array, int offset,int length)

将 short 数组包装到缓冲区中。
给定的 short 数组将支持新缓冲区。即缓冲区改动将导致数组改动，反之亦然。新缓冲区的容量将为 array.length，其位置将为 offset。其界限将为 offset + length，其标记是没有定义的。其底层实现数组将为给定数组，而且其数组偏移量将为零。

參数：
array - 支持新缓冲区的数组
offset - 要使用的子数组的偏移量；必须为非负且不大于 array.length。
将新缓冲区的位置设置为此值。
length - 要使用的子数组的长度。必须为非负且不大于 array.length - offset。将新缓冲区的界限设置为 offset + length。
返回：
新的 short 缓冲区
抛出：
IndexOutOfBoundsException - 假设关于 offset 和 length 參数的前提不成立
3、public static ShortBuffer wrap(short[] array)

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

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

參数：
array - 实现此缓冲区的数组
返回：
新的 short 缓冲区
4、public abstract ShortBuffer slice()

创建新的 short 缓冲区。其内容是此缓冲区内容的共享子序列。
新缓冲区的内容将从此缓冲区的当前位置開始。此缓冲区内容的更改在新缓冲区中是可见的，反之亦然。这两个缓冲区的位置、界限和标记值是相互独立的。

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

返回：
新的 short 缓冲区
5、public abstract ShortBuffer duplicate()

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

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

返回：
新的 short 缓冲区

6、public abstract ShortBuffer asReadOnlyBuffer()

创建共享此缓冲区内容的新的仅仅读 short 缓冲区。
新缓冲区的内容将为此缓冲区的内容。此缓冲区内容的更改在新缓冲区中是可见的。但新缓冲区将是仅仅读的而且不同意改动共享内容。两个缓冲区的位置、界限和标记值是相互独立的。

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

假设此缓冲区本身是仅仅读的。则此方法与 duplicate 方法全然同样。

返回：
新的仅仅读 short 缓冲区
7、public abstract short get()

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

返回：
缓冲区当前位置的 short
抛出：
BufferUnderflowException - 假设缓冲区当前位置不小于其界限

8、public abstract ShortBuffer put(short s)

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

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

參数：
s - 要写入的 short
返回：
此缓冲区
抛出：
BufferOverflowException - 假设此缓冲区的当前位置不小于界限
ReadOnlyBufferException - 假设此缓冲区是仅仅读的
9、public abstract short get(int index)

绝对 get 方法。读取给定索引处的 short。

參数：
index - 将读取 short 的位置的索引
返回：
给定索引处的 short
抛出：
IndexOutOfBoundsException - 假设 index 为负或不小于缓冲区界限
10、public abstract ShortBuffer put(int index, short s)

绝对 put 方法（可选操作）。
将给定 short 写入此缓冲区的给定索引处。

參数：
index - 将在该位置写入 short
s - 要写入的 short 值
返回：
此缓冲区
抛出：
IndexOutOfBoundsException - 假设 index 为负或不小于缓冲区界限
ReadOnlyBufferException - 假设此缓冲区是仅仅读的

11、public ShortBuffer get(short[] dst,int offset,int length)
相对批量 get 方法。
此方法将此缓冲区的 short 传输到给定的目标数组中。
假设缓冲区中剩余的 short 少于满足请求所需的 short，即假设 length > remaining()，则不传输 short 且抛出 BufferUnderflowException。

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

换句话说，调用此方法的形式为 src.get(dst, off, len)，效果与下面循环语句全然同样：
```
     for (int i = off; i < off + len; i++)
         dst[i] = src.get(); 
```
差别在于它首先检查此缓冲区中是否具有足够的 short。这样可能效率更高。
參数：
dst - 要写入 short 的数组
offset - 要写入的第一个 short 在数组中的偏移量；必须为非负且不大于 dst.length
length - 要写入给定数组中的 short 的最大数量。必须为非负且不大于 dst.length - offset
返回：
此缓冲区
抛出：
BufferUnderflowException - 假设此缓冲区中的剩余 short 少于 length
IndexOutOfBoundsException - 假设关于 offset 和 length 參数的前提不成立
12、public ShortBuffer get(short[] dst)
相对批量 get 方法。
此方法将此缓冲区的 short 传输到给定的目标数组中。调用此方法的形式为 src.get(a)，该调用与下面调用全然同样：
```
     src.get(a, 0, a.length) 
```
返回：
此缓冲区
抛出：
BufferUnderflowException - 假设此缓冲区中的剩余 short 少于 length
13、public ShortBuffer put(ShortBuffer src)
相对批量 put 方法（可选操作）。

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

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

换句话说。调用此方法的形式为 dst.put(src)，效果与下面循环语句全然同样：
```
     while (src.hasRemaining())
         dst.put(src.get()); 
```
差别在于它首先检查此缓冲区中是否有足够空间。这样可能效率更高。
參数：
src - 要从中读取 short 的源缓冲区；不能为此缓冲区
返回：
此缓冲区
抛出：
BufferOverflowException - 假设对于源缓冲区中剩余的 short，此缓冲区没有足够空间
IllegalArgumentException - 假设源缓冲区是此缓冲区
ReadOnlyBufferException - 假设此缓冲区是仅仅读的
14、public ShortBuffer put(short[] src, int offset,int length)
相对批量 put 方法（可选操作）。
此方法将给定源数组中的 short 传输到此缓冲区中。假设要从数组复制的 short 多于此缓冲区中的剩余 short 空间。即假设 length > remaining()，则不传输 short 且抛出 BufferOverflowException。

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

换句话说，调用此方法的形式为 dst.put(src, off, len)，效果与下面循环语句全然同样：
```
     for (int i = off; i < off + len; i++)
         dst.put(a[i]); 
```
差别在于它首先检查此缓冲区中是否有足够空间。这样可能效率更高。
參数：
src - 要从中读取 short 的数组
offset - 要读取的第一个 short 在数组中的偏移量；必须为非负且不大于 array.length
length - 要从给定数组读取的 short 数量；必须为非负且不大于 array.length - offset
返回：
此缓冲区
抛出：
BufferOverflowException - 假设此缓冲区没有足够空间
IndexOutOfBoundsException - 假设关于 offset 和 length 參数的前提不成立
ReadOnlyBufferException - 假设此缓冲区是仅仅读的
15、public final ShortBuffer put(short[] src)
相对批量 put 方法（可选操作）。
此方法将给定源 short 数组中的全部内容传输到此缓冲区中。调用此方法的形式为 dst.put(a)，该调用与下面调用全然同样：
```
     dst.put(a, 0, a.length) 
```
返回：
此缓冲区
抛出：
BufferOverflowException - 假设此缓冲区没有足够空间
ReadOnlyBufferException - 假设此缓冲区是仅仅读的
16、public final boolean hasArray()
推断是否可通过一个可訪问的 short 数组实现此缓冲区。

假设此方法返回 true，则能够安全地调用 array 和 arrayOffset 方法。

指定者：
类 Buffer 中的 hasArray

返回：
当且仅当存在实现此缓冲区的数组，而且此缓冲区不是仅仅读缓冲区时，返回 true
17、public final short[] array()

返回实现此缓冲区的 short 数组（可选操作）。
此缓冲区的内容改动将导致返回的数组内容改动。反之亦然。

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

指定者：
类 Buffer 中的 array

返回：
实现此缓冲区的数组
抛出：
ReadOnlyBufferException - 假设存在实现此缓冲区的数组。但缓冲区是仅仅读的
UnsupportedOperationException - 假设不存在某个可訪问的数组实现此缓冲区
18、public final int arrayOffset()

返回此缓冲区的第一个元素在缓冲区的底层实现数组中的偏移量（可选操作）。
假设存在实现此缓冲区的数组，则缓冲区位置 p 相应于数组索引 p + arrayOffset()。

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

指定者：
类 Buffer 中的 arrayOffset

返回：
此缓冲区的第一个元素在缓冲区数组中的偏移量
抛出：
ReadOnlyBufferException - 假设存在实现此缓冲区的数组。但缓冲区是仅仅读的
UnsupportedOperationException - 假设不存在某个可訪问的数组实现此缓冲区
19、public abstract ShortBuffer compact()

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

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

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

返回：
此缓冲区
抛出：
ReadOnlyBufferException - 假设此缓冲区是仅仅读的
20、public abstract boolean isDirect()

推断此 short 缓冲区是否为直接的。

指定者：
类 Buffer 中的 isDirect

返回：
当且仅当此缓冲区为直接时。返回 true
21、public String toString() 返回总结了此缓冲区状态的字符串。

返回：一个总结字符串

22、public int hashCode()

返回此缓冲区的当前哈希码。

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

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

覆盖：
类 Object 中的 hashCode

返回：
此缓冲区的当前哈希码
23、public boolean equals(Object ob)
推断此缓冲区是否与还有一个对象同样。
两个 short 缓冲区是同样的。当且仅当：
1. 它们具有同样的元素类型，
2. 它们具有同样数量的剩余元素，而且
3. 两个剩余元素序列（与它们的起始位置无关）逐点同样。
short 缓冲区与不论什么其它类型的对象都不同。
覆盖：
类 Object 中的 equals

參数：
ob - 此缓冲区要比較的对象
返回：
当且仅当此缓冲区与给定对象同样时，返回 true
24、public int compareTo(ShortBuffer that)

将此缓冲区与还有一个缓冲区进行比較。

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

short 缓冲区不能与不论什么其它类型的对象进行比較。

指定者：
接口 Comparable<ShortBuffer> 中的 compareTo

參数：
that - 要比較的对象。
返回：
假设此缓冲区小于、等于或大于给定缓冲区。则对应返回负整数、零或正整数
25、public abstract ByteOrder order()

获取此缓冲区的字节顺序。

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

返回：
此缓冲区的字节顺序

查看全文

相关阅读:
1.0-springboot的java配置方式
关于springboot启动的问题.
关于Springboot整合mybatis启动的问题
关于IDEA无法引入包和类的情况
关于SpringBoot bean无法注入的问题（与文件包位置有关）改变自动扫描的包
PostgerSQL 解决锁表
git 合并冲突后回滚到之前版本
双重检查锁实现单例
SpringBoot事务
SQL性能优化

原文地址：https://www.cnblogs.com/wzjhoutai/p/7136849.html