JNI数据类型与签名

/* jni.h — JNI 基本类型定义（简化版） */
 
typedef unsigned char   jboolean;  // Java boolean → 无符号 8 位，取值 JNI_TRUE(1) 或 JNI_FALSE(0)
typedef signed char     jbyte;     // Java byte    → 有符号 8 位整数
typedef unsigned short  jchar;     // Java char    → 无符号 16 位，存储 UTF-16 编码单元
typedef short           jshort;    // Java short   → 有符号 16 位整数
typedef int             jint;      // Java int     → 有符号 32 位整数（几乎所有平台 int 都是 32 位）
typedef long long       jlong;     // Java long    → 有符号 64 位整数（注意：用 long long 而非 long！）
typedef float           jfloat;    // Java float   → IEEE 754 单精度 32 位浮点
typedef double          jdouble;   // Java double  → IEEE 754 双精度 64 位浮点

#define JNI_FALSE 0  // 对应 Java 的 false
#define JNI_TRUE  1  // 对应 Java 的 true

// ✅ 正确写法：始终使用 JNI_TRUE / JNI_FALSE
JNIEXPORT jboolean JNICALL
Java_com_example_NativeLib_isReady(JNIEnv *env, jobject thiz) {
    int status = check_device_status();     // 假设返回 0 或非 0
    return status ? JNI_TRUE : JNI_FALSE;   // 显式转换，安全可靠
}
 
// ❌ 危险写法：直接返回 C 的 int 值
// return status;  // 如果 status == 256，截断为 unsigned char → 0 → 变成 false！

// 从 Java byte[] 数组中读取数据时的典型模式
JNIEXPORT void JNICALL
Java_com_example_NativeLib_processBytes(JNIEnv *env, jobject thiz,
                                         jbyteArray data) {
    jsize len = (*env)->GetArrayLength(env, data);          // 获取数组长度
    jbyte *buf = (*env)->GetByteArrayElements(env, data, NULL); // 获取数组指针
 
    for (jsize i = 0; i < len; i++) {
        jbyte b = buf[i];                // 每个元素都是 signed char，范围 -128~127
        unsigned char ub = (unsigned char)b;  // 如需无符号操作，显式转换
        // ... 处理数据 ...
    }
 
    (*env)->ReleaseByteArrayElements(env, data, buf, 0);   // 释放资源（必须！）
}

// jchar 是 16 位，可以直接与 wchar_t 配合使用（在 Windows 上 wchar_t 也是 16 位）
// 但在 Linux 上 wchar_t 是 32 位，需注意差异
JNIEXPORT jchar JNICALL
Java_com_example_NativeLib_toUpperCase(JNIEnv *env, jobject thiz, jchar ch) {
    // jchar 本质是 unsigned short (0~65535)
    if (ch >= 'a' && ch <= 'z') {       // ASCII 范围内的简单大写转换
        return ch - ('a' - 'A');        // 计算偏移量完成转换
    }
    return ch;                          // 非小写字母直接返回
}

// 一个简单的加法 Native 方法
JNIEXPORT jint JNICALL
Java_com_example_NativeLib_add(JNIEnv *env, jobject thiz,
                                jint a, jint b) {
    // jint 就是 int，可以直接参与所有 C 算术运算
    jint result = a + b;   // 32 位有符号加法，溢出行为与 Java 一致（wrap around）
    return result;
}

// 经典模式：用 jlong 在 Java 层保存 Native 对象指针
JNIEXPORT jlong JNICALL
Java_com_example_NativeLib_nativeCreate(JNIEnv *env, jobject thiz) {
    // 在堆上创建一个 C++ 对象
    MyNativeObject *obj = new MyNativeObject();
 
    // 将指针转为 jlong 返回给 Java 层保存
    // reinterpret_cast 将指针的地址值重新解释为 64 位整数
    return reinterpret_cast<jlong>(obj);
}
 
JNIEXPORT void JNICALL
Java_com_example_NativeLib_nativeProcess(JNIEnv *env, jobject thiz,
                                          jlong nativePtr) {
    // 从 Java 层取回指针，还原为 C++ 对象指针
    MyNativeObject *obj = reinterpret_cast<MyNativeObject*>(nativePtr);
    obj->process();   // 调用 Native 对象的方法
}

JNIEXPORT jdouble JNICALL
Java_com_example_NativeLib_computeDistance(JNIEnv *env, jobject thiz,
                                            jdouble x1, jdouble y1,
                                            jdouble x2, jdouble y2) {
    // jdouble 就是 double，可以直接调用 C 标准数学库函数
    jdouble dx = x2 - x1;   // 横坐标差
    jdouble dy = y2 - y1;   // 纵坐标差
    return sqrt(dx * dx + dy * dy);  // 欧几里得距离公式
}

jsize len = (*env)->GetArrayLength(env, array);  // 返回 jsize，语义明确：这是"长度"
jsize strLen = (*env)->GetStringLength(env, str); // 字符串长度，同样返回 jsize

// Java: public native void doSomething();
JNIEXPORT void JNICALL
Java_com_example_NativeLib_doSomething(JNIEnv *env, jobject thiz) {
    // 无返回值，直接执行逻辑
    printf("Hello from JNI!\n");
}

┌──────────────────────────────────────────────────────────────────────────┐
│                    内存布局对比 (Memory Layout)                          │
├──────────────────────────────────────────────────────────────────────────┤
│                                                                          │
│  Java long (所有平台):                                                    │
│  ┌─────────────────────────────────────────────────────────────────────┐ │
│  │                          64 bits (8 bytes)                          │ │
│  └─────────────────────────────────────────────────────────────────────┘ │
│                                                                          │
│  C long (Windows x64 / Android ARM32):                                   │
│  ┌──────────────────────────────┐                                        │
│  │       32 bits (4 bytes)      │  ← 只有一半！高 32 位数据丢失         │
│  └──────────────────────────────┘                                        │
│                                                                          │
│  C long long (所有平台) → 即 jlong:                                      │
│  ┌─────────────────────────────────────────────────────────────────────┐ │
│  │                          64 bits (8 bytes)                          │ │
│  └─────────────────────────────────────────────────────────────────────┘ │
│                                                                          │
│  ✅ jlong = long long → 完美匹配 Java long，跨平台安全                   │
└──────────────────────────────────────────────────────────────────────────┘

jint   i = 42;
jlong  l = 1234567890123LL;
jfloat f = 3.14f;
 
// 使用正确的 printf 格式说明符
printf("jint:   %d\n", i);          // %d 对应 32 位 int
printf("jlong:  %lld\n", (long long)l);  // %lld 对应 long long
printf("jfloat: %f\n", f);          // %f 对应 float/double（printf 中 float 自动提升为 double）

// jni.h 中 C 语言的定义（简化版）
typedef void*           jobject;    // 所有引用类型的不透明指针
typedef jobject         jclass;     // 类引用，本质上也是 jobject
typedef jobject         jstring;    // 字符串引用
typedef jobject         jthrowable; // 异常引用
typedef jobject         jarray;     // 数组基类引用
typedef jarray          jintArray;  // int[] 数组引用
typedef jarray          jlongArray; // long[] 数组引用
// ... 其他数组类型类似

// jni.h 中 C++ 的定义（简化版）
class _jobject {};                          // 基类：空类，仅作为类型标记
class _jclass : public _jobject {};         // jclass 继承 _jobject
class _jstring : public _jobject {};        // jstring 继承 _jobject
class _jthrowable : public _jobject {};     // jthrowable 继承 _jobject
class _jarray : public _jobject {};         // jarray 继承 _jobject
class _jintArray : public _jarray {};       // jintArray 继承 _jarray
class _jlongArray : public _jarray {};      // jlongArray 继承 _jarray
// ... 其他数组类型类似
 
typedef _jobject*       jobject;            // 指向 _jobject 实例的指针
typedef _jclass*        jclass;             // 指向 _jclass 实例的指针
typedef _jstring*       jstring;            // 指向 _jstring 实例的指针
typedef _jarray*        jarray;             // 指向 _jarray 实例的指针
typedef _jintArray*     jintArray;          // 指向 _jintArray 实例的指针

// Java 侧定义
public class Person {
    public String name;  // 姓名字段
    public int age;      // 年龄字段
 
    // 声明一个 native 方法，接收一个 Person 对象
    public native void printInfo(Person p);
}

/*
 * Class:     Person
 * Method:    printInfo
 * Signature: (LPerson;)V
 */
JNIEXPORT void JNICALL Java_Person_printInfo
  (JNIEnv *env,       // JNI 环境指针，所有 JNI 函数的入口
   jobject thiz,      // 调用此 native 方法的 Java 对象自身（即 this）
   jobject p)         // 参数 Person p，映射为 jobject
{
    // 在这里通过 JNI 函数操作 jobject
}

JNIEXPORT void JNICALL Java_Person_printInfo
  (JNIEnv *env, jobject thiz, jobject p)
{
    // ========== 第一步：获取 Person 类的 jclass ==========
    // FindClass 通过全限定类名查找类（使用 / 分隔包名）
    jclass personClass = env->FindClass("Person");
 
    // ========== 第二步：获取字段 ID ==========
    // GetFieldID 参数：(类引用, 字段名, 字段类型签名)
    // "name" 字段的类型签名是 "Ljava/lang/String;"
    jfieldID nameFieldId = env->GetFieldID(personClass, "name", "Ljava/lang/String;");
    // "age" 字段的类型签名是 "I"（代表 int）
    jfieldID ageFieldId = env->GetFieldID(personClass, "age", "I");
 
    // ========== 第三步：通过字段 ID 读取字段值 ==========
    // GetObjectField 返回 jobject，这里我们知道它是 jstring
    jstring nameStr = (jstring) env->GetObjectField(p, nameFieldId);
    // GetIntField 直接返回 jint
    jint age = env->GetIntField(p, ageFieldId);
 
    // ========== 第四步：将 jstring 转为 C 风格字符串 ==========
    const char *nameCStr = env->GetStringUTFChars(nameStr, NULL);
 
    // ========== 输出信息 ==========
    printf("Name: %s, Age: %d\n", nameCStr, (int)age);
 
    // ========== 第五步：释放字符串资源（极其重要！） ==========
    env->ReleaseStringUTFChars(nameStr, nameCStr);
}

// Java 侧
public class MathUtils {
    // 静态 native 方法
    public static native int add(int a, int b);
}

// Native 侧生成的头文件
JNIEXPORT jint JNICALL Java_MathUtils_add
  (JNIEnv *env,
   jclass clazz,   // 注意！这里是 jclass，不是 jobject
   jint a,         // 参数 a
   jint b)         // 参数 b
{
    return a + b;  // 简单的加法运算
}

// 通过全限定名查找类（用 / 替代 Java 中的 .）
jclass stringClass = env->FindClass("java/lang/String");
 
// 查找内部类时使用 $ 分隔
jclass entryClass = env->FindClass("java/util/Map$Entry");
 
// 查找数组类型
jclass intArrayClass = env->FindClass("[I");          // int[]
jclass strArrayClass = env->FindClass("[Ljava/lang/String;"); // String[]

JNIEXPORT void JNICALL Java_Demo_testStatic
  (JNIEnv *env, jclass clazz)
{
    // ========== 访问静态字段 ==========
    // 获取 Integer.MAX_VALUE 的字段 ID
    jclass integerClass = env->FindClass("java/lang/Integer");
    // GetStaticFieldID：注意是 Static 版本
    jfieldID maxValId = env->GetStaticFieldID(integerClass, "MAX_VALUE", "I");
    // GetStaticIntField：读取静态 int 字段
    jint maxVal = env->GetStaticIntField(integerClass, maxValId);
    printf("Integer.MAX_VALUE = %d\n", (int)maxVal);  // 输出：2147483647
 
    // ========== 调用静态方法 ==========
    // 获取 String.valueOf(int) 方法的 ID
    jclass stringClass = env->FindClass("java/lang/String");
    // 方法签名 "(I)Ljava/lang/String;" 表示参数为 int，返回 String
    jmethodID valueOfId = env->GetStaticMethodID(
        stringClass, "valueOf", "(I)Ljava/lang/String;");
    // CallStaticObjectMethod：调用静态方法并接收返回的 jobject
    jstring result = (jstring) env->CallStaticObjectMethod(
        stringClass, valueOfId, (jint)42);
 
    // 将结果转为 C 字符串并输出
    const char *cStr = env->GetStringUTFChars(result, NULL);
    printf("String.valueOf(42) = %s\n", cStr);  // 输出："42"
    env->ReleaseStringUTFChars(result, cStr);    // 释放资源
}

// Java 侧
public class StringDemo {
    // 接收一个字符串，返回处理后的字符串
    public native String processString(String input);
}

JNIEXPORT jstring JNICALL Java_StringDemo_processString
  (JNIEnv *env, jobject thiz, jstring input)
{
    // ========== 1. 空指针检查（防御性编程） ==========
    if (input == NULL) {
        // 直接返回一个 Native 创建的新字符串
        return env->NewStringUTF("input is null!");
    }
 
    // ========== 2. 获取字符串的 Modified UTF-8 表示 ==========
    // 第二个参数 isCopy：指向 jboolean 的指针
    // 如果 JVM 创建了副本则设为 JNI_TRUE，否则设为 JNI_FALSE
    // 传 NULL 表示我们不关心是否是副本
    jboolean isCopy;
    const char *nativeStr = env->GetStringUTFChars(input, &isCopy);
 
    // ========== 3. 检查是否获取成功 ==========
    // 如果 JVM 内存不足，GetStringUTFChars 可能返回 NULL
    if (nativeStr == NULL) {
        // 此时 JVM 已经抛出了 OutOfMemoryError
        // 直接返回 NULL，让异常向上传播
        return NULL;
    }
 
    // ========== 4. 在 Native 侧处理字符串 ==========
    printf("isCopy = %s\n", isCopy ? "true" : "false");
    printf("Original: %s\n", nativeStr);
    printf("UTF-8 byte length: %d\n", env->GetStringUTFLength(input));
    printf("UTF-16 char count: %d\n", env->GetStringLength(input));
 
    // 构造新的 C 字符串（添加前缀）
    char buffer[256];
    snprintf(buffer, sizeof(buffer), "[Processed] %s", nativeStr);
 
    // ========== 5. 释放字符串资源（必须与 Get 配对！） ==========
    env->ReleaseStringUTFChars(input, nativeStr);
    // 此时 nativeStr 已经是悬空指针，不能再使用！
 
    // ========== 6. 创建并返回新的 jstring ==========
    return env->NewStringUTF(buffer);
}

┌──────────────────────────┬──────────────────────┬──────────────────────┐
│         特性              │  Standard UTF-8      │  Modified UTF-8      │
├──────────────────────────┼──────────────────────┼──────────────────────┤
│ 空字符 '\0' (U+0000)     │  1 字节: 0x00        │  2 字节: 0xC0 0x80   │
├──────────────────────────┼──────────────────────┼──────────────────────┤
│ 补充字符 (U+10000+)      │  4 字节              │  6 字节 (代理对)      │
├──────────────────────────┼──────────────────────┼──────────────────────┤
│ 字符串结尾               │  不依赖 \0           │  以 \0 结尾           │
└──────────────────────────┴──────────────────────┴──────────────────────┘

// Java 侧
public class ArrayDemo {
    // 接收 int[] 并返回所有元素的和
    public native int sumArray(int[] arr);
}

JNIEXPORT jint JNICALL Java_ArrayDemo_sumArray
  (JNIEnv *env, jobject thiz, jintArray arr)
{
    // ========== 1. 获取数组长度 ==========
    jsize length = env->GetArrayLength(arr);
 
    // ========== 2. 获取数组元素指针 ==========
    // GetIntArrayElements 可能返回：
    //   - 指向 JVM 内部数组数据的直接指针（零拷贝）
    //   - 一份堆外拷贝（如果 GC 可能移动数组）
    // isCopy 参数同 GetStringUTFChars
    jboolean isCopy;
    jint *elements = env->GetIntArrayElements(arr, &isCopy);
 
    // ========== 3. 检查是否获取成功 ==========
    if (elements == NULL) {
        return 0;  // OutOfMemoryError 已被 JVM 抛出
    }
 
    // ========== 4. 像操作普通 C 数组一样使用 ==========
    jint sum = 0;
    for (jsize i = 0; i < length; i++) {
        sum += elements[i];  // 直接通过下标访问
    }
 
    // ========== 5. 释放数组（必须！）==========
    // 第三个参数 mode 控制释放行为：
    //   0          : 将修改写回 Java 数组，并释放 native 缓冲区
    //   JNI_COMMIT : 将修改写回 Java 数组，但不释放缓冲区（可继续使用）
    //   JNI_ABORT  : 不写回修改，直接释放缓冲区（丢弃更改）
    env->ReleaseIntArrayElements(arr, elements, JNI_ABORT);
    // 使用 JNI_ABORT 因为我们只是读取，没有修改数组
 
    return sum;
}

// 在 Native 侧创建一个 int[5] 并返回给 Java
JNIEXPORT jintArray JNICALL Java_ArrayDemo_createArray
  (JNIEnv *env, jobject thiz)
{
    // ========== 1. 创建长度为 5 的 int 数组 ==========
    jintArray result = env->NewIntArray(5);
    if (result == NULL) {
        return NULL;  // 内存分配失败
    }
 
    // ========== 2. 准备要填充的数据 ==========
    jint values[] = {10, 20, 30, 40, 50};
 
    // ========== 3. 将 C 数组数据复制到 Java 数组 ==========
    // SetIntArrayRegion(目标数组, 起始索引, 长度, 源数据)
    env->SetIntArrayRegion(result, 0, 5, values);
    // SetXxxArrayRegion 是一种更轻量的方式，不需要 Get/Release 配对
 
    return result;  // 返回给 Java 侧
}

JNIEXPORT void JNICALL Java_ArrayDemo_processStringArray
  (JNIEnv *env, jobject thiz, jobjectArray strArr)
{
    // ========== 1. 获取数组长度 ==========
    jsize length = env->GetArrayLength(strArr);
 
    // ========== 2. 遍历数组，逐个获取元素 ==========
    for (jsize i = 0; i < length; i++) {
        // GetObjectArrayElement：获取指定索引处的元素
        // 返回 jobject，此处实际是 jstring
        jstring element = (jstring) env->GetObjectArrayElement(strArr, i);
 
        // 将 jstring 转为 C 字符串
        const char *cStr = env->GetStringUTFChars(element, NULL);
        if (cStr != NULL) {
            printf("strArr[%d] = %s\n", (int)i, cStr);
            // 释放字符串资源
            env->ReleaseStringUTFChars(element, cStr);
        }
 
        // 注意：GetObjectArrayElement 返回的是 Local Reference
        // 在循环中大量创建局部引用时，应使用 DeleteLocalRef 避免溢出
        env->DeleteLocalRef(element);
    }
}
 
// 创建对象数组
JNIEXPORT jobjectArray JNICALL Java_ArrayDemo_createStringArray
  (JNIEnv *env, jobject thiz)
{
    // ========== 1. 查找 String 类 ==========
    jclass stringClass = env->FindClass("java/lang/String");
 
    // ========== 2. 创建 String[3]，初始值为 NULL ==========
    // NewObjectArray(长度, 元素类型, 默认值)
    jobjectArray result = env->NewObjectArray(3, stringClass, NULL);
 
    // ========== 3. 逐个设置元素 ==========
    env->SetObjectArrayElement(result, 0, env->NewStringUTF("Hello"));
    env->SetObjectArrayElement(result, 1, env->NewStringUTF("JNI"));
    env->SetObjectArrayElement(result, 2, env->NewStringUTF("World"));
 
    return result;  // 返回 String[]{"Hello", "JNI", "World"}
}

// 使用 Region API 的示例（推荐用于小规模、局部访问）
void readPartialArray(JNIEnv *env, jintArray arr) {
    jint buffer[10];  // 栈上分配的本地缓冲区
 
    // 从索引 5 开始，复制 10 个元素到 buffer
    env->GetIntArrayRegion(arr, 5, 10, buffer);
    // 无需 Release！buffer 是我们自己管理的内存
 
    for (int i = 0; i < 10; i++) {
        printf("arr[%d] = %d\n", i + 5, buffer[i]);
    }
}

// ❌ 错误示范：局部引用泄漏
void badLoop(JNIEnv *env, jobjectArray arr) {
    jsize len = env->GetArrayLength(arr);
    for (jsize i = 0; i < len; i++) {
        // 每次迭代创建一个新的局部引用
        jobject elem = env->GetObjectArrayElement(arr, i);
        // ... 使用 elem ...
        // 没有 DeleteLocalRef！如果 len > 512，程序崩溃！
    }
}
 
// ✅ 正确做法：及时释放局部引用
void goodLoop(JNIEnv *env, jobjectArray arr) {
    jsize len = env->GetArrayLength(arr);
    for (jsize i = 0; i < len; i++) {
        jobject elem = env->GetObjectArrayElement(arr, i);
        // ... 使用 elem ...
        env->DeleteLocalRef(elem);  // 每次迭代结束时释放
    }
}
 
// ✅ 另一种方案：使用 PushLocalFrame / PopLocalFrame
void frameLoop(JNIEnv *env, jobjectArray arr) {
    jsize len = env->GetArrayLength(arr);
    for (jsize i = 0; i < len; i++) {
        env->PushLocalFrame(16);  // 进入新的引用帧，容量 16
        jobject elem = env->GetObjectArrayElement(arr, i);
        // ... 在此帧内随意创建局部引用 ...
        env->PopLocalFrame(NULL);  // 自动释放此帧内的所有局部引用
    }
}

 ┌─────────────────────────────────────────────────────────────────────┐
 │                        Native Stack Frame                          │
 │                                                                    │
 │   jobject thiz  ──────┐     jstring name  ──────┐                  │
 │   jclass  clazz ──┐   │     jintArray arr ──┐   │                  │
 │                    │   │                     │   │                  │
 └────────────────────┼───┼─────────────────────┼───┼──────────────────┘
                      │   │                     │   │
 ┌────────────────────▼───▼─────────────────────▼───▼──────────────────┐
 │              JNI Local Reference Table                              │
 │  ┌────────┬────────┬────────┬────────┬─────────┬────────┐          │
 │  │ Slot 0 │ Slot 1 │ Slot 2 │ Slot 3 │ Slot 4  │  ...   │          │
 │  │   ●    │   ●    │   ●    │   ●    │  NULL   │        │          │
 │  └───┼────┴───┼────┴───┼────┴───┼────┴─────────┴────────┘          │
 └──────┼────────┼────────┼────────┼───────────────────────────────────┘
        │        │        │        │
 ┌──────▼────────▼────────▼────────▼───────────────────────────────────┐
 │                          JVM Heap                                   │
 │                                                                     │
 │   ┌──────────────┐  ┌───────────────────┐  ┌──────────────────┐    │
 │   │ Person 对象   │  │ Class<Person> 对象 │  │ String 对象      │    │
 │   │ name: ──────────►│ "Person"          │  │ "Hello JNI"     │    │
 │   │ age: 25       │  │ methods[...]      │  │ char[]: [H,e,.] │    │
 │   └──────────────┘  └───────────────────┘  └──────────────────┘    │
 │                                                                     │
 │   ┌──────────────────────────────────────┐                          │
 │   │ int[] 数组对象                        │                          │
 │   │ length: 5                             │                          │
 │   │ data: [10, 20, 30, 40, 50]           │                          │
 │   └──────────────────────────────────────┘                          │
 └─────────────────────────────────────────────────────────────────────┘

public class Config {
    public static native String getVersion();
}

JNIEXPORT jstring JNICALL Java_Config_getVersion(JNIEnv *env, jclass clazz);

public class Calculator {
    // 重载方法：同名 add，但参数不同
    public int add(int a, int b) { return a + b; }           // 方法①
    public double add(double a, double b) { return a + b; }   // 方法②
    public long add(long a, long b, long c) { return a+b+c; } // 方法③
}

// 在 Native 代码中通过签名查找字段
// 假设 Java 类有一个字段: String name;
jfieldID fid = env->GetFieldID(
    clazz,            // 目标类的 jclass
    "name",           // 字段名
    "Ljava/lang/String;"  // 字段的类型签名（注意末尾分号！）
);

public void init()

参数列表: 无  →  ()
返回值:  void →  V
─────────────────
方法签名:      ()V

public int add(int a, int b)

参数列表: int, int  →  I + I  →  II
返回值:   int       →  I
───────────────────────────
方法签名:            (II)I

public long compute(int x, double y, boolean flag)

参数列表: int, double, boolean → I + D + Z → IDZ
返回值:   long                 → J
───────────────────────────────────
方法签名:                       (IDZ)J

public String greet(String name, int age)

参数列表: String, int → Ljava/lang/String; + I → Ljava/lang/String;I
返回值:   String      → Ljava/lang/String;
──────────────────────────────────────────────
方法签名:              (Ljava/lang/String;I)Ljava/lang/String;

public int sumArray(int[] arr)

参数列表: int[]  →  [I
返回值:   int    →  I
─────────────────────
方法签名:         ([I)I

public Object[][] process(String name, int[] ids, double factor, boolean[][] mask)

参数列表: String      → Ljava/lang/String;
          int[]       → [I
          double      → D
          boolean[][] → [[Z
          拼接        → Ljava/lang/String;[ID[[Z
 
返回值:   Object[][]  → [[Ljava/lang/Object;
────────────────────────────────────────────────
方法签名:              (Ljava/lang/String;[ID[[Z)[[Ljava/lang/Object;

public MyClass(int id, String name)

方法名:   <init>
方法签名: (ILjava/lang/String;)V

# 编译 Java 文件
javac Calculator.java
 
# 使用 -s 参数输出签名（-p 表示包含 private 成员）
javap -s -p Calculator

Compiled from "Calculator.java"
public class Calculator {
  public Calculator();
    descriptor: ()V
 
  public int add(int, int);
    descriptor: (II)I
 
  public double add(double, double);
    descriptor: (DD)D
 
  public long add(long, long, long);
    descriptor: (JJJ)J
}

public class UserManager {
    // 目标方法：Native 层将回调此方法
    public String formatUser(String name, int age, boolean isVip) {
        String vipTag = isVip ? "[VIP]" : "";
        return vipTag + name + " (age: " + age + ")";
    }
 
    // native 方法声明
    public native void callFromNative();
}

#include <jni.h>
 
extern "C"
JNIEXPORT void JNICALL
Java_com_example_UserManager_callFromNative(JNIEnv *env, jobject thiz) {
 
    // ==================== Step 1: 获取 jclass ====================
    // 通过 jobject 实例获取其所属的 Java 类
    jclass clazz = env->GetObjectClass(thiz);
 
    // ==================== Step 2: 获取 jmethodID ====================
    // 方法名: "formatUser"
    // 签名分析:
    //   参数: String       → Ljava/lang/String;
    //         int          → I
    //         boolean      → Z
    //   返回: String       → Ljava/lang/String;
    //   完整签名: (Ljava/lang/String;IZ)Ljava/lang/String;
    jmethodID mid = env->GetMethodID(
        clazz,                                          // 目标类
        "formatUser",                                   // 方法名
        "(Ljava/lang/String;IZ)Ljava/lang/String;"      // ★ 方法签名
    );
 
    // 检查方法是否找到（签名写错会返回 NULL）
    if (mid == nullptr) {
        // 签名错误！JVM 会抛出 NoSuchMethodError
        return;
    }
 
    // ==================== Step 3: 准备参数 ====================
    // 创建 Java String 对象作为第一个参数
    jstring nameArg = env->NewStringUTF("Alice");       // 构造 jstring
    jint ageArg = 28;                                    // int 参数直接传值
    jboolean vipArg = JNI_TRUE;                          // boolean 参数
 
    // ==================== Step 4: 调用 Java 方法 ====================
    // CallObjectMethod 用于返回值为引用类型的方法调用
    jobject result = env->CallObjectMethod(
        thiz,           // 调用目标对象
        mid,            // 方法 ID
        nameArg,        // 参数1: String
        ageArg,         // 参数2: int
        vipArg          // 参数3: boolean
    );
 
    // ==================== Step 5: 处理返回值 ====================
    // 将返回的 jobject 强转为 jstring
    jstring resultStr = (jstring) result;
    // 获取 C 风格字符串以便打印
    const char *cStr = env->GetStringUTFChars(resultStr, nullptr);
 
    // 输出结果: "[VIP]Alice (age: 28)"
    printf("Result from Java: %s\n", cStr);
 
    // ==================== Step 6: 释放资源 ====================
    // 释放 GetStringUTFChars 分配的内存
    env->ReleaseStringUTFChars(resultStr, cStr);
    // 释放局部引用（可选，函数返回后自动释放，但显式释放是好习惯）
    env->DeleteLocalRef(nameArg);
    env->DeleteLocalRef(resultStr);
}

// 推荐：将高频签名定义为常量，集中管理
static const char* SIG_STRING       = "Ljava/lang/String;";  // String 类型签名
static const char* SIG_VOID_VOID    = "()V";                  // void method()
static const char* SIG_INT_INT      = "(II)I";                // int method(int, int)
static const char* SIG_STRING_TO_STRING =                      // String method(String)
    "(Ljava/lang/String;)Ljava/lang/String;";

public boolean checkUser(String name, int[] scores, long timestamp)

字符: '你'  (U+4F60)
 
标准 UTF-8:    0xE4 0xBD 0xA0         (3 bytes)
Modified UTF-8: 0xE4 0xBD 0xA0         (3 bytes)  ← 相同
 
字符: '\0'  (U+0000)
 
标准 UTF-8:    0x00                    (1 byte)
Modified UTF-8: 0xC0 0x80              (2 bytes)  ← 不同！
 
字符: '😀'  (U+1F600)
 
标准 UTF-8:    0xF0 0x9F 0x98 0x80    (4 bytes)
Modified UTF-8: 0xED 0xA0 0xBD        (6 bytes, 代理对编码)
               0xED 0xB8 0x80         ← 不同！

// 参数说明:
// env      — JNI 环境指针
// string   — Java 传入的 jstring 对象
// isCopy   — 输出参数，JNI_TRUE 表示返回的是副本，JNI_FALSE 表示直接指向 JVM 内部数据
const char* GetStringUTFChars(JNIEnv *env, jstring string, jboolean *isCopy);

#include <jni.h>    // JNI 头文件
#include <stdio.h>  // printf
 
// Native 方法实现：接收 Java String，在 Native 层打印
JNIEXPORT void JNICALL
Java_com_example_StringDemo_printFromNative(JNIEnv *env, jobject thiz, jstring jMsg) {
 
    // ① 空指针检查：Java 可能传入 null
    if (jMsg == NULL) {                          // 防御性编程，避免传入 null 导致崩溃
        printf("Received null string\n");        // 打印提示信息
        return;                                  // 提前返回，不做后续处理
    }
 
    // ② 将 jstring 转为 C 字符串（Modified UTF-8）
    // 第三个参数传 NULL，表示我们不关心是拷贝还是固定
    const char *cStr = (*env)->GetStringUTFChars(env, jMsg, NULL);
 
    // ③ 检查转换是否成功（内存不足时可能返回 NULL）
    if (cStr == NULL) {                          // GetStringUTFChars 失败会返回 NULL
        // 此时 JVM 已经抛出了 OutOfMemoryError，直接返回即可
        return;                                  // 不需要手动抛异常
    }
 
    // ④ 正常使用 C 字符串
    printf("Message from Java: %s\n", cStr);     // 打印字符串内容
    printf("UTF-8 byte length: %zu\n",           // 打印字节长度
           strlen(cStr));                         // strlen 计算到 \0 的字节数
 
    // ⑤ 【关键】使用完毕后必须释放！
    (*env)->ReleaseStringUTFChars(env, jMsg, cStr);  // 释放 Native 内存或取消固定
    // 释放后 cStr 变成悬垂指针（dangling pointer），不可再使用
    cStr = NULL;                                      // 良好习惯：置为 NULL 防止误用
}

// 参数说明:
// env    — JNI 环境指针
// string — 原始的 jstring 对象（必须与 Get 时的相同）
// utf    — GetStringUTFChars 返回的指针（必须与 Get 时的返回值相同）
void ReleaseStringUTFChars(JNIEnv *env, jstring string, const char *utf);

JNIEXPORT jint JNICALL
Java_com_example_StringDemo_processString(JNIEnv *env, jobject thiz, jstring input) {
 
    // 获取 C 字符串
    const char *str = (*env)->GetStringUTFChars(env, input, NULL);  // 转换为 UTF-8
    if (str == NULL) {                  // 检查是否成功
        return -1;                      // 失败时直接返回，无需 Release（Get 已失败）
    }
 
    jint result = 0;                    // 定义返回值
 
    // 假设有多个处理分支
    if (strlen(str) == 0) {             // 分支1：空字符串
        result = 0;                     // 设置返回值
        goto cleanup;                   // 跳转到统一释放点（避免忘记 Release）
    }
 
    if (str[0] == '#') {               // 分支2：以 # 开头的特殊字符串
        result = -2;                    // 设置错误码
        goto cleanup;                   // 跳转到统一释放点
    }
 
    result = (jint)strlen(str);         // 正常情况：返回字符串长度
 
cleanup:                                // 统一释放点
    (*env)->ReleaseStringUTFChars(env, input, str);  // 所有分支都在此释放
    str = NULL;                         // 置空指针
    return result;                      // 返回结果
}

// 获取 UTF-16 字符数组指针（每个字符 2 字节）
const jchar* GetStringChars(JNIEnv *env, jstring string, jboolean *isCopy);
 
// 释放 UTF-16 字符数组
void ReleaseStringChars(JNIEnv *env, jstring string, const jchar *chars);

// 将 jstring 的指定区域转为 Modified UTF-8，拷贝到用户提供的缓冲区
// start — 起始字符索引（UTF-16 字符索引，非字节偏移）
// len   — 要拷贝的字符数量
// buf   — 用户提供的输出缓冲区
void GetStringUTFRegion(JNIEnv *env, jstring str, jsize start, jsize len, char *buf);

JNIEXPORT void JNICALL
Java_com_example_StringDemo_regionCopy(JNIEnv *env, jobject thiz, jstring input) {
 
    // 获取字符串的 UTF-16 字符数量（注意：不是字节数）
    jsize charLen = (*env)->GetStringLength(env, input);           // 获取字符长度
 
    // 获取 Modified UTF-8 的字节数量
    jsize utfLen = (*env)->GetStringUTFLength(env, input);         // 获取 UTF-8 字节长度
 
    // 在栈上分配缓冲区（+1 为 '\0' 终止符预留空间）
    // 注意：仅当 utfLen 较小时才适合栈分配，否则应使用 malloc
    char buf[256];                                                  // 栈上缓冲区
    if (utfLen < 256) {                                            // 安全检查
        // 拷贝整个字符串到栈缓冲区
        (*env)->GetStringUTFRegion(env, input, 0, charLen, buf);   // 区域拷贝
        buf[utfLen] = '\0';                                        // 手动添加终止符
 
        printf("Stack buffer content: %s\n", buf);                 // 使用缓冲区
        // 无需调用任何 Release 函数！
    }
}

// 从 Modified UTF-8 的 C 字符串创建一个新的 Java String 对象
// bytes — 以 \0 结尾的 Modified UTF-8 字符串
// 返回值 — 新建的 jstring 对象，失败返回 NULL（并抛出 OutOfMemoryError）
jstring NewStringUTF(JNIEnv *env, const char *bytes);

JNIEXPORT jstring JNICALL
Java_com_example_StringDemo_greetFromNative(JNIEnv *env, jobject thiz, jstring jName) {
 
    // ① 获取 Java 传来的名字
    const char *name = (*env)->GetStringUTFChars(env, jName, NULL);  // 转换为 C 字符串
    if (name == NULL) {                   // 检查是否成功
        return NULL;                      // 失败则返回 null 给 Java
    }
 
    // ② 在 Native 层拼接字符串
    char greeting[512];                   // 栈上缓冲区
    snprintf(greeting, sizeof(greeting),  // 安全格式化（防溢出）
             "Hello, %s! From Native.", name);
 
    // ③ 释放原始字符串（在创建新字符串之前释放，减少内存占用）
    (*env)->ReleaseStringUTFChars(env, jName, name);  // 释放
    name = NULL;                          // 置空
 
    // ④ 创建新的 Java String 并返回
    jstring result = (*env)->NewStringUTF(env, greeting);  // 从 C 字符串创建 jstring
    // result 可能为 NULL（OOM），Java 层会收到 null
    return result;                        // 返回给 Java
}

// ❌ 错误示例：在子线程中使用已释放的指针
const char *str = (*env)->GetStringUTFChars(env, jStr, NULL);
(*env)->ReleaseStringUTFChars(env, jStr, str);
 
// ... 后续在另一个线程中 ...
printf("%s\n", str);  // 未定义行为！str 已被释放

jsize charLen = (*env)->GetStringLength(env, jStr);       // UTF-16 字符数量
jsize byteLen = (*env)->GetStringUTFLength(env, jStr);    // Modified UTF-8 字节数量
 
// 对于纯 ASCII 字符串:   charLen == byteLen
// 对于中文字符串 "你好":  charLen = 2,  byteLen = 6
// 对于 Emoji "😀":       charLen = 2 (代理对),  byteLen = 6

#include <jni.h>   // JNI 头文件
#include <string>  // std::string
 
// RAII 封装类：自动管理 GetStringUTFChars / ReleaseStringUTFChars 的生命周期
class JniString {
public:
    // 构造函数：获取 C 字符串
    JniString(JNIEnv *env, jstring jStr)
        : env_(env),                                              // 保存 env 指针
          jStr_(jStr),                                            // 保存 jstring 引用
          cStr_(nullptr) {                                        // 初始化为空
        if (jStr_ != nullptr) {                                   // 非空才获取
            cStr_ = env_->GetStringUTFChars(jStr_, nullptr);      // 获取 C 字符串
        }
    }
 
    // 析构函数：自动释放
    ~JniString() {
        if (cStr_ != nullptr) {                                   // 仅在成功获取时释放
            env_->ReleaseStringUTFChars(jStr_, cStr_);            // 自动释放
        }
    }
 
    // 禁止拷贝（防止 double-free）
    JniString(const JniString&) = delete;                         // 删除拷贝构造
    JniString& operator=(const JniString&) = delete;              // 删除拷贝赋值
 
    // 获取 C 字符串指针
    const char* c_str() const { return cStr_; }                   // 返回内部指针
 
    // 转为 std::string（安全拷贝，可跨线程使用）
    std::string toString() const {                                // 转为 std::string
        return cStr_ ? std::string(cStr_) : std::string();        // 空安全
    }
 
    // 判断是否有效
    explicit operator bool() const { return cStr_ != nullptr; }   // 支持 if(jniStr) 判断
 
private:
    JNIEnv *env_;          // JNI 环境指针
    jstring jStr_;         // 原始 jstring
    const char *cStr_;     // 转换后的 C 字符串
};
 
// 使用示例
JNIEXPORT void JNICALL
Java_com_example_StringDemo_elegantPrint(JNIEnv *env, jobject thiz, jstring jMsg) {
    JniString msg(env, jMsg);             // 构造时自动 Get
    if (msg) {                            // 检查是否有效
        printf("Message: %s\n", msg.c_str());  // 安全使用
    }
    // 离开作用域时自动 Release，无需手动管理！
}

JNIEXPORT jstring JNICALL
Java_com_example_Test_process(JNIEnv *env, jobject thiz, jstring input) {
    const char *str = (*env)->GetStringUTFChars(env, input, NULL);
    if (strlen(str) > 100) {
        return (*env)->NewStringUTF(env, "too long");
    }
    char buf[256];
    snprintf(buf, 256, "Result: %s", str);
    (*env)->ReleaseStringUTFChars(env, input, str);
    return (*env)->NewStringUTF(env, buf);
}

// env  : JNI 环境指针
// arr  : 从 Java 传入的 jintArray
jsize len = (*env)->GetArrayLength(env, arr);  // 返回数组元素个数（jsize 即 jint 的别名）

// isCopy: 输出参数，JNI 会填入 JNI_TRUE 或 JNI_FALSE
//         JNI_TRUE  → 返回的是堆内存的 *副本*（copy）
//         JNI_FALSE → 返回的是直接指向 Java 堆的 *原始指针*（pinned）
//         传 NULL 表示"我不关心是不是副本"
jboolean isCopy = JNI_FALSE;
jint *elements = (*env)->GetIntArrayElements(env, arr, &isCopy);
 
// ⚠️ 必须检查返回值！内存不足时返回 NULL
if (elements == NULL) {
    return; // OutOfMemoryError 已由 JNI 自动抛出
}

// ===== 场景 A: isCopy == JNI_FALSE (Pinned) =====
//
//   Java Heap                          Native Code
//  ┌───────────────────┐
//  │  int[] arr        │
//  │ ┌───┬───┬───┬───┐ │
//  │ │ 1 │ 2 │ 3 │ 4 │◄──────────── elements (jint*)
//  │ └───┴───┴───┴───┘ │              直接指向堆内存
//  └───────────────────┘              GC 被阻止移动此对象
//
// ===== 场景 B: isCopy == JNI_TRUE (Copied) =====
//
//   Java Heap                          Native Heap
//  ┌───────────────────┐            ┌───────────────────┐
//  │  int[] arr        │   memcpy   │  malloc'd buffer  │
//  │ ┌───┬───┬───┬───┐ │  ------→   │ ┌───┬───┬───┬───┐ │
//  │ │ 1 │ 2 │ 3 │ 4 │ │            │ │ 1 │ 2 │ 3 │ 4 │◄── elements (jint*)
//  │ └───┴───┴───┴───┘ │            │ └───┴───┴───┴───┘ │
//  └───────────────────┘            └───────────────────┘
//                                    修改此处不影响 Java 堆
//                                    直到 Release 且 mode=0

// arr      : 原始 jintArray 引用
// elements : 之前 Get 返回的 jint* 指针
// mode     : 释放模式（0 / JNI_COMMIT / JNI_ABORT）
(*env)->ReleaseIntArrayElements(env, arr, elements, 0);

public class ArrayDemo {
    // 加载 Native 库
    static {
        System.loadLibrary("arraydemo");
    }
 
    // 声明 native 方法：将 int 数组元素翻倍
    public static native void doubleElements(int[] data);
 
    public static void main(String[] args) {
        int[] data = {10, 20, 30, 40, 50};             // 原始数组
        System.out.println("Before: " + java.util.Arrays.toString(data));
        doubleElements(data);                           // 调用 Native
        System.out.println("After:  " + java.util.Arrays.toString(data));
        // 期望输出: After: [20, 40, 60, 80, 100]
    }
}

#include <jni.h>    // JNI 头文件
#include <stddef.h> // NULL 定义
 
/*
 * Class:     ArrayDemo
 * Method:    doubleElements
 * Signature: ([I)V
 *
 * 参数说明：
 *   env  - JNI 环境指针，所有 JNI 函数都通过它调用
 *   clazz - 调用该 static native 方法的类（ArrayDemo.class）
 *   arr  - Java 传入的 int[] 数组
 */
JNIEXPORT void JNICALL
Java_ArrayDemo_doubleElements(JNIEnv *env, jclass clazz, jintArray arr) {
 
    // 1. 获取数组长度
    jsize len = (*env)->GetArrayLength(env, arr); // 返回元素个数
 
    // 2. 获取数组元素的 Native 指针
    jboolean isCopy = JNI_FALSE;                  // 用于接收是否为副本
    jint *elems = (*env)->GetIntArrayElements(     // 核心 API
        env,        // JNI 环境
        arr,        // Java 数组引用
        &isCopy     // 输出：是否拷贝（可传 NULL）
    );
 
    // 3. 空指针检查（内存不足时返回 NULL）
    if (elems == NULL) {
        return;     // JNI 已自动挂起 OutOfMemoryError
    }
 
    // 4. 在 Native 层操作数组（逐元素翻倍）
    for (jsize i = 0; i < len; i++) {
        elems[i] *= 2;  // 直接通过 C 指针修改（pin 模式下立即生效于 Java 堆）
    }
 
    // 5. 释放资源并将修改写回 Java 堆
    (*env)->ReleaseIntArrayElements(
        env,        // JNI 环境
        arr,        // 原始 Java 数组引用
        elems,      // 之前获取的指针
        0           // mode=0: 写回 + 释放
    );
    // ⚠️ 此行之后 elems 指针已失效，不可再使用！
}

JNIEXPORT void JNICALL
Java_ArrayDemo_processRegion(JNIEnv *env, jclass clazz, jintArray arr) {
 
    jsize len = (*env)->GetArrayLength(env, arr);  // 获取数组总长度
 
    // 只处理前 3 个元素
    jint buf[3];  // 在栈上分配局部缓冲区（适合小数组）
 
    // 从 Java 数组的第 0 个位置开始，拷贝 3 个元素到 buf
    (*env)->GetIntArrayRegion(
        env,    // JNI 环境
        arr,    // Java 数组
        0,      // start: 起始索引
        3,      // len:   拷贝元素数
        buf     // dest:  目标 C 缓冲区
    );
    // ⚠️ 如果 start+len > 数组长度，JNI 会抛出 ArrayIndexOutOfBoundsException
 
    // 修改缓冲区（对 Java 数组无影响）
    for (int i = 0; i < 3; i++) {
        buf[i] += 100;  // 每个元素加 100
    }
 
    // 将修改后的数据写回 Java 数组的 [0, 3) 区间
    (*env)->SetIntArrayRegion(
        env,    // JNI 环境
        arr,    // Java 数组
        0,      // start: 写入起始索引
        3,      // len:   写入元素数
        buf     // src:   源 C 缓冲区
    );
    // 不需要 Release！Region 操作自包含，用完即走。
}

JNIEXPORT void JNICALL
Java_ArrayDemo_criticalProcess(JNIEnv *env, jclass clazz, jintArray arr) {
 
    jsize len = (*env)->GetArrayLength(env, arr); // 获取长度
 
    // 进入 Critical 区域 —— JVM 可能暂停 GC
    jint *elems = (jint *)(*env)->GetPrimitiveArrayCritical(
        env,    // JNI 环境
        arr,    // Java 数组
        NULL    // isCopy（通常传 NULL，不关心）
    );
 
    if (elems == NULL) {
        return; // 内存不足
    }
 
    // ========== Critical 区域内 ==========
    // ✅ 允许：纯计算、内存拷贝、memcpy 等
    for (jsize i = 0; i < len; i++) {
        elems[i] = elems[i] * elems[i]; // 平方操作
    }
    // ❌ 禁止：调用其他 JNI 函数（除了另一个 GetPrimitiveArrayCritical）
    // ❌ 禁止：调用可能阻塞当前线程的系统调用
    // ❌ 禁止：分配新的 Java 对象
    // ========== Critical 区域结束 ==========
 
    // 离开 Critical 区域
    (*env)->ReleasePrimitiveArrayCritical(
        env,    // JNI 环境
        arr,    // Java 数组
        elems,  // 指针
        0       // mode（同 Release<Type>ArrayElements）
    );
}

// Critical 区域的时间线模型
//
//  ──── 时间轴 ─────────────────────────────────────────────→
//
//  GetPrimitiveArrayCritical()           ReleasePrimitiveArrayCritical()
//          │                                       │
//          ▼                                       ▼
//  ═══════╤═══════════════════════════════════════╤═══════
//         │         🔒 Critical Section           │
//         │  · GC 被抑制或完全暂停                  │
//         │  · 禁止调用大多数 JNI 函数               │
//         │  · 禁止阻塞性系统调用                    │
//         │  · elems 指针保证有效                   │
//  ═══════╧═══════════════════════════════════════╧═══════
//
//  ⚠️ 如果 Critical Section 持续过长 → GC 延迟 → 其他线程可能卡顿

JNIEXPORT void JNICALL
Java_ArrayDemo_processStringArray(JNIEnv *env, jclass clazz, jobjectArray strArr) {
 
    // 1. 获取数组长度
    jsize len = (*env)->GetArrayLength(env, strArr); // 对象数组同样用此函数
 
    for (jsize i = 0; i < len; i++) {
 
        // 2. 获取第 i 个元素（返回 jobject，实际是 jstring）
        jstring str = (jstring)(*env)->GetObjectArrayElement(
            env,      // JNI 环境
            strArr,   // 对象数组
            i         // 索引
        );
        // ⚠️ 返回的是 Local Reference，当前帧结束自动释放
 
        // 3. 将 jstring 转为 C 字符串以便处理
        const char *cStr = (*env)->GetStringUTFChars(env, str, NULL);
        if (cStr == NULL) return; // OOM
 
        printf("Element[%d] = %s\n", i, cStr); // 打印
 
        // 4. 释放 UTF 字符串
        (*env)->ReleaseStringUTFChars(env, str, cStr);
 
        // 5. 及时删除 Local Reference（循环中非常重要！）
        (*env)->DeleteLocalRef(env, str);
        // 不删除的话，循环次数过多会超出 Local Reference 表上限（默认 512）
    }
}

JNIEXPORT jobjectArray JNICALL
Java_ArrayDemo_createStringArray(JNIEnv *env, jclass clazz) {
 
    // 1. 找到 String 类
    jclass strClass = (*env)->FindClass(env, "java/lang/String"); // 类签名
 
    // 2. 创建长度为 3 的 String[] 数组，初始值为 NULL
    jobjectArray result = (*env)->NewObjectArray(
        env,        // JNI 环境
        3,          // 数组长度
        strClass,   // 元素类型（java.lang.String）
        NULL        // 初始值（每个元素初始为 null）
    );
 
    if (result == NULL) return NULL; // OOM
 
    // 3. 逐一填入字符串
    const char *names[] = {"Alice", "Bob", "Charlie"}; // C 字符串数组
    for (int i = 0; i < 3; i++) {
        jstring jStr = (*env)->NewStringUTF(env, names[i]); // 创建 Java String
        (*env)->SetObjectArrayElement(
            env,      // JNI 环境
            result,   // 目标数组
            i,        // 索引
            jStr      // 要设置的元素
        );
        (*env)->DeleteLocalRef(env, jStr); // 释放局部引用
    }
 
    return result; // 返回给 Java 层
}