JNI/NDK入门指南之JNI访问数组

最新推荐文章于 2024-02-20 19:29:01 发布
最新推荐文章于 2024-02-20 19:29:01 发布
阅读量4k 收藏 22
点赞数 8
分类专栏： JNI/NDK入门指南 文章标签： JNI JNI访问数组 NewIntArray NewObjectArray GetArrayLength
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/tkwxty/article/details/103665532
版权

        JNI/NDK入门指南之JNI访问数组


Android JNI/NDK入门指南目录

JNI/NDK入门指南之正确姿势了解JNI和NDK
JNI/NDK入门指南之JavaVM和JNIEnv
JNI/NDK入门指南之JNI数据类型，描述符详解
JNI/NDK入门指南之jobject和jclass
JNI/NDK入门指南之javah和javap的使用和集成
JNI/NDK入门指南之Eclipse集成NDK开发环境并使用
JNI/NDK入门指南之JNI动/静态注册全分析
JNI/NDK入门指南之JNI字符串处理
JNI/NDK入门指南之JNI访问数组
JNI/NDK入门指南之C/C++通过JNI访问Java实例属性和类静态属性
JNI/NDK入门指南之C/C++通过JNI访问Java实例方法和类静态方法
JNI/NDK入门指南之JNI异常处理
JNI/NDK入门指南之JNI多线程回调Java方法
JNI/NDK入门指南之正确姿势了解，使用，管理，缓存JNI引用
JNI/NDK入门指南之调用Java构造方法和父类实例方法
JNI/NDK入门指南之C/C++结构体和Java对象转换方式一
JNI/NDK入门指南之C/C++结构体和Java对象转换方式二


  在前面的章节JNI/NDK入门指南之JNI字符串处理中讲解了JNI对字符串的处理流程。今天我们继续向JNI的知识海洋进军讲解JNI对数组的处理。本章内容有点多哦！


前言

JNI 中的数组分为基本类型数组和对象数组，它们的处理方式是不一样的，基本类型数组中的所有元素都是 JNI的基本数据类型，可以直接访问。而对象数组中的所有元素是一个类的实例或其它数组的引用，和字符串操作一样，不能直接访问 Java 传递给 JNI 层的数组，必须选择合适的 JNI 函数来访问和设置 Java 层的数组对象。阅读此文假设你已经了解了 JNI 与 Java 数据类型的映射关系，如果还不了解的，请仔细阅读篇章JNI/NDK入门指南之JNI数据类型，描述符详解，里面有详尽的解析。下面让我们从JNI的基本数组操作函数开始，一步步带领读者攻破JNI对数组的处理。



一. 初探JNI数组处理函数

好了有了前面知识的铺垫，下面让我们来看看JNIEnv为我们提供了那些常见的数组处理函数。

1.1 GetArrayLength

函数原型: jsize (GetArrayLength)(JNIEnv env, jarray array);
函数功能: 返回数组中的元素个数。
参数:

  • env: JNIEnv接口指针
  • array: Java通过JNI传递的Java数组对象

返回值: 数组的长度


1.2 NewObjectArray

函数原型: jobjectArray NewObjectArray (JNIEnv *env, jsize length, jclass elementClass, jobject initialElement);
函数功能: 构建JNI引用类型的数组，它将保存类 elementClass 中的对象。所有元素初始值均设为 initialElement，一般使用NULL就好。
参数：

  • env： JNIEnv接口指针
  • lenght: 数组大小
  • elementClass: 引用数组元素类
  • initialElement：初始值。通常为NULL

返回值： 返回需要创建的JNI引用类型数组对象。如果无法构造数组，则为NULL。
异常抛出: 如果系统内存不足,则抛出OutOfMemoryError异常


1.3 GetObjectArrayElement和SetObjectArrayElement

这对函数主要的功能是获取/设置数组元素的内容，下面我们分别对其介绍之:
GetObjectArrayElement

函数原型: jobject GetObjectArrayElement (JNIEnv *env, jobjectArray array, jsize index)
函数功能: 返回jobjectArray数组的元素，通常是获取JNI引用类型数组元素
参数:

  • env: JNIEnv接口指针
  • array: 通过JNI传递到C/C++层的Java引用数组
  • index: 数组下标

返回值:返回数组中index下标的对象
异常抛出: 如果 index 不是数组中的有效下标，则抛出ArrayIndexOutOfBoundsException异常

SetObjectArrayElement

函数原型: void SetObjectArrayElement (JNIEnv *env, jobjectArray array, jsize index, jobject value)
函数功能: 设置jobjectArray数组中index下标对象的值
参数:

  • env: JNIEnv接口指针

  • array:通过JNI传递到C/C++层的Java引用数

  • index: 数组下表值

  • value: 将要设置的新值

异常抛出: ArrayIndexOutOfBoundsException：如果 index 不是数组中的有效下标。 ArrayStoreException：如果 value 的类不是数组元素类的子类。


1.4 New<PrimitiveType>Array函数集

这里的PrimitiveType指代的是一系列的JNI基本数据类型。
函数原型: NativeTypeArray New<PrimitiveType>Array (JNIEnv* env, jsize size)

函数功能: 用于构造JNI基本类型数组对象的一系列操作。
使用说明： 在下表中会将特定的基本类型数组构造函数及其返回值一一对应。在实际应用中把PrimitiveType替换为某个实际的基本类型数据类型，然后再将NativeType替换成对应的JNI Native Type即可，。譬如我们以int型来说明，那么其对应的函数为：

    jintArray     (*NewIntArray)(JNIEnv*, jsize);

参数:

  • env: JNIEnv接口指针
  • lenght: 需要创建的数组的长度

返回值:返回JNI基本数据类型数组。如果无法构造该数组，则为 NULL。

NewPrimitiveTypeArray函数名NativeTypeArray 返回数组
NewBooleanArray()jbooleanArray
NewByteArray()jbyteArray
NewCharArray()jcharArray
NewShortArray()jshorArray
NewIntArray()jintArray
NewLongArrayjlongArray
NewFloatArray()jfloatArray
NewDoubleArrayjdoubleArray

1.5 Get/Release<PrimitiveType>ArrayElements函数集

这里的PrimitiveType指代的是一系列的JNI基本数据类型,这对函数一般都是成对使用，下面我们分别进行分析：
Get<PrimitiveType>ArrayElements

函数原型: NativeType* Get<PrimitiveType>ArrayElements(JNIEnv *env, NativeTypeArray array, jboolean *isCopy)
函数功能: 一组返回JNI基本数据类型数组的函数。结果在调用相应的 ReleasePrimitiveTypeArrayElements()函数前将一直有效。
使用说明: 在实际使用过程中将PrimitiveType替换成某个实际的基本类型元素访问函数，然后再将NativeType替换成对应的JNI Native Type即可，可以参见下面的表格。譬如我们以int型来说明，那么其对应的函数为：

jint*       (*GetIntArrayElements)(JNIEnv*, jintArray, jboolean*);

参数：

  • env：JNI 接口指针
  • array：Java基本类型数组对象
  • isCopy：指向布尔值的指针 ，该参数表示返回的数组指针是原始数组，还是拷贝原始数据到临时缓冲区的指针，如果是 JNI_TRUE：表示临时缓冲区数组指针，JNI_FALSE：表示临时原始数组指针

返回值： 返回指向数组元素的指针，如果操作失败，则为 NULL。

Get<PrimitiveType>ArrayElements函数集NativeTypeArray 数组类型NativeType
GetBooleanArrayElements()jbooleanArrayjboolean
GetByteArrayElements()jbyteArrayjbyte
GetCharArrayElements()jcharArrayjchar
GetShortArrayElements()jshortArrayjshort
GetIntArrayElements()jintArrayjint
GetLongArrayElements()jlongArrayjlong
GetFloatArrayElements()jfloatArrayjfloat
GetDoubleArrayElements()jdoubleArrayjdouble

Release<PrimitiveType>ArrayElements

函数原型: void Release<PrimitiveType>ArrayElements (JNIEnv *env, NativeTypeArray array, NativeType *elems,jint mode);
函数功能: 通知虚拟机平台相关代码无需再访问 elems 的一组函数。elems 参数是一个通过使用对应的GetPrimitiveTypeArrayElements() 函数由 array 导出的指针。必要时，该函数将把对 elems 的修改复制回基本类型数组。mode参数将提供有关如何释放数组缓冲区的信息。如果elems 不是 array 中数组元素的副本，mode将无效。
否则，mode 将具有下表所述的功能：

模式功能
0更新数组并释放elems 缓冲区
JNI_COMMIT更新但不释放elems 缓冲区
JNI_ABORT不作更新但释放elems缓冲区

通常开发情况下，编程人员将把“0”传给 mode 参数以确保数组内容保持一致。其它选项可以使编程人员进一 步控制内存管理，但使用时务必慎重。
使用说明: 将PrimitiveType替换成对应的数据类型，将NativeType 替换成JNI Native type类型，譬如我们以释放int数组为例：

    void        (*ReleaseIntArrayElements)(JNIEnv*, jintArray,
                        jint*, jint);

参数:

  • env：JNIENV接口指针
  • array：Java 基本类型数组对象
  • elems：指向数组元素的指针
  • mode：释放模式
Relase<PrimitiveType>ArrayElements函数集NativeTypeArray 数组类型NativeType
ReleaseBooleanArrayElements()jbooleanArrayjboolean
ReleaseByteArrayElements()jbyteArrayjbyte
ReleaseCharArrayElements()jcharArrayjchar
ReleaseShortArrayElements()jshortArrayjshort
ReleaseIntArrayElements()jintArrayjint
ReleaseLongArrayElements()jlongArrayjlong
ReleaseFloatArrayElements()jfloatArrayjfloat
ReleaseDoubleArrayElements()jdoubleArrayjdouble

1.6 Get/Set<PrimitiveType>ArrayRegion函数集

这里的PrimitiveType指代的是一系列的JNI基本数据类型,这对函数集分别用来将基本类型数组某一区域复制到缓冲区中的一组函数/将基本类型数组的某一区域从缓冲区中复制回来的一组函数,下面让我们来分别分析：
Get<PrimitiveType>ArrayRegion

函数原型：void Set<PrimitiveType>ArrayRegion (JNIEnv *env, NativeTypeArray array, jsize start, jsize len, NativeType *buf);

函数功能：将基本类型数组某一区域复制到缓冲区中的一组函数。
使用说明: 将PrimitiveType替换成对应的数据类型，将NativeType 替换成JNI Native type类型，譬如我们以释放int数组为例：

    void        (*GetIntArrayRegion)(JNIEnv*, jintArray,
                        jsize, jsize, jint*);

参数:

  • env：JNIEnv 接口指针
  • array: Java基本类型数组，源缓冲区
  • start：起始下标
  • len：要复制的元素长度
  • buf：目的缓冲区

异常抛出: 如果区域中的某个下标无效,将抛出ArrayIndexOutOfBoundsException异常。

函数集如下：

Get<PrimitiveType>ArrayRegion函数集NativeTypeArray 数组类型NativeType
GetBooleanArrayRegion()jbooleanArrayjboolean
GetByteArrayRegion()jbyteArrayjbyte
GetCharArrayRegion()jcharArrayjchar
GetShortArrayRegion()jshortArrayjshort
GetIntArrayRegion()jintArrayjint
GetLongArrayRegion()jlongArrayjlong
GetFloatArrayRegion()jfloatArrayjfloat
GetDoubleArrayRegion()jdoubleArrayjdouble

Set<PrimitiveType>ArrayRegion

函数原型：void Set<PrimitiveType>ArrayRegion (JNIEnv *env, NativeTypeArray array, jsize start, jsize len, const NativeType *buf);

函数功能：将缓冲区中的内容复制到基本数据类型数组的某一区域，有点类似memcpy函数功能。
使用说明: 将PrimitiveType替换成对应的数据类型，将NativeType 替换成JNI Native type类型，譬如我们以释放int数组为例：

    void        (*GetIntArrayRegion)(JNIEnv*, jintArray,
                        jsize, jsize, jint*);

参数:

  • env：JNIEnv 接口指针
  • array: Java基本类型数组 ，目的缓冲区
  • start：起始下标
  • len：要复制的元素长度
  • buf：源缓冲区

异常抛出: 如果区域中的某个下标无效,将抛出ArrayIndexOutOfBoundsException异常。

函数集如下：

SetArrayRegion函数集NativeTypeArray 数组类型NativeType
SetBooleanArrayRegion()jbooleanArrayjboolean
SetByteArrayRegion()jbyteArrayjbyte
SetCharArrayRegion()jcharArrayjchar
SetShortArrayRegion()jshortArrayjshort
SetIntArrayRegion()jintArrayjint
SetLongArrayRegion()jlongArrayjlong
SetFloatArrayRegion()jfloatArrayjfloat
SetDoubleArrayRegion()jdoubleArrayjdouble


二. 再探JNI数组处理实战分析

前面的章节，我们将JNI中有关数组处理的函数基本逐个分析，一网打净了(当然是夸张说法了)。说得再多不练，都是纸上谈兵，下面我们来实战一把，跟紧我要开战了，可别走丢了。


2.1 访问和返回基本类型一维数组

这里我们以int型数组为例来说明，JNI中访问和返回基本类型一维数组。
Java端代码:

package com.xxx.jni;

public class JNIArrayManager {
    public native int[] operateIntArray(int[] array);// 一维数组入参和作为返回值
    static {
        System.loadLibrary("jniArray");
    }
}

    private void operateIntArray() {
        int[] array_int = { 10, 100 };
        JNIArrayManager jniArrayManager = new JNIArrayManager();
        int[] array_out = jniArrayManager.operateIntArray(array_int);
        if (array_out != null) {
            for (int i = 0; i < array_out.length; i++) {
                Log.e("JNI_ARRAY", "operateIntArray : " + array_out[i]);
            }
        }
    }

JNI端代码:
com_xxx_jni_JNIArrayManager.h文件代码如下：

/* DO NOT EDIT THIS FILE - it is machine generated */
#include <jni.h>
/* Header for class com_xxx_jni_JNIArrayManager */

#ifndef _Included_com_xxx_jni_JNIArrayManager
#define _Included_com_xxx_jni_JNIArrayManager
#ifdef __cplusplus
extern "C" {
#endif
/*
 * Class:     com_xxx_jni_JNIArrayManager
 * Method:    operateIntArray
 * Signature: ([I)[I
 */
JNIEXPORT jintArray JNICALL Java_com_xxx_jni_JNIArrayManager_operateIntArray
  (JNIEnv *, jobject, jintArray);

#ifdef __cplusplus
}
#endif
#endif

com_xxx_jni_JNIArrayManager.cpp实现代码如下：

#include "com_xxx_jni_JNIArrayManager.h"
#include <stdio.h>
#include <android/log.h>
#include <jni.h>
#include <stdlib.h>
#define TAG "JNI_ARRAY"
#define LOGE(TAG,...) __android_log_print(ANDROID_LOG_INFO,TAG,__VA_ARGS__)

JNIEXPORT jintArray JNICALL Java_com_xxx_jni_JNIArrayManager_operateIntArray
  (JNIEnv * env, jobject object, jintArray intArray_in)
{

	/**********	解析从Java Native得到的jintArray数组 **********/
	jint * intArray;
	//操作方式一:
	// 如同 getUTFString 一样，会申请 native 内存
	intArray= env->GetIntArrayElements(intArray_in, NULL);
	if(intArray == NULL){
		return NULL;
	}

	//得到数组的长度
	const int  length = env->GetArrayLength(intArray_in);
	LOGE(TAG,"The intArray length is : %d\n", length);
	for(int i = 0; i < length; i++)
	{
		LOGE(TAG,"The intArray_in[%d} is %d\n", i,intArray[i]);
	}

	
	//操作方法二
	if(length > 0)
	{
		jint * buf_in;//直接定义一个jni型数组
		buf_in = (int *)malloc(sizeof(int) * length);
		//通过GetIntArrayRegion方法获取数组内容，此种方法不会申请内存
		env->GetIntArrayRegion(intArray_in, 0, length, buf_in);		
		free(buf_in);
	}

	//对于操作方式一，使用完了一定不要忘了释放内存
	env->ReleaseIntArrayElements(intArray_in, intArray, 0);

	

	/**********从JNI返回jintArray数组给Java层**********/
	jintArray intArray_out;//返回给java
	const int len_out = 10;
	intArray_out = env->NewIntArray(len_out);//在Native层创建一个长度为10的int型数组
	jint buf_out[len_out] = {0};
	for(int j = 0; j < len_out; j++){
		buf_out[j]  = j * 2; 
	}

	//使用SetIntArrayRegion来赋值
	env->SetIntArrayRegion(intArray_out, 0, len_out, buf_out);
	return intArray_out;
}

运行演示:

λ adb shell logcat  -s  JNI_ARRAY
--------- beginning of system
--------- beginning of main
I/JNI_ARRAY( 6628): The intArray length is : 2
I/JNI_ARRAY( 6628): The intArray_in[0} is 10
I/JNI_ARRAY( 6628): The intArray_in[1} is 100
E/JNI_ARRAY( 6628): operateIntArray : 0
E/JNI_ARRAY( 6628): operateIntArray : 2
E/JNI_ARRAY( 6628): operateIntArray : 4
E/JNI_ARRAY( 6628): operateIntArray : 6
E/JNI_ARRAY( 6628): operateIntArray : 8
E/JNI_ARRAY( 6628): operateIntArray : 10
E/JNI_ARRAY( 6628): operateIntArray : 12
E/JNI_ARRAY( 6628): operateIntArray : 14
E/JNI_ARRAY( 6628): operateIntArray : 16
E/JNI_ARRAY( 6628): operateIntArray : 18

案例分析:
在本例中，Java类JNIArrayManager 中定义了一个operateIntArray的Native方法，参数类型是int[]并且返回值类型也是int[]，对应JNI中的jnitArray类型。下面让我们对本地代码以一一分析。
解析jintArray数组数据:
在该部分代码中我们将会解析通过JNI传递下来的Java的int型数组内容，并打印出来。
(1) 首先通过 JNI的GetArrayLength 函数获取数组的长度，已知数组是 jintArray 类型，可以得出数组的元素类型是 jint，然后根据数组的长度和数组元素类型，申请相应大小的缓冲区。如果缓冲区不大的话，当然也可以直接在栈上申请内存，那样效率更高，但是没那么灵活，因为 Java 数组的大小变了，本地代码也跟着修改。
(2) 使用操作方式一GetIntArrayElements获取jintArray数据，其中该函数第三个参数表示返回的数组指针是原始数组，还是拷贝原始数组到临时缓冲区的指针，如果是JNI_TRUE则表示临时缓冲区数组指针，如果是JNI_FALSE临时原始数组指针。在实际开发当中，如果我们想修改原来的数组数据可以通过修改这个参数的值来达到。对于通过该函数获取的指针必须做校验，因为当原始数据在内存当中不是连续存放的情况下，JVM 会复制所有原始数据到一个临时缓冲区，并返回这个临时缓冲区的指针。有可能在申请开辟临时缓冲区内存空间时，会内存不足导致申请失败，这时会返回 NULL。并且使用该函数后，必须使用ReleaseIntArrayElements进行内存释放，不然可能会导致内存泄漏问题。
(3) 使用操作方式二GetIntArrayRegion 函数将 Java中int型数组中的所有元素拷贝到 C 缓冲区中，最后释放存储 java中int型数组元素的 缓冲区。关于GetIntArrayRegion的具体使用可以参见前面章节的内容。JNI 还提供了一个和 GetIntArrayRegion 相对应的函 SetIntArrayRegion，本地代码可以通过这个函数来修改所有基本数据类型数组的元素。

返回jintArray数组数据:
该部分代码会在JNI的本地方法中创建int型数组并赋值，然后返回给Java端。
(1) 定义jintArray类型变量intArray_out，此时并没有赋值和创建。
(2) 调用NewIntArray函数创建长度为intArray_out的int型数组对象，关于该函数的具体使用参见章节1.4 New<PrimitiveType>Array函数集。
(3) 接着调用SetIntArrayRegion将本地方法缓冲区中buf_out数据复制到intArray_out中。
(4) 最后直接将intArray_out返回给Java。

小结:
上面的章节我们通过一个访问和返回一维数组的实例，讲解了JNI中怎么处理数组的。那么下面让我们总结一下前面两种方法的优缺点和使用范围：

  • 对于小量的、固定大小的数组，应该选择 Get/SetArrayRegion 函数来操作数组元素是效率最高的。因为这对函数要求提前分配一个 C 临时缓冲区来存储数组元素，你可以直接在 Stack（栈）上或用 malloc 在堆上来动态申请，当然在栈上申请是最快的。有童鞋可能会认为，访问数组元素还需要将原始数据全部拷贝一份到临时缓冲区才能访问而觉得效率低？我想告诉你的是，像这种复制少量数组元素的代价是很小的，几乎可以忽略。这对函数的另外一个优点就是，允许你传入一个开始索引和长度来实现对子数组元素的访问和操作（SetArrayRegion函数可以修改数组），不过传入的索引和长度不要越界，函数会进行检查，如果越界了会抛出 ArrayIndexOutOfBoundsException 异常。

  • Get/ReleaseArrayElements 系列函数永远是安全的，虚拟机 会选择性的返回一个指针，这个指针可能指向原始数据，也可能指向原始数据的复制。

通过这个访问基本类型int一维数组的实例，也可以将这个模式代码套用到其它的基本类型一维数组里面，各位读者看官朋友们可以自行扩展验证！


2.2 访问和返回String类型一维数组

在前面的章节里面我们以int型数组为例讲解，在本章节中我们以String类型引用数组为例，讲解JNI中怎么访问和返回String类型一维数组。
Java端代码:

package com.xxx.jni;
public class JNIArrayManager {
    public native String[] operateStringArrray(String[] array);//String数组入参和做为返回值

    static {
        System.loadLibrary("jniArray");
    }
}

    private void operateStringArray(){
        JNIArrayManager jniArrayManager = new JNIArrayManager();
        String[] string_in = {"Hello","JNI"};
        String[] string_out = jniArrayManager.operateStringArrray(string_in);
        for(int i  = 0; i < string_out.length; i++){
            Log.e("JNI_ARRAY","operateStringArray : " + string_out[i].toString());
        }
    }

JNI端代码:
com_xxx_jni_JNIArrayManager.h文件代码如下：

/* DO NOT EDIT THIS FILE - it is machine generated */
#include <jni.h>
/* Header for class com_xxx_jni_JNIArrayManager */

#ifndef _Included_com_xxx_jni_JNIArrayManager
#define _Included_com_xxx_jni_JNIArrayManager
#ifdef __cplusplus
extern "C" {
#endif

/*
 * Class:     com_xxx_jni_JNIArrayManager
 * Method:    operateStringArrray
 * Signature: ([Ljava/lang/String;)[Ljava/lang/String;
 */
JNIEXPORT jobjectArray JNICALL Java_com_xxx_jni_JNIArrayManager_operateStringArrray
  (JNIEnv *, jobject, jobjectArray);

#ifdef __cplusplus
}
#endif
#endif

com_xxx_jni_JNIArrayManager.cpp实现代码如下:

#include "com_xxx_jni_JNIArrayManager.h"
#include <stdio.h>
#include <android/log.h>
#include <jni.h>
#include <stdlib.h>


#define TAG "JNI_ARRAY"
#define LOGE(TAG,...) __android_log_print(ANDROID_LOG_INFO,TAG,__VA_ARGS__)

//将jstring转换成char *
char* jstringToNative(JNIEnv *env, jstring jstr)
{
	if ((env)->ExceptionCheck() == JNI_TRUE || jstr == NULL)
	{
		(env)->ExceptionDescribe();
		(env)->ExceptionClear();
		//printf("jstringToNative函数转换时,传入的参数str为空");
		return NULL;
	} 
 
	jbyteArray bytes = 0; 
	jthrowable exc; 
	char *result = 0; 
	if ((env)->EnsureLocalCapacity(2) < 0) 
	{ 
		return 0; /* out of memory error */ 
	} 
	jclass jcls_str = (env)->FindClass("java/lang/String"); 
	jmethodID MID_String_getBytes = (env)->GetMethodID(jcls_str, "getBytes", "()[B"); 
 
	bytes = (jbyteArray)(env)->CallObjectMethod(jstr, MID_String_getBytes); 
	exc = (env)->ExceptionOccurred(); 
	if (!exc) 
	{ 
		jint len = (env)->GetArrayLength( bytes); 
		result = (char *)malloc(len + 1); 
		if (result == 0) 
		{ 
			//JNU_ThrowByName( "java/lang/OutOfMemoryError", 	0); 
			(env)->DeleteLocalRef(bytes); 
			return 0; 
		} 
		(env)->GetByteArrayRegion(bytes, 0, len, (jbyte *)result); 
		result[len] = 0; /* NULL-terminate */ 
	} 
	else 
	{ 
		(env)->DeleteLocalRef( exc); 
	} 
	(env)->DeleteLocalRef( bytes); 
	return (char*)result; 

} 

//将char  * 转装成jstring
jstring nativeTojstring( JNIEnv* env,const char* str )
{	
	//定义java String类 strClass
	jclass strClass = (env)->FindClass("java/lang/String");
	//获取java String类方法String(byte[],String)的构造器,用于将本地byte[]数组转换为一个新String
	jmethodID ctorID = (env)->GetMethodID( strClass, "<init>", "([BLjava/lang/String;)V");
	//建立byte数组
	jbyteArray bytes = (env)->NewByteArray( (jsize)strlen(str));
	//将char* 转换为byte数组
	(env)->SetByteArrayRegion( bytes, 0, (jsize)strlen(str), (jbyte*)str);
	//设置String, 保存语言类型,用于byte数组转换至String时的参数
	jstring encoding = (env)->NewStringUTF( "utf-8"); 
	//将byte数组转换为java String,并输出
	return (jstring)(env)->NewObject( strClass, ctorID, bytes, encoding); 
}

/*
 * Class:     com_xxx_jni_JNIArrayManager
 * Method:    operateStringArrray
 * Signature: ([Ljava/lang/String;)[Ljava/lang/String;
 */
JNIEXPORT jobjectArray JNICALL Java_com_xxx_jni_JNIArrayManager_operateStringArrray
  (JNIEnv * env, jobject object, jobjectArray objectArray_in)
{
	/*******获取从JNI传过来的String数组数据**********/
	jsize  size = env->GetArrayLength(objectArray_in);
	for(int i = 0; i < size; i++)
	{
		jstring string_in= (jstring)env->GetObjectArrayElement(objectArray_in, i);
		char *char_in  = jstringToNative(env, string_in);
		LOGE(TAG,"objectArray_in[%d] : %s\n", i, char_in);
	}


	/***********从JNI返回String数组给Java层**************/
	jclass clazz = env->FindClass("java/lang/String");
	jobjectArray objectArray_out;
	const int len_out = 5;
	objectArray_out = env->NewObjectArray(len_out, clazz, NULL);
	char * char_out[]=  { "Hello,", "world!", "JNI", "is", "fun" };

	jstring temp_string;
	for( int i= 0; i < len_out; i++ )
    {
        temp_string = nativeTojstring(env, char_out[i]);
        env->SetObjectArrayElement(objectArray_out, i, temp_string);
    }
	return objectArray_out;
}

运行演示:

λ adb shell logcat  -s  JNI_ARRAY
--------- beginning of system
--------- beginning of main
12-24 06:42:40.546  3515  3515 I JNI_ARRAY: objectArray_in[0] : Hello
12-24 06:42:40.547  3515  3515 I JNI_ARRAY: objectArray_in[1] : JNI
12-24 06:42:40.548  3515  3515 E JNI_ARRAY: operateStringArray : Hello,
12-24 06:42:40.549  3515  3515 E JNI_ARRAY: operateStringArray : world!
12-24 06:42:40.549  3515  3515 E JNI_ARRAY: operateStringArray : JNI
12-24 06:42:40.549  3515  3515 E JNI_ARRAY: operateStringArray : is
12-24 06:42:40.549  3515  3515 E JNI_ARRAY: operateStringArray : fun

案例分析:
在本例中，Java类JNIArrayManager 中定义了一个operateStringArrray的Native方法，参数类型是String[]并且返回值类型也是String[]，对应JNI中的jobjectArray类型。下面让我们对本地代码以一一分析。
解析String引用类型数组数据:
在该部分代码中我们将会解析通过JNI传递下来的Java的String引用类型数组内容，并打印出来。
(1) 首先通过GetArrayLength函数获取String类型数组的长度。
(2) 通过for循环调用GetObjectArrayElement获取String引用类型数组的元素String的值。
(3) 调用jstringToNative函数将jstring转换为char *并将其打印出来。
创建String引用类型数组数据并返回:
(1) 首先通过FindClass加载本类，其中的参数是类的描述符，我们这里的是String类的描述符是java/lang/String。
(2) 定义引用类型变量jobjectArray objectArray_out，然后通过NewObjectArray创建引用类型数组，关于该函数的具体用法参见章节1.2 NewObjectArray 。
(3) 开启for循环然后调用nativeTojstring将char *转换成jstring数据，接着调用SetObjectArrayElement对String类型引用数组的元素进行赋值，关于该函数的调用请参见前面章节。
(4) 返回objectArray_out给Java层。
如上就是访问和返回String类型一维数组的全过程，这个代码流程也可以扩展多其它引用类型数组的处理。在下面的2.3章节将会带领读者来处理自定义class数组的处理。


2.3 访问和返回自定义Class引用类型一维数组

在前面的章节里面我们以String引用类型数组为例讲解，在本章节中我们以自定义Class类型引用数组为例，讲解JNI中怎么访问和返回自定义Class引用类型一维数组。
Java端代码:
自定义Class类文件Person.java代码

package com.xxx.jni;
public class Person {
    public int mAge;
    public String mName;

    @Override
    public String toString() {
        return "Person [age=" + mAge + ", name=" + mName + "]";
    }

    public int getAge() {
        return mAge;
    }

    public void setAge(int age) {
        this.mAge = age;
    }

    public String getName() {
        return mName;
    }

    public void setName(String name) {
        this.mName = name;
    }
}

Java端Native方法定义文件JNIArrayManager.java代码

package com.xxx.jni;

public class JNIArrayManager {
    public native Person[] operateObjectArray(Person[] person);//自定义对象数组入参和返回值
    static {
        System.loadLibrary("jniArray");
    }
}

    private void operateObjectArray() {
        JNIArrayManager jniArrayManager = new JNIArrayManager();
        ArrayList<Person> persons = new ArrayList<Person>();

        Person person_0 = new Person();
        person_0.setAge(10);
        person_0.setName("Hello");

        Person person_1 = new Person();
        person_1.setAge(110);
        person_1.setName("JNI");
        persons.add(person_0);
        persons.add(person_1);

        Person[] person_Array = new Person[2];
        persons.toArray(person_Array);

        Person[] persons_out = jniArrayManager.operateObjectArray(person_Array);
        if (persons_out != null) {
            for (int i = 0; i < persons_out.length; i++) {
                Log.e("JNI_ARRAY ",
                        "operateObjectArray : " + persons_out[i].toString());
            }
        }
    }

JNI端代码:

com_xxx_jni_JNIArrayManager.h文件代码如下：

/* DO NOT EDIT THIS FILE - it is machine generated */
#include <jni.h>
/* Header for class com_xxx_jni_JNIArrayManager */

#ifndef _Included_com_xxx_jni_JNIArrayManager
#define _Included_com_xxx_jni_JNIArrayManager
#ifdef __cplusplus
extern "C" {
#endif

/*
 * Class:     com_xxx_jni_JNIArrayManager
 * Method:    operateObjectArray
 * Signature: ([Lcom/xxx/jni/Person;)[Lcom/xxx/jni/Person;
 */
JNIEXPORT jobjectArray JNICALL Java_com_xxx_jni_JNIArrayManager_operateObjectArray
  (JNIEnv *, jobject, jobjectArray);

#ifdef __cplusplus
}
#endif
#endif

com_xxx_jni_JNIArrayManager.cpp实现代码如下:

#include "com_xxx_jni_JNIArrayManager.h"
#include <stdio.h>
#include <android/log.h>
#include <jni.h>
#include <stdlib.h>


#define TAG "JNI_ARRAY"
#define LOGE(TAG,...) __android_log_print(ANDROID_LOG_INFO,TAG,__VA_ARGS__)

//将jstring转换成char *
char* jstringToNative(JNIEnv *env, jstring jstr)
{
	if ((env)->ExceptionCheck() == JNI_TRUE || jstr == NULL)
	{
		(env)->ExceptionDescribe();
		(env)->ExceptionClear();
		//printf("jstringToNative函数转换时,传入的参数str为空");
		return NULL;
	} 
 
	jbyteArray bytes = 0; 
	jthrowable exc; 
	char *result = 0; 
	if ((env)->EnsureLocalCapacity(2) < 0) 
	{ 
		return 0; /* out of memory error */ 
	} 
	jclass jcls_str = (env)->FindClass("java/lang/String"); 
	jmethodID MID_String_getBytes = (env)->GetMethodID(jcls_str, "getBytes", "()[B"); 
 
	bytes = (jbyteArray)(env)->CallObjectMethod(jstr, MID_String_getBytes); 
	exc = (env)->ExceptionOccurred(); 
	if (!exc) 
	{ 
		jint len = (env)->GetArrayLength( bytes); 
		result = (char *)malloc(len + 1); 
		if (result == 0) 
		{ 
			//JNU_ThrowByName( "java/lang/OutOfMemoryError", 	0); 
			(env)->DeleteLocalRef(bytes); 
			return 0; 
		} 
		(env)->GetByteArrayRegion(bytes, 0, len, (jbyte *)result); 
		result[len] = 0; /* NULL-terminate */ 
	} 
	else 
	{ 
		(env)->DeleteLocalRef( exc); 
	} 
	(env)->DeleteLocalRef( bytes); 
	return (char*)result; 

} 

//将char *  转换成 jstring
jstring nativeTojstring( JNIEnv* env,const char* str )
{	
	//定义java String类 strClass
	jclass strClass = (env)->FindClass("java/lang/String");
	//获取java String类方法String(byte[],String)的构造器,用于将本地byte[]数组转换为一个新String
	jmethodID ctorID = (env)->GetMethodID( strClass, "<init>", "([BLjava/lang/String;)V");
	//建立byte数组
	jbyteArray bytes = (env)->NewByteArray( (jsize)strlen(str));
	//将char* 转换为byte数组
	(env)->SetByteArrayRegion( bytes, 0, (jsize)strlen(str), (jbyte*)str);
	//设置String, 保存语言类型,用于byte数组转换至String时的参数
	jstring encoding = (env)->NewStringUTF( "utf-8"); 
	//将byte数组转换为java String,并输出
	return (jstring)(env)->NewObject( strClass, ctorID, bytes, encoding); 
}

//和Java层的Person类相对应
typedef struct Person
{
    char    * mName;
    int     mAge;
};

JNIEXPORT jobjectArray JNICALL Java_com_xxx_jni_JNIArrayManager_operateObjectArray
  (JNIEnv * env, jobject object, jobjectArray object_in)
{
	
	/********解析自定义对象数组作为参数入参********/
	//获取对应Java类Person的class以及各个属性
	jclass clazz = env->FindClass("com/xxx/jni/Person");
	//获取mAge变量对应的域信息
	jfieldID mAge = env->GetFieldID(clazz, "mAge", "I");
	//获取mName变量对应的域信息
	jfieldID mName = env->GetFieldID(clazz, "mName","Ljava/lang/String;");
	const int object_len = env->GetArrayLength(object_in);//获取数组长度


	 //将数组拆分转换成结构体
	 jobject mObject_in;
	 Person person_in[object_len];
	 for(int i = 0; i < object_len; i++)
	 {
	 	mObject_in = env->GetObjectArrayElement(object_in, i);
		person_in[i].mAge = env->GetIntField(mObject_in, mAge);
		person_in[i].mName = jstringToNative(env, (jstring)env->GetObjectField(mObject_in, mName));
		LOGE(TAG,"mObject_in[%d].mAge : %d\n",  i, person_in[i].mAge);
		LOGE(TAG,"mObject_in[%d].mName : %s\n", i, person_in[i].mName);
	 }


	/********创建自定义Class数组对象并返回********/
	const int object_num = 2;
	//在JNI层创建数据
	Person  persons[object_num];
	for(int i = 0 ; i < object_num; i++)
	{
		persons[i].mAge = 10 + i;
		persons[i].mName = (char *)malloc(sizeof(char) * (20));//长度为20
		sprintf(persons[i].mName,"name : %d", i);
	}

	// 这里获得构造方法
	jmethodID initMethodId = env->GetMethodID(clazz, "<init>", "()V");

	//将数据封装成对象然后再封装成数组
	jobject mObject_out;
	//创建Person对象数组
	jobjectArray mArray_out = env->NewObjectArray(object_num, clazz, NULL);
	for(int i = 0; i < object_num; i++)
	{
		mObject_out = env->NewObject(clazz, initMethodId);
		env->SetIntField(mObject_out, mAge, persons[i].mAge);
		env->SetObjectField(mObject_out, mName, nativeTojstring(env, persons[i].mName));


		//将对象插入到数组的特定位置
		env->SetObjectArrayElement(mArray_out, i, mObject_out);
	}
	return mArray_out;
}

运行演示:

λ adb lshell logcat  -s  JNI_ARRAY
--------- beginning of system
--------- beginning of main
12-24 09:04:09.968  4118  4118 I JNI_ARRAY: mObject_in[0].mAge : 10
12-24 09:04:09.968  4118  4118 I JNI_ARRAY: mObject_in[0].mName : Hello
12-24 09:04:09.968  4118  4118 I JNI_ARRAY: mObject_in[1].mAge : 110
12-24 09:04:09.968  4118  4118 I JNI_ARRAY: mObject_in[1].mName : JNI
12-24 09:04:09.969  4118  4118 E JNI_ARRAY: operateObjectArray : Person [age=10, name=name : 0]
12-24 09:04:09.970  4118  4118 E JNI_ARRAY: operateObjectArray : Person [age=11, name=name : 1]

案例分析:
在本例中，Java类JNIArrayManager 中定义了一个operateObjectArray的Native方法，参数类型是自定义Class类的Person[]数据并且返回值也是自定义Class类的Person[]数据。自定义的类也属于引用数组，对应JNI中的jobjectArray类型。下面让我们对本地代码以一一分析。
解析Person引用类型数组数据:
(1) 首先通过FindClass和GetFieldID获取获取对应Java类Person的class以及各个属性，关于这个的操作会在后续章节详细介绍。
(2) 调用GetArrayLength函数获取数组的长度。
(3) 开启for循环，然后在循环中调用GetObjectArrayElement获取自定义Class类型数组的元素值，接着调用GetIntField获取自定义Class类的变量值然后打印出来。关于怎么获取Java实例变量的我们会在后续章节专门讨论。

创建Person引用类型数组数据并返回:
(1) 在JNI层创建Java的Person类对应的C/C++的结构体数组Person persons[object_num]并赋值。
(2) 调用GetMethodID获取Java自定义类Person的构造函数域方法。
(3) 调用NewObjectArray函数创建Person引用数组对象。
(4) 开启循环，调用NewObject创建Person引用对象，并接着通过域进行赋值，最后通过SetObjectArrayElement将创建的Person引用对象放入对象数组中。
(5) 经过前面的一些操作此时Java自定Class引用型数组对象已经创建，然后直接返回会Java层。
通过上面的实例，我们讲解了怎么处理自定义Class引用对象数组，这里的Person类读者朋友们也可以扩展到其它的自定义Class，然后参照这个模式进行相关的解析。


2.3 访问和返回int类型二维数组

在前面的章节我们都是操作的一维数组，那么在这个章节让我们加大点难度，搞点大的直接操作二维数组。各位读者请抓好扶手坐稳，要开车了。
Java端代码
Java端Native方法定义文件JNIArrayManager.java代码

package com.xxx.jni;
public class JNIArrayManager {
    public native Person[] operateObjectArray(Person[] person);//自定义对象数组入参和返回值
    static {
        System.loadLibrary("jniArray");
    }
}

Java端调用代码

    private void operateTwoIntDimArray(){
        int [][] array_in  = {{10, 100},{20, 200}};
        JNIArrayManager jniArrayManager = new JNIArrayManager();
        int [][] array_out = jniArrayManager.operateTwoIntDimArray(array_in);
        if(array_out != null){
            for(int i =0; i < array_out.length; i++){
                for(int j = 0; j < array_out[i].length; j++){
                    Log.e("JNI_ARRAY", "operateTwoIntDimArray[" + i +  "][" +  j + "]" + array_out[i][j]);
                }
            }
        }
    }

JNI端代码
com_xxx_jni_JNIArrayManager.h文件代码如下：

/* DO NOT EDIT THIS FILE - it is machine generated */
#include <jni.h>
/* Header for class com_xxx_jni_JNIArrayManager */

#ifndef _Included_com_xxx_jni_JNIArrayManager
#define _Included_com_xxx_jni_JNIArrayManager
#ifdef __cplusplus
extern "C" {
#endif


/*
 * Class:     com_xxx_jni_JNIArrayManager
 * Method:    operateTwoIntDimArray
 * Signature: ([[I)[[I
 */
JNIEXPORT jobjectArray JNICALL Java_com_xxx_jni_JNIArrayManager_operateTwoIntDimArray
  (JNIEnv *, jobject, jobjectArray);

#ifdef __cplusplus
}
#endif
#endif

com_xxx_jni_JNIArrayManager.cpp实现代码如下:

#include "com_xxx_jni_JNIArrayManager.h"
#include <stdio.h>
#include <android/log.h>
#include <jni.h>
#include <stdlib.h>

#define TAG "JNI_ARRAY"
#define LOGE(TAG,...) __android_log_print(ANDROID_LOG_INFO,TAG,__VA_ARGS__)

JNIEXPORT jobjectArray JNICALL Java_com_xxx_jni_JNIArrayManager_operateTwoIntDimArray
  (JNIEnv * env, jobject object, jobjectArray objectArray_in)
{
	/**********	解析从Java得到的int型二维数组 **********/
	int i, j ;
	const int row = env->GetArrayLength(objectArray_in);//获取二维数组的行数
	jarray array = (jarray)env->GetObjectArrayElement(objectArray_in, 0);
	const int col = env->GetArrayLength(array);//获取二维数组每行的列数

	//根据行数和列数创建int型二维数组
	jint intDimArrayIn[row][col];

	

	for(i =0; i < row; i++)
	{
		 array = (jintArray)env->GetObjectArrayElement(objectArray_in, i);
		
		 //操作方式一，这种方法会申请natvie memory内存
		 jint *coldata = env->GetIntArrayElements((jintArray)array, NULL );        
         for (j=0; j<col; j++) {    
              intDimArrayIn [i] [j] = coldata[j]; //取出JAVA类中int二维数组的数据,并赋值给JNI中的数组  
         }  

		  //操作方式二，赋值,这种方法不会申请内存
  		 env->GetIntArrayRegion((jintArray)array, 0, col, (jint*)&intDimArrayIn[i]);		 
		  
		 env->ReleaseIntArrayElements((jintArray)array, coldata,0 );  
	}
	for(int i = 0; i < row; i ++)
		for(int j = 0; j < col; j++)
			LOGE(TAG,"The intDimArrayIn[%d][%d] is %d\n", i, j, intDimArrayIn[i][j]);


	

	/**************创建一个int型二维数组返回给Java**************/
	const int row_out = 2;//行数
	const int col_out = 2;//列数

	//获取数组的class
	jclass clazz  = env->FindClass("[I");//一维数组的类
	//新建object数组，里面是int[]
	jobjectArray intDimArrayOut = env->NewObjectArray(row_out, clazz, NULL);

	int tmp_array[row_out][col_out] = {{0,1},{2,3}};
	for(i = 0; i< row_out; i ++)
	{
		jintArray intArray = env->NewIntArray(col_out);
		env->SetIntArrayRegion(intArray, 0, col_out, (jint*)&tmp_array[i]);
		env->SetObjectArrayElement(intDimArrayOut, i, intArray);
	}
	return intDimArrayOut;
}

运行演示：

λ adb logcat  -s  JNI_ARRAY
--------- beginning of main
--------- beginning of system
12-25 10:20:48.432  8281  8281 I JNI_ARRAY: The intDimArrayIn[0][0] is 10
12-25 10:20:48.432  8281  8281 I JNI_ARRAY: The intDimArrayIn[0][1] is 100
12-25 10:20:48.432  8281  8281 I JNI_ARRAY: The intDimArrayIn[1][0] is 20
12-25 10:20:48.432  8281  8281 I JNI_ARRAY: The intDimArrayIn[1][1] is 200
12-25 10:20:48.433  8281  8281 E JNI_ARRAY: operateTwoIntDimArray[0][0]0
12-25 10:20:48.433  8281  8281 E JNI_ARRAY: operateTwoIntDimArray[0][1]1
12-25 10:20:48.433  8281  8281 E JNI_ARRAY: operateTwoIntDimArray[1][0]2
12-25 10:20:48.433  8281  8281 E JNI_ARRAY: operateTwoIntDimArray[1][1]3

案例分析:
在本例中，Java类JNIArrayManager 中定义了一个operateTwoIntDimArray的Native方法，参数类型是int[][]二维数组数据并且返回值也是int[][]x型数组数据，对应JNI中的jobjectArray类型。下面让我们对本地代码以一一分析。
解析init[][]型类型数组数据:
这里主要的逻辑是逐步划分，先将二维数组解析为一维数组，然后再对一维数组进行解析。让我们就这代码一一分析！
(1) 首先调用GetArrayLength获取二维数组jobjectArray的行数。
(2) 然后调用GetObjectArrayElement获取二维数组jobjectArray的指定行数的数据。
(3) 调用GetArrayLength获取二维数组jobjectArray每一行的列数。
(4) 根据前面解析得到的二维数组jobjectArray的行数和列数，在C/C++层创建一个int[][]型二维数组intDimArrayIn。
(5) 开启循环，对每行二维数组每行逐步分解，调用GetObjectArrayElement获取每行的数据此时也是一个数组，然后继续调用GetIntArrayElements或者GetIntArrayRegion将数据保存在intDimArrayIn里面。
创建init[][]型类型数组数据并返回:
这里的步骤刚好和解析二维数组相反，先创建二维数组，然后创建二维数组行数数目的一维数组并且一维数组的长度为二维数组每行列数的长度。下面我们就这代码一一分析！
(1) 调用FindClass("[I")找到一维数组的类。
(2) 接着调用NewObjectArray创建一个一维数组，即二维数组也可以认为是一维数组，不过此时的一维数组的元素是一维数组。
(3) 开启循环，调用NewIntArray创建int型一维数组，接着调用SetIntArrayRegion对前面创建的一维数组赋值，最后调用SetObjectArrayElement将前面创建的一维数组放到二维数组里面去。
(4) 返回回init[][]二维数组intDimArrayOut到Java层。
好了到这里就解析完成了。



写在最后

  各位读者看官朋友们，关于JNI对数组的处理就讲到这里了。本篇几乎将JNI中各种数组情况都有概括到了，只要仔细阅读本章，应该以后没有JNI数组问题能难住各位了。在最后麻烦读者朋友们如果本篇对你有帮助，关注和点赞一下，让然如果有错误和不足的地方也可以拍砖。青山不改绿水长流，各位江湖见！

IT先森
关注
  • 8
    点赞
  • 踩
  • 22
    收藏
    觉得还不错? 一键收藏
  • 8
    评论
专栏目录
java调用本地方法--JNI访问对象型数组
w1992wishes的博客
05-11 1617
本篇结构： 简介 实例 一、简介 补充JNI对象数组访问实例。 JNI 中的数组分为基本类型数组和对象数组，它们的处理方式是不一样的，基本类型数组中的所有元素都是 JNI 的基本数据类型，可以直接访问。而对象数组中的所有元素是一个类的实例或其它数组的引用，和字符串操作一样，不能直接访问 Java 传递给 JNI 层的数组，必须选择合适的 JNI 函数来访问和设置 Java 层的数组对象...
jni传递对象数组
10-16
可在jni层返回应用层一个对象数组，包括字符串、整数、小数的成员变量
JNI数组
枫竹梦
11-14 2102
JNI数组 在上一篇中介绍了JNI String类型。本文是JNI系列的第四篇，介绍JNI中的引用类型—Array类型。 系列文章的大纲如下： JNI 简介 JNI 基本类型 JNI String JNI 数组 JNI 实例变量 JNI 静态变量 JNI 回调实例方法与静态方法 JNI 调用Java中的super.method() JNI 中创建对象 JNI 中创建对象数组 JNI 中局部引用和全局引用 JNI 动态注册 使用Android NDK编译Android的Native库 JNI数组 如在 J
Ndk学习之JNI获取数组（Java-->C-->Java）
心宽何处不桃源
12-25 1249
1.在java中定义方法以及获取C中返回值的方法 public native int[] getArray(int len);2.javah生成头文件 /* * Class: com_boom_JNITest * Method: getArray * Signature: (I)[I */ JNIEXPORT jintArray JNICALL Java_com_boom
jni java与c++交互返回三维数组jobjectArray
weixin_34309543的博客
05-11 1196
1.在java里创建一个类，在类里添加静态方法调用c++的类库dll，在java里创建要返回数组的函数。在java的main方法里创建返回后的测试方法。 Java代码   package cn.gov.cma.cnn.webgis.active;         public class TestHello {            //调用c++的动态库         static...
JNI 访问数组
07-18 395
JNI 中的数组分为基本类型数组和对象数组，它们的处理方式是不一样的，基本类型数组中的所有元素都是 JNI 的基本数据类型，可以直接访问。而对象数组中的所有元素是一个类的实例或其它数组的引用，和字符串操作一样，不能直接访问 Java 传递给 JNI 层的数组，必须选择合适的 JNI 函数来访问和设置 Java 层的数组对象。阅读此文假设你已经了解了 JNI 与 Java 数据类型的映射关系，如果还不
【JNI编程】JNI数组使用
洪伟的专栏
02-18 1819
我们经常遇到在native代码中处理数组的需求，JNI中数组的使用可以说是基本功。下面的例子演示了如何在JNI中获取数组的长度，JNI获取Java层的数组并使用等。 一、涉及API 1.1 GetArrayLength jsize GetArrayLength(JNIEnv *env, jarray array); 返回数组中元素的数量。 LINKAGE: JNIEnv接口函数表中的索引171。...
JNI教程之数组操作
最新发布
没事就写点
02-20 665
指针用完要及时释放，否则gc的内存回收机制会认为该指针指向的内存还在被使用，从而造成内存泄漏。
jni 取java对象数组_使用JNI从Java访问C对象数组
weixin_29189003的博客
02-26 160
继我的previous question和Some Name的回应之后,我想尝试相反的方式并增强前一个问题：我想做以下步骤：>在Java中分配缓冲区>在C中填充数组>在Java中编辑值>在C中做一些数字运算>读取Java中的值考虑C中的以下类：#pragma once#pragma pack(push, 8)class Point{public:double x;do...
java 数组强制转 jni数组_Java层与Jni层的数组传递（转）
weixin_39631767的博客
02-13 296
Android开发中，经常会在Java代码与Jni层之间传递数组(byte[])，一个典型的应用是Java层把需要发送给客户端的数据流传递到Jni层，由Jni层的Socket代码发送出去，当然，Jni层也需要把从Socket接收到的数据流返回给Java层。我简单地总结了一下，从Java层到Jni层，从Jni层到JAVA层，各有3种传递方式，下面用代码示例简单地介绍一下。示例代码的主要文件有两个，一...
android jni 使用object对象
12-13
这是我自己写的jni jobjectarray的demo共享一下
android开发 在JNI函数中引用Java类，将cxx复杂数据转换成jobjectArray，实现从JNI到Java的数据传输
u013620235的博客
01-19 4270
引言： JNI是Java可以调用高效的c++代码，但是在JNI函数中传递复杂数据类型十分的繁琐，一般情况下需要jobject作为中转，一维数组int[],float[]以及二维数组String[]可以实现方便的参数传入/传出。其他复杂的二、三维数组理论上可以使用jobjectarray实现参数传入/传出，可是实现过程中出现问题，可能是内存上的错误。 下面介绍一种通用方法，在JNI函数中引用Jav
JNI：如何操作数组
天行健，君子以自强不息；地势坤，君子以厚德载物。
03-03 591
1. 数组的分类数组分为两种基本数据类型的数组对象类型（Object[]）的数组一个能通用于两种不同数据类型数组的函数GetArrayLength( jarray array);//获取长...
JNI 数组数据处理
专注基础架构领域
09-19 2376
JNI 中的数组分为基本类型数组和对象数组，它们的处理方式是不一样的，基本类型数组中的所有元素都是 JNI 的基本数据类型，可以直接访问。而对象数组中的所有元素是一个类的实例或其它数组的引用，和字符串操作一样，不能直接访问 Java 传递给 JNI 层的数组，必须选择合适的 JNI 函数来访问和设置 Java 层的数组对象。 访问基本类型数组 1、Java代码 //调用数组 byte a...
jni数组使用(二）
达闻东的专栏
03-16 6858
上一篇说到在java中调用c++函数中，如何使用jni数组。 下面谈一谈在回调中如何使用jni数组。 假如有一个java函数： public void Receive(char buffer[],int length) 我们需要在c++中调用这个函数，在jni中该如何实现数组的转换？（本篇不涉及jni的回调函数的实现机制） 实现如下： static void receive_callb
Android Studio 开发之JNI开发 -- jni层返回一维对象数组
Jimmy
11-29 789
说明：本博客记录一下，如何将JNI层的PointF类对象数组返回给Java层，是一维数组的。 1、Java层接口定义： public native PointF[] GetArrayPf(); 2、JNI层实现： extern "C" JNIEXPORT jobjectArray JNICALL Java_com_terawins_www_demo007_Java_1Interface...
JNI心得 - (三)向本地代码传递数组
小北的博客
07-18 4009
接着上一个例子java 调用本地代码 继续补充代码，这次看看本地代码如何接收java层数组。 首先在MainActivity.java 添加如下代码声明 public native void stringArray(String []strArr); public native void floatArray(float []fArray); public nativ...
JNI 中创建对象数组
枫竹梦
11-23 2226
JNI 回调实例方法与静态方法 在上一篇中介绍了JNI中创建对象。本文是JNI系列的第十篇，介绍JNI中的如何调在Native代码中创建对象数组。 系列文章的大纲如下： JNI 简介 JNI 基本类型 JNI String JNI 数组 JNI 实例变量 JNI 静态变量 JNI 回调实例方法与静态方法 JNI 调用Java中的super.method() JNI 中创建对象 JNI 中创建对象数组 JNI 中局部引用和全局引用 JNI 动态注册 使用Android NDK编译Android的Native
Android 使用jni解析数组
lovoo的博客
06-07 741
1、创建页面/** * @描述 数组传递 * @项目名称 App_imooc * @包名 com.android.imooc.jni * @类名 ArrayActivity * @author chenlin * @date 2014年6月7日 下午10:26:02 * @version 1.0
jni/ndk 开发指南 pdf
01-01
JNI（Java Native Interface）是一种编程框架，可实现Java和本地...总之，JNI/NDK开发指南PDF是一份对开发者非常有价值的资料，可以帮助他们更好地理解和应用JNI/NDK技术，从而开发出更加高效、稳定的Android应用程序。
评论 8
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值