com.sun.jna.Pointer类的方法

最新推荐文章于 2023-11-29 22:26:04 发布

zhong_da

最新推荐文章于 2023-11-29 22:26:04 发布

阅读量7.2k

点赞数 3

版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文链接：https://blog.csdn.net/zhong_da/article/details/116235970

版权

官方文档

初始化Pointer时的长度是使用的数组字节数的倍数

com.sun.jna

类指针

java.lang.Object
com.sun.jna.Pointer

直接已知子类：

功能，记忆
```
公共类指针
扩展Object
```
本机指针数据类型的抽象。在Java方面，Pointer实例表示一个本机指针。本机指针可以是任何类型的本机指针。方法，例如write， read，getXXX，和setXXX，提供手段来访问存储器中的本地指针底层。
虽然存在构造函数以根据整数值创建Pointer，但通常不是以这种方式创建指针是一个好主意。

作者：

盛亮，发起人，Todd Fast，适用性修改，Timothy Wall，强大的库加载

也可以看看：

Function

方法总结

**所有方法静态方法实例方法具体方法不推荐使用的方法**
修饰符和类型	方法和说明
`void`	`clear(long size)` 对于给定的字节数，内存为零。
`static Pointer`	`createConstant(int peer)` *便利常数，等于`(void)CONSTANT`。**
`static Pointer`	`createConstant(long peer)` *便利常数，等于`(void)CONSTANT`。**
`String`	`dump(long offset, int size)` 转储内存以进行调试。
`boolean`	`equals(Object o)` 将此`Pointer`与指定对象进行比较。
`byte`	`getByte(long offset)` 间接将本机指针作为的指针`byte`。
`byte[]`	`getByteArray(long offset, int arraySize)` 从this中读取`arraySize`给定大小的本地字节数组。`offsetPointer`
`ByteBuffer`	`getByteBuffer(long offset, long length)` 获取映射到指针指向的内存的ByteBuffer，确保缓冲区使用本机字节顺序。
`char`	`getChar(long offset)` 间接将本机指针作为的指针`wchar_t`。
`char[]`	`getCharArray(long offset, int arraySize)` 从this中读取`arraySize`给定大小的wchar_t的本机数组。`offsetPointer`
`double`	`getDouble(long offset)` 间接将本机指针作为的指针`double`。
`double[]`	`getDoubleArray(long offset, int arraySize)` 从this中读取`arraySize`给定大小的双精度数组。`offsetPointer`
`float`	`getFloat(long offset)` 间接将本机指针作为的指针`float`。
`float[]`	`getFloatArray(long offset, int arraySize)` 从this中读取`arraySize`给定大小的本地float数组。`offsetPointer`
`int`	`getInt(long offset)` 间接将本机指针作为的指针`int`。
`int[]`	`getIntArray(long offset, int arraySize)` 从this中读取`arraySize`给定的int32大小的本机数组。`offsetPointer`
`long`	`getLong(long offset)` 间接将本机指针作为的指针`long`。
`long[]`	`getLongArray(long offset, int arraySize)` 从this中读取`arraySize`给定的int64大小的本机数组。`offsetPointer`
`NativeLong`	`getNativeLong(long offset)` 间接将本机指针作为的指针`long`。
`Pointer`	`getPointer(long offset)` 间接将本机指针作为指向指针的指针。
`Pointer[]`	`getPointerArray(long offset)` 返回的数组`Pointer`。
`Pointer[]`	`getPointerArray(long offset, int arraySize)` 返回`Pointer`所请求大小的数组。
`short`	`getShort(long offset)` 间接将本机指针作为的指针`short`。
`short[]`	`getShortArray(long offset, int arraySize)` 从this中读取`arraySize`给定的int16大小的本机数组。`offsetPointer`
`String`	`getString(long offset)` 将本机内存复制到Java字符串。
`String`	`getString(long offset, boolean wide)` 不推荐使用。使用`getString(long,String)`或`getWideString(long)`代替。
`String`	`getString(long offset, String encoding)` 使用请求的编码将本机内存复制到Java String。
`String[]`	`getStringArray(long offset)` *`String`根据的原生数组返回的数组`char `。**
`String[]`	`getStringArray(long offset, boolean wide)` 不推荐使用。使用`getStringArray(long,String)`或`getWideStringArray(long)`代替。
`String[]`	`getStringArray(long offset, int length)` *使用给定的数组长度，`String`基于的原始数组返回的数组`char `。**
`String[]`	`getStringArray(long offset, int length, boolean wide)` 不推荐使用。使用`getStringArray(long,int,String)`或`getWideStringArray(long,int)`代替。
`String[]`	`getStringArray(long offset, int length, String encoding)` *返回的阵列`String`基于的天然阵列上`char`或`wchar_t`基于所述 `wide`参数，使用给定的阵列长度。*
`String[]`	`getStringArray(long offset, String encoding)` *使用请求的编码，`String`基于的本地数组返回一个数组`char `。**
`(package private) Object`	`getValue(long offset, Class type, Object currentValue)`
`String`	`getWideString(long offset)` *`const wchar_t `从内存中读取一个宽（）字符串。**
`String[]`	`getWideStringArray(long offset)`
`String[]`	`getWideStringArray(long offset, int length)`
`int`	`hashCode()` 返回此`Pointer`对象表示的本机指针的哈希码
`long`	`indexOf(long offset, byte value)` 返回内存中给定值与给定偏移量之间的偏移量；如果未找到该值，则返回-1。
`static long`	`nativeValue(Pointer p)` 读取本地对等值。
`static void`	`nativeValue(Pointer p, long value)` 设置本地对等值。
`void`	`read(long offset, byte[] buf, int index, int length)` 间接本地指针，复制从存储器所指向的本机指针，到指定的数组。
`void`	`read(long offset, char[] buf, int index, int length)` 间接本地指针，复制从存储器所指向的本机指针，到指定的数组。
`void`	`read(long offset, double[] buf, int index, int length)` 间接本地指针，复制从存储器所指向的本机指针，到指定的数组。
`void`	`read(long offset, float[] buf, int index, int length)` 间接本地指针，复制从存储器所指向的本机指针，到指定的数组。
`void`	`read(long offset, int[] buf, int index, int length)` 间接本地指针，复制从存储器所指向的本机指针，到指定的数组。
`void`	`read(long offset, long[] buf, int index, int length)` 间接本地指针，复制从存储器所指向的本机指针，到指定的数组。
`void`	`read(long offset, Pointer[] buf, int index, int length)` 间接本地指针，复制从存储器所指向的本机指针，到指定的数组。
`void`	`read(long offset, short[] buf, int index, int length)` 间接本地指针，复制从存储器所指向的本机指针，到指定的数组。
`void`	`setByte(long offset, byte value)` 设置`value`在要指向的位置。
`void`	`setChar(long offset, char value)` 设置`value`在要指向的位置。
`void`	`setDouble(long offset, double value)` 设置`value`在要指向的位置。
`void`	`setFloat(long offset, float value)` 设置`value`在要指向的位置。
`void`	`setInt(long offset, int value)` 设置`value`在要指向的位置。
`void`	`setLong(long offset, long value)` 设置`value`在要指向的位置。
`void`	`setMemory(long offset, long length, byte value)` 写入`value`请求的内存库。
`void`	`setNativeLong(long offset, NativeLong value)` 设置`value`在要指向的位置。
`void`	`setPointer(long offset, Pointer value)` 设置`value`在要指向的位置。
`void`	`setShort(long offset, short value)` 设置`value`在要指向的位置。
`void`	`setString(long offset, String value)` `value`使用指示的编码，将字符串中的字节复制到指向的位置`Native.getDefaultStringEncoding()`。
`void`	`setString(long offset, String value, boolean wide)` 不推荐使用。使用`setWideString(long,String)`代替。
`void`	`setString(long offset, String value, String encoding)` `value`使用请求的编码将字符串复制到指向的位置。
`void`	`setString(long offset, WString value)` *将字符串复制`value`到指向宽字符串（`wchar_t`）的位置。**
`(package private) void`	`setValue(long offset, Object value, Class type)`
`void`	`setWideString(long offset, String value)` *将字符串复制`value`到指向宽字符串（`wchar_t`）的位置。**
`Pointer`	`share(long offset)` 使用给定的偏移量提供此存储器的视图，以计算新的基址。
`Pointer`	`share(long offset, long sz)` 使用给定的偏移量提供此内存的视图以计算新的基地址，以给定的大小限制内存。
`String`	`toString()`
`void`	`write(long offset, byte[] buf, int index, int length)` *从指定数组间接复制本机指针，并将其复制到本机指针指向的内存中。*
`void`	`write(long offset, char[] buf, int index, int length)` *从指定数组间接复制本机指针，并将其复制到本机指针指向的内存中。*
`void`	`write(long offset, double[] buf, int index, int length)` *从指定数组间接复制本机指针，并将其复制到本机指针指向的内存中。*
`void`	`write(long offset, float[] buf, int index, int length)` *从指定数组间接复制本机指针，并将其复制到本机指针指向的内存中。*
`void`	`write(long offset, int[] buf, int index, int length)` *从指定数组间接复制本机指针，并将其复制到本机指针指向的内存中。*
`void`	`write(long offset, long[] buf, int index, int length)` *从指定数组间接复制本机指针，并将其复制到本机指针指向的内存中。*
`void`	`write(long bOff, Pointer[] buf, int index, int length)` 将给定的Pointer数组写入本地内存。
`void`	`write(long offset, short[] buf, int index, int length)` *从指定数组间接复制本机指针，并将其复制到本机指针指向的内存中。*

从类java.lang继承的方法。目的
clone, finalize, getClass, notify, notifyAll, wait, wait, wait

构造器摘要

建设者
构造函数和描述
Pointer()
派生类必须分配对等指针值。

Pointer(long peer)
从本机指针创建。

领域摘要

领域
修饰符和类型	栏位及说明
`static Pointer`	`NULL` 便利常数，与相同`null`。
`protected long`	`peer` 真正的本机指针的指针值。
`static int`	`SIZE` 本机指针的大小，以字节为单位。

方法细节
- createConstant
```
公共静态最终 指针 createConstant（长同级）
```
  便利常数，等于(void*)CONSTANT。
- createConstant
```
公共静态最终 指针 createConstant（int peer）
```
  便利常数，等于(void*)CONSTANT。此版本将避免在64位系统上设置任何高位。
- 分享
```
公共 指针 共享（长偏移量）
```
  使用给定的偏移量提供此存储器的视图，以计算新的基址。
- 分享
```
公共 指针 共享（长偏移量，
                     长sz）
```
  使用给定的偏移量提供此内存的视图以计算新的基地址，以给定的大小限制内存。
- 清除
```
公共空隙清晰（长尺寸）
```
  对于给定的字节数，内存为零。
- 等于
```
public boolean equals（Object  o）
```
  将此Pointer与指定对象进行比较。
  
  覆写：
  
  equals 在班上 Object
  
  参数：
  
  o-一个Pointer实例
  
  返回值：
  
  如果另一个对象是a Pointer，则为true ，并且这些对象所指向的C指针也相等。否则返回false。
- hashCode
```
public int hashCode（）
```
  返回此Pointer对象表示的本机指针的哈希码
  
  覆写：
  
  hashCode 在班上 Object
  
  返回值：
  
  所表示的本机指针的哈希码值
- 指数
```
公共long indexOf（长偏移量，
                    字节值）
```
  返回内存中给定值与给定偏移量之间的偏移量；如果未找到该值，则返回-1。
- 读
```
公共无效读取（长偏移量，
                 字节[] buf，
                 整数索引，
                 整数长度）
```
  间接本地指针，复制从存储器所指向的本机指针，到指定的数组。
  
  参数：
  
  offset -从数据复制到的指针的字节偏移
  
  buf-byte将数据复制到的数组
  
  index -从其开始复制的数组索引
  
  length -必须复制的本机指针中的元素数
- 读
```
公共无效读取（长偏移量，
                 short [] buf，
                 int索引，
                 int长度）
```
  间接本地指针，复制从存储器所指向的本机指针，到指定的数组。
  
  参数：
  
  offset -从要复制数据的指针的字节偏移
  
  buf-short将数据复制到的数组
  
  index -将数据复制到的数组索引
  
  length -必须复制的本机指针中的元素数
- 读
```
公共无效读取（长偏移量，
                 char [] buf，
                 int索引，
                 int长度）
```
  间接本地指针，复制从存储器所指向的本机指针，到指定的数组。
  
  参数：
  
  offset -从要复制数据的指针的字节偏移
  
  buf-char将数据复制到的数组
  
  index -将数据复制到的数组索引
  
  length -必须复制的本机指针中的元素数
- 读
```
公共无效读取（长偏移量，
                 int [] buf，
                 int索引，
                 int长度）
```
  间接本地指针，复制从存储器所指向的本机指针，到指定的数组。
  
  参数：
  
  offset -从要复制数据的指针的字节偏移
  
  buf-int将数据复制到的数组
  
  index -将数据复制到的数组索引
  
  length -必须复制的本机指针中的元素数
- 读
```
公共无效读取（长偏移量，
                 长[] buf，
                 整数索引，
                 整数长度）
```
  间接本地指针，复制从存储器所指向的本机指针，到指定的数组。
  
  参数：
  
  offset -从要复制数据的指针的字节偏移
  
  buf-long将数据复制到的数组
  
  index -将数据复制到的数组索引
  
  length -必须复制的本机指针中的元素数
- 读
```
公共无效读取（长偏移量，
                 float []，buf，
                 int索引，
                 int长度）
```
  间接本地指针，复制从存储器所指向的本机指针，到指定的数组。
  
  参数：
  
  offset -从要复制数据的指针的字节偏移
  
  buf-float将数据复制到的数组
  
  index -将数据复制到的数组索引
  
  length -必须复制的本机指针中的元素数
- 读
```
公共无效读取（长偏移量，
                 double [] buf，
                 int索引，
                 int长度）
```
  间接本地指针，复制从存储器所指向的本机指针，到指定的数组。
  
  参数：
  
  offset -从要复制数据的指针的字节偏移
  
  buf-double将数据复制到的数组
  
  index -将数据复制到的数组索引
  
  length -必须复制的本机指针中的元素数
- 读
```
公共无效读取（长偏移量，
                 指针[]，buf，
                 int索引，
                 int长度）
```
  间接本地指针，复制从存储器所指向的本机指针，到指定的数组。
  
  参数：
  
  offset -从要复制数据的指针的字节偏移
  
  buf-Pointer将数据复制到的数组
  
  index -将数据复制到的数组索引
  
  length -必须复制的本机指针中的元素数
- 写
```
公共无效写入（长偏移量，
                  字节[] buf，
                  整数索引，
                  整数长度）
```
  从指定数组间接复制本机指针，并将其复制到本机指针指向的内存中。
  
  参数：
  
  offset -从数据复制到的指针的字节偏移
  
  buf-byte从中复制的数组
  
  index -从其开始复制的数组索引
  
  length-buf必须复制其中的元素数量
- 写
```
公共无效写入（长偏移量，
                  short [] buf，
                  int索引，
                  int长度）
```
  从指定数组间接复制本机指针，并将其复制到本机指针指向的内存中。
  
  参数：
  
  offset -从数据复制到的指针的字节偏移
  
  buf-short从中复制的数组
  
  index -从其开始复制的数组索引
  
  length-buf必须复制其中的元素数量
- 写
```
公共无效写入（长偏移量，
                  char [] buf，
                  int索引，
                  int长度）
```
  从指定数组间接复制本机指针，并将其复制到本机指针指向的内存中。
  
  参数：
  
  offset -从数据复制到的指针的字节偏移
  
  buf-char从中复制的数组
  
  index -从其开始复制的数组索引
  
  length-buf必须复制其中的元素数量
- 写
```
公共无效写入（长偏移量，
                  int [] buf，
                  int索引，
                  int长度）
```
  从指定数组间接复制本机指针，并将其复制到本机指针指向的内存中。
  
  参数：
  
  offset -从数据复制到的指针的字节偏移
  
  buf-int从中复制的数组
  
  index -从其开始复制的数组索引
  
  length-buf必须复制其中的元素数量
- 写
```
公共无效写入（长偏移量，
                  长[]错误，
                  整数索引，
                  整数长度）
```
  从指定数组间接复制本机指针，并将其复制到本机指针指向的内存中。
  
  参数：
  
  offset -从数据复制到的指针的字节偏移
  
  buf-long从中复制的数组
  
  index -从其开始复制的数组索引
  
  length-buf必须复制其中的元素数量
- 写
```
公共无效写入（长偏移量，
                  float []，buf，
                  int索引，
                  int长度）
```
  从指定数组间接复制本机指针，并将其复制到本机指针指向的内存中。
  
  参数：
  
  offset -从数据复制到的指针的字节偏移
  
  buf-float从中复制的数组
  
  index -从其开始复制的数组索引
  
  length-buf必须复制其中的元素数量
- 写
```
公共无效写入（长偏移量，
                  double [] buf，
                  int索引，
                  int长度）
```
  从指定数组间接复制本机指针，并将其复制到本机指针指向的内存中。
  
  参数：
  
  offset -从数据复制到的指针的字节偏移
  
  buf-double从中复制的数组
  
  index -从其开始复制的数组索引
  
  length-buf必须复制其中的元素数量
- 写
```
公共无效写入（长bOff，
                  指针[]，buf，
                  int索引，
                  int长度）
```
  将给定的Pointer数组写入本地内存。
  
  参数：
  
  bOff -从数据复制到的指针的字节偏移
  
  buf-Pointer从中复制的数组
  
  index -从其开始复制的数组索引
  
  length-buf必须复制其中的元素数量
- getValue
```
对象 getValue（长偏移量，
                类 类型，
                对象 currentValue）
```
- getByte
```
公共字节getByte（长偏移量）
```
  间接将本机指针作为的指针byte。这等效于表达式 *((jbyte *)((char *)Pointer + offset))。
  
  参数：
  
  offset -从指针偏移以执行间接
  
  返回值：
  
  byte所指向的值
- getChar
```
公共字符getChar（长偏移量）
```
  间接将本机指针作为的指针wchar_t。这等效于表达式 *((wchar_t*)((char *)Pointer + offset))。
  
  参数：
  
  offset -从指针偏移以执行间接
  
  返回值：
  
  wchar_t所指向的值
- getShort
```
公共短getShort（长偏移量）
```
  间接将本机指针作为的指针short。这等效于表达式 *((jshort *)((char *)Pointer + offset))。
  
  参数：
  
  offset -从指针开始执行间接寻址的字节偏移量
  
  返回值：
  
  short所指向的值
- getInt
```
public int getInt（长偏移量）
```
  间接将本机指针作为的指针int。这等效于表达式 *((jint *)((char *)Pointer + offset))。
  
  参数：
  
  offset -从指针开始执行间接寻址的字节偏移量
  
  返回值：
  
  int所指向的值
- getLong
```
公共long getLong（长偏移量）
```
  间接将本机指针作为的指针long。这等效于表达式 *((jlong *)((char *)Pointer + offset))。
  
  参数：
  
  offset -从指针开始执行间接寻址的字节偏移量
  
  返回值：
  
  long所指向的值
- getNativeLong
```
public  NativeLong  getNativeLong（长偏移量）
```
  间接将本机指针作为的指针long。这等效于表达式 *((long *)((char *)Pointer + offset))。
  
  参数：
  
  offset -从指针开始执行间接寻址的字节偏移量
  
  返回值：
  
  long所指向的值
- getFloat
```
public float getFloat（长偏移量）
```
  间接将本机指针作为的指针float。这等效于表达式 *((jfloat *)((char *)Pointer + offset))。
  
  参数：
  
  offset -从指针开始执行间接寻址的字节偏移量
  
  返回值：
  
  float所指向的值
- getDouble
```
public double getDouble（长偏移量）
```
  间接将本机指针作为的指针double。这等效于表达式 *((jdouble *)((char *)Pointer + offset))。
  
  参数：
  
  offset -从指针开始执行间接寻址的字节偏移量
  
  返回值：
  
  double所指向的值
- getPointer
```
公共 指针 getPointer（长偏移量）
```
  间接将本机指针作为指向指针的指针。这等效于表达式 *((void **)((char *)Pointer + offset))。
  
  参数：
  
  offset -从指针开始执行间接寻址的字节偏移量
  
  返回值：
  
  一个Pointer指针值的等效被指向的，或者null如果该指针值是 NULL;
- getByteBuffer
```
公共 ByteBuffer  getByteBuffer（长偏移量，
                                长长度）
```
  获取映射到指针指向的内存的ByteBuffer，确保缓冲区使用本机字节顺序。
  
  参数：
  
  offset -从指针开始启动缓冲区的字节偏移
  
  length -ByteBuffer的长度
  
  返回值：
  
  直接ByteBuffer用来访问所指向的内存，
- getString
```
公共 字符串 getString（长偏移量，
                        布尔值宽）
```
  不推荐使用。 使用getString(long,String)或getWideString(long)代替。
  
  将本机内存复制到Java字符串。如果wide为true，则使用默认平台编码将内存作为数组访问wchar_t，否则以数组访问内存char。
  
  参数：
  
  offset -从指针获得的字节偏移，以获取本地字符串v * @param width，是从宽字符串还是标准C字符串转换
  
  返回值：
  
  String所指向的值
- getWideString
```
公共 字符串 getWideString（长偏移量）
```
  const wchar_t *从内存中读取一个宽（）字符串。
- getString
```
公共 字符串 getString（长偏移量）
```
  将本机内存复制到Java字符串。所使用的编码是从获得的Native.getDefaultStringEncoding()。
  
  参数：
  
  offset -从指针到开始读取字节的字节偏移
  
  返回值：
  
  String所指向的值
- getString
```
公共 字符串 getString（长偏移量，
                        字符串 编码）
```
  使用请求的编码将本机内存复制到Java String。
  
  参数：
  
  offset -从指针获得本地字符串的字节偏移
  
  encoding -所需的编码
  
  返回值：
  
  String所指向的值
- getByteArray
```
public byte [] getByteArray（long offset，
                           int arraySize ）
```
  从this中读取arraySize给定大小的本地字节数组。offsetPointer
- getCharArray
```
公共char [] getCharArray（long offset，
                           int arraySize ）
```
  从this中读取arraySize给定大小的wchar_t的本机数组。offsetPointer
- getShortArray
```
public short [] getShortArray（long offset，
                             int arraySize）
```
  从this中读取arraySize给定的int16大小的本机数组。offsetPointer
- getIntArray
```
public int [] getIntArray（long offset，
                         int arraySize ）
```
  从this中读取arraySize给定的int32大小的本机数组。offsetPointer
- getLongArray
```
public long [] getLongArray（long offset，
                           int arraySize ）
```
  从this中读取arraySize给定的int64大小的本机数组。offsetPointer
- getFloatArray
```
public float [] getFloatArray（long offset，
                             int arraySize）
```
  从this中读取arraySize给定大小的本地float数组。offsetPointer
- getDoubleArray
```
public double [] getDoubleArray（long offset，
                               int arraySize）
```
  从this中读取arraySize给定大小的双精度数组。offsetPointer
- getPointerArray
```
公共 指针[] getPointerArray（长偏移量）
```
  返回的数组Pointer。数组长度由NULL值的终止元素确定。
- getPointerArray
```
公共 指针[] getPointerArray（long offset，
                                 int arraySize）
```
  返回Pointer所请求大小的数组。
- getStringArray
```
公共 字符串[] getStringArray（长偏移量）
```
  String根据的原生数组返回的数组char *。数组长度由NULL值的终止元素确定。
  使用返回的编码对字符串进行解码Native.getDefaultStringEncoding()。
- getStringArray
```
public  String [] getStringArray（长偏移量，
                               字符串 编码）
```
  使用请求的编码，String基于的本地数组返回一个数组char *。数组长度由NULL值的终止元素确定。
- getStringArray
```
公共 字符串[] getStringArray（long offset，
                               int length）
```
  使用给定的数组长度，String基于的原始数组返回的数组char *。
  使用返回的编码对字符串进行解码Native.getDefaultStringEncoding()。
- getStringArray
```
public  String [] getStringArray（long offset，
                               boolean width）
```
  不推荐使用。 使用getStringArray(long,String)或getWideStringArray(long)代替。
  
  返回String基于char*或wchar_t*基于 wide参数的本机数组的数组。数组长度由NULL值的终止元素确定。
- getWideStringArray
```
公共 字符串[] getWideStringArray（长偏移量）
```
- getWideStringArray
```
公共 字符串[] getWideStringArray（长偏移量，
                                   整数长度）
```
- getStringArray
```
public  String [] getStringArray（长偏移量，
                               整数长度，
                               布尔值宽）
```
  不推荐使用。 使用getStringArray(long,int,String)或getWideStringArray(long,int)代替。
  
  返回的阵列String基于的天然阵列上char*或wchar_t*基于所述 wide参数，使用给定的阵列长度。
- getStringArray
```
public  String [] getStringArray（长偏移量，
                               整数长度，字符串 编码）
                               
```
  返回的阵列String基于的天然阵列上char*或wchar_t*基于所述 wide参数，使用给定的阵列长度。
  
  参数：
  
  offset --
  
  length --
  
  encoding --
- 设定值
```
void setValue（长偏移量，
              对象 值，
              类 类型）
```
- setMemory
```
公共无效setMemory（长偏移量，
                      长长度，
                      字节值）
```
  写入value请求的内存库。
  
  参数：
  
  offset -从指针到开始的字节偏移
  
  length -要写入的字节数
  
  value -要写的值
- setByte
```
公共无效setByte（长偏移量，
                    字节值）
```
  设置value在要指向的位置。这等效于表达式 *((jbyte *)((char *)Pointer + offset)) = value。
  
  参数：
  
  offset-value 必须设置的指针的字节偏移量
  
  value-byte要设置的值
- setShort
```
公共无效setShort（长偏移量，
                     短值）
```
  设置value在要指向的位置。这等效于表达式 *((jshort *)((char *)Pointer + offset)) = value。
  
  参数：
  
  offset-value 必须设置的指针的字节偏移量
  
  value-short要设置的值
- setChar
```
公共无效setChar（长偏移量，
                    char值）
```
  设置value在要指向的位置。这等效于表达式 *((wchar_t *)((char *)Pointer + offset)) = value。
  
  参数：
  
  offset-value 必须设置的指针的字节偏移量
  
  value-char要设置的值
- setInt
```
公共无效setInt（长偏移量，
                   int值）
```
  设置value在要指向的位置。这等效于表达式 *((jint *)((char *)Pointer + offset)) = value。
  
  参数：
  
  offset-value 必须设置的指针的字节偏移量
  
  value-int要设置的值
- setLong
```
public void setLong（长偏移量，
                    长值）
```
  设置value在要指向的位置。这等效于表达式 *((jlong *)((char *)Pointer + offset)) = value。
  
  参数：
  
  offset-value 必须设置的指针的字节偏移量
  
  value-long要设置的值
- setNativeLong
```
public void setNativeLong（长偏移量，
                           NativeLong 值）
```
  设置value在要指向的位置。这等效于表达式 *((long *)((char *)Pointer + offset)) = value。
  
  参数：
  
  offset-value 必须设置的指针的字节偏移量
  
  value-long要设置的值
- setFloat
```
公共无效setFloat（长偏移量，
                     浮点值）
```
  设置value在要指向的位置。这等效于表达式 *((jfloat *)((char *)Pointer + offset)) = value。
  
  参数：
  
  offset-value 必须设置的指针的字节偏移量
  
  value-float要设置的值
- setDouble
```
public void setDouble（长偏移量，
                      双精度值）
```
  设置value在要指向的位置。这等效于表达式 *((jdouble *)((char *)Pointer + offset)) = value。
  
  参数：
  
  offset-value 必须设置的指针的字节偏移量
  
  value-double要设置的值
- setPointer
```
公共无效setPointer（长偏移量，
                       指针 值）
```
  设置value在要指向的位置。这等效于表达式 *((void **)((char *)Pointer + offset)) = value。
  
  参数：
  
  offset-value 必须设置的指针的字节偏移量
  
  value-Pointer保留要设置的实际指针值，这可能null表示一个NULL 指针。
- setString
```
public void setString（长偏移量，
                      字符串 值，
                      布尔值宽）
```
  不推荐使用。 使用setWideString(long,String)代替。
  
  将字符串复制value到所指向的位置。
  
  参数：
  
  offset-与value必须设置字符的指针的字节偏移
  
  value-java.lang.String要设置的值
  
  wide-是否将本机字符串写为的数组 wchar_t。如果为false，则char使用表示的编码编写为NUL终止的数组 Native.getDefaultStringEncoding()。
- setWideString
```
公共无效setWideString（长偏移量，
                          字符串 值）
```
  将字符串复制value到指向宽字符串（wchar_t*）的位置。
  
  参数：
  
  offset-与value必须设置字符的指针的字节偏移
  
  value-java.lang.String要设置的值
- setString
```
公共无效setString（长偏移量，
                       WString 值）
```
  将字符串复制value到指向宽字符串（wchar_t*）的位置。
  
  参数：
  
  offset-与value必须设置字符的指针的字节偏移
  
  value-WString要设置的值
- setString
```
公共无效setString（长偏移量，
                      字符串 值）
```
  value使用指示的编码，将字符串中的字节复制到指向的位置Native.getDefaultStringEncoding()。
  
  参数：
  
  offset-与value必须设置字符的指针的字节偏移
  
  value-java.lang.String要设置的值
- setString
```
公共无效setString（长偏移量，
                      字符串 值，
                      字符串 编码）
```
  value使用请求的编码将字符串复制到指向的位置。
  
  参数：
  
  offset-与value必须设置字符的指针的字节偏移
  
  value-java.lang.String要设置的值
  
  encoding -所需的编码
- 倾倒
```
公共 字符串 转储（长偏移量，
                   整数大小）
```
  转储内存以进行调试。
- ```
公共 字符串 toString（）
```
  覆写：
  
  toString 在班上 Object
- nativeValue
```
公共静态长nativeValue（指针 p）
```
  读取本地对等值。请谨慎使用。
- nativeValue
```
公共静态无效值nativeValue（指针 p，
                               长值）
```
  设置本地对等值。请谨慎使用。
构造器详细信息
- 指针
```
指针（）
```
  派生类必须分配对等指针值。
- 指针
```
公共指针（长同伴）
```
  从本机指针创建。除非您知道自己在做什么，否则不要使用它。
栏位详细
- 尺寸
```
公共静态最终int SIZE
```
  本机指针的大小，以字节为单位。
- 空值
```
公共静态最终 指针NULL
```
  便利常数，与相同null。
- 同伴
```
受保护的长期同伴
```
  真正的本机指针的指针值。请长期使用以确保64位安全。

关注

3
点赞
踩
14

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫

zhong_da CSDN认证博客专家 CSDN认证企业博客

码龄7年

6: 原创

42万+: 周排名

14万+: 总排名

2万+: 访问

: 等级

80: 积分

7: 粉丝

13: 获赞

1: 评论

35: 收藏

私信

关注

热门文章

最新评论

ClickHouse 日期函数
CSDN-Ada助手: 恭喜您成功发布了第7篇博客，内容也十分实用！对于ClickHouse日期函数的介绍，我也从中学到了很多。建议下一篇博客可以继续深入探讨ClickHouse的其他函数或者介绍一些实际应用案例，这样可以让读者更好地理解和运用。期待您的下一篇佳作！ CSDN 会根据你创作的博客的质量，给予优秀的博主博客红包奖励。请关注 https://bbs.csdn.net/forums/csdnnews?typeId=116148&utm_source=csdn_ai_ada_blog_reply7 看奖励名单。
spring boot操作ES（简版）
CSDN-Ada助手: 恭喜您写出了这篇关于spring boot操作ES的博客！文章内容简明扼要，很容易理解，对读者来说十分实用。接下来，建议您可以继续深入研究这方面的知识，例如如何使用更高级的ES功能，或者结合其他框架进行更复杂的应用。期待您的下一篇精彩博客！ CSDN 会根据你创作的博客的质量，给予优秀的博主博客红包奖励。请关注 https://bbs.csdn.net/forums/csdnnews?typeId=116148&utm_source=csdn_ai_ada_blog_reply6 看奖励名单。
yum makecache 报错
小羊的预备程序员: 大佬牛逼，真心的牛，我搞了一天了，各种教程都没用，阿里云环境也不行404

最新文章

目录

评论

被折叠的条评论为什么被折叠?

到【灌水乐园】发言

查看更多评论

添加红包

成就一亿技术人!

hope_wisdom

发出的红包

实付元

使用余额支付

点击重新获取

扫码支付

钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。