{"id":629,"date":"2025-09-20T13:22:52","date_gmt":"2025-09-20T12:22:52","guid":{"rendered":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/?p=629"},"modified":"2025-10-01T13:27:23","modified_gmt":"2025-10-01T12:27:23","slug":"nutzung-von-lists-in-jni","status":"publish","type":"post","link":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/?p=629","title":{"rendered":"Nutzung von Lists in JNI"},"content":{"rendered":"\n

Java Native Interface (JNI) ist eine m\u00e4chtige Schnittstelle, die es Java-Anwendungen erm\u00f6glicht, direkt mit nativem Code in C oder C++ zu interagieren. Dies ist besonders n\u00fctzlich, wenn bestimmte Aufgaben effizienter in nativer Sprache umgesetzt werden oder wenn existierende Bibliotheken wiederverwendet werden sollen, die nicht in Java verf\u00fcgbar sind. Ein h\u00e4ufig auftretender Anwendungsfall ist der Umgang mit List-Strukturen aus Java, die in JNI verarbeitet werden sollen. In diesem Artikel betrachten wir die grundlegenden Prinzipien, typische Fallstricke und praktische Beispiele zur Nutzung von Lists in JNI.<\/p>\n\n\n\n

Grundlagen: JNI und Java-Objekte<\/strong><\/h4>\n\n\n\n

JNI erlaubt den Zugriff auf Java-Objekte \u00fcber einen speziellen Zeiger, den sogenannten JNIEnv*. \u00dcber diesen Zeiger k\u00f6nnen native Methoden Java-Objekte erzeugen, Methoden aufrufen oder Felder lesen und schreiben. Dabei ist zu beachten, dass Java-Objekte in JNI als jobject repr\u00e4sentiert werden. F\u00fcr spezielle Typen wie String gibt es dedizierte Typen (jstring), f\u00fcr Arrays (jintArray, jobjectArray) und so weiter.<\/p>\n\n\n\n

Ein List-Objekt in Java ist jedoch ein Interface (java.util.List) und keine native Struktur. Das bedeutet, dass es in JNI nicht direkt manipuliert werden kann wie ein Array. Stattdessen muss man Methoden des Interfaces \u00fcber JNI aufrufen.<\/p>\n\n\n\n

Zugriff auf Java\u00a0<\/strong>List in JNI<\/h4>\n\n\n\n

Angenommen, wir haben eine Java-Methode, die eine List<String> an eine native Methode \u00fcbergibt:<\/p>\n\n\n

public<\/span> class<\/span> ListExample<\/span> <\/span>{\n    public<\/span> native void processList(List<\/span><String> items);\n}<\/code><\/span>Code-Sprache:<\/span> PHP<\/span> (<\/span>php<\/span>)<\/span><\/small><\/pre>\n\n\n
Im C\/C++-Code m\u00fcssen wir zun\u00e4chst die Klassen- und Methodensignaturen abrufen und Methoden wie size() und get(int index) verwenden, um auf die Listenelemente zuzugreifen:<\/p>\n\n\n
#include <jni.h><\/span>\n#include <stdio.h><\/span>\n\nJNIEXPORT void JNICALL Java_ListExample_processList(JNIEnv *env, jobject obj, jobject list<\/span>) {\n    jclass listClass = (*env)->GetObjectClass(env, list<\/span>);\n\n    jmethodID sizeMethod = (*env)->GetMethodID(env, listClass, \"size\"<\/span>, \"()I\"<\/span>);\n    jmethodID getMethod = (*env)->GetMethodID(env, listClass, \"get\"<\/span>, \"(I)Ljava\/lang\/Object;\"<\/span>);\n\n    jint size = (*env)->CallIntMethod(env, list<\/span>, sizeMethod);\n\n    for<\/span> (jint i = 0<\/span>; i < size; i++) {\n        jobject element = (*env)->CallObjectMethod(env, list<\/span>, getMethod, i);\n\n        const<\/span> char *str = (*env)->GetStringUTFChars(env, (jstring)element, NULL<\/span>);\n        printf(\"Element %d: %s\\n\"<\/span>, i, str);\n        (*env)->ReleaseStringUTFChars(env, (jstring)element, str);\n        (*env)->DeleteLocalRef(env, element);\n    }\n\n    (*env)->DeleteLocalRef(env, listClass);\n}<\/code><\/span>Code-Sprache:<\/span> PHP<\/span> (<\/span>php<\/span>)<\/span><\/small><\/pre>\n\n\n
Hier sind einige zentrale Punkte zu beachten:<\/p>\n\n\n\n
    \n
  1. Klassen- und Methodenermittlung<\/strong>: Jede Methode des List-Interfaces muss \u00fcber GetMethodID gefunden werden.<\/li>\n\n\n\n
  2. Methodenaufrufe<\/strong>: CallObjectMethod und CallIntMethod dienen zum Aufruf von Methoden und zum Abrufen von R\u00fcckgabewerten.<\/li>\n\n\n\n
  3. Speicherverwaltung<\/strong>: Lokale Referenzen wie element sollten mit DeleteLocalRef freigegeben werden, um Speicherlecks zu vermeiden.<\/li>\n\n\n\n
  4. String-Konvertierung<\/strong>: Java-Strings m\u00fcssen mit GetStringUTFChars in C-kompatible Strings konvertiert werden und anschlie\u00dfend wieder freigegeben werden.<\/li>\n<\/ol>\n\n\n\n
    Listen in JNI erstellen<\/strong><\/h4>\n\n\n\n
    Nicht nur der Zugriff, sondern auch das Erstellen einer neuen List in JNI ist m\u00f6glich. In der Regel erzeugt man ein ArrayList-Objekt und f\u00fcgt Elemente \u00fcber add hinzu:<\/p>\n\n\n
    JNIEXPORT jobject JNICALL Java_ListExample_createList(JNIEnv *env, jobject obj) {\n    jclass arrayListClass = (*env)->FindClass(env, \"java\/util\/ArrayList\"<\/span>);\n    jmethodID constructor = (*env)->GetMethodID(env, arrayListClass, \"<init>\"<\/span>, \"()V\"<\/span>);\n    jobject arrayList = (*env)->NewObject(env, arrayListClass, constructor);\n\n    jmethodID addMethod = (*env)->GetMethodID(env, arrayListClass, \"add\"<\/span>, \"(Ljava\/lang\/Object;)Z\"<\/span>);\n\n    jstring str1 = (*env)->NewStringUTF(env, \"Hallo\"<\/span>);\n    jstring str2 = (*env)->NewStringUTF(env, \"JNI\"<\/span>);\n\n    (*env)->CallBooleanMethod(env, arrayList, addMethod, str1);\n    (*env)->CallBooleanMethod(env, arrayList, addMethod, str2);\n\n    (*env)->DeleteLocalRef(env, str1);\n    (*env)->DeleteLocalRef(env, str2);\n    (*env)->DeleteLocalRef(env, arrayListClass);\n\n    return<\/span> arrayList;\n}<\/code><\/span>Code-Sprache:<\/span> PHP<\/span> (<\/span>php<\/span>)<\/span><\/small><\/pre>\n\n\n
    Dieser Code zeigt, wie man eine Java-ArrayList in C erstellt, Elemente hinzuf\u00fcgt und sie an Java zur\u00fcckgibt.<\/p>\n\n\n\n
    Typische Fallstricke<\/strong><\/h4>\n\n\n\n
      \n
    1. JNI-Referenzen<\/strong>: JNI unterscheidet zwischen lokalen und globalen Referenzen. Lokale Referenzen existieren nur w\u00e4hrend des Aufrufs und m\u00fcssen bei gro\u00dfen Schleifen explizit gel\u00f6scht werden.<\/li>\n\n\n\n
    2. Typensicherheit<\/strong>: List-Elemente sind Object. Ein falscher Cast kann zu Laufzeitfehlern f\u00fchren.<\/li>\n\n\n\n
    3. Performance<\/strong>: H\u00e4ufiges Aufrufen von get(i) kann ineffizient sein. F\u00fcr gro\u00dfe Listen empfiehlt sich das Zwischenspeichern in einem Array oder die \u00dcbergabe als jobjectArray.<\/li>\n\n\n\n
    4. Exception Handling<\/strong>: JNI-Methoden l\u00f6sen Java-Ausnahmen aus, die in C gepr\u00fcft werden m\u00fcssen. Ohne Pr\u00fcfung kann ein Fehler \u00fcbersehen werden.<\/li>\n\n\n\n
    5. <\/li>\n<\/ol>\n\n\n\n
      \n\n\n\n
      Verschachtelte Listen (List<List<String>><\/strong>)<\/h4>\n\n\n\n
      In vielen Anwendungen ist es n\u00f6tig, Listen von Listen zu verarbeiten, z.\u202fB. eine Tabelle als List<List<String>>. In JNI werden solche Strukturen als List von List-Objekten dargestellt. Der Zugriff erfolgt rekursiv: Zuerst wird die \u00e4u\u00dfere Liste durchlaufen, dann die innere.<\/p>\n\n\n\n
      Beispiel:<\/p>\n\n\n
      JNIEXPORT void JNICALL Java_ListExample_processNestedList(JNIEnv *env, jobject obj, jobject nestedList) {\n    jclass listClass = (*env)->GetObjectClass(env, nestedList);\n    jmethodID sizeMethod = (*env)->GetMethodID(env, listClass, \"size\"<\/span>, \"()I\"<\/span>);\n    jmethodID getMethod = (*env)->GetMethodID(env, listClass, \"get\"<\/span>, \"(I)Ljava\/lang\/Object;\"<\/span>);\n\n    jint outerSize = (*env)->CallIntMethod(env, nestedList, sizeMethod);\n\n    for<\/span> (jint i = 0<\/span>; i < outerSize; i++) {\n        jobject innerList = (*env)->CallObjectMethod(env, nestedList, getMethod, i);\n        jclass innerListClass = (*env)->GetObjectClass(env, innerList);\n\n        jint innerSize = (*env)->CallIntMethod(env, innerList, sizeMethod);\n        for<\/span> (jint j = 0<\/span>; j < innerSize; j++) {\n            jobject element = (*env)->CallObjectMethod(env, innerList, getMethod, j);\n            const<\/span> char *str = (*env)->GetStringUTFChars(env, (jstring)element, NULL<\/span>);\n            printf(\"Element [%d][%d]: %s\\n\"<\/span>, i, j, str);\n            (*env)->ReleaseStringUTFChars(env, (jstring)element, str);\n            (*env)->DeleteLocalRef(env, element);\n        }\n\n        (*env)->DeleteLocalRef(env, innerListClass);\n        (*env)->DeleteLocalRef(env, innerList);\n    }\n\n    (*env)->DeleteLocalRef(env, listClass);\n}<\/code><\/span>Code-Sprache:<\/span> PHP<\/span> (<\/span>php<\/span>)<\/span><\/small><\/pre>\n\n\n
      Hinweise:<\/strong><\/p>\n\n\n\n
        \n
      • Jede innere Liste wird wie ein separates List-Objekt behandelt.<\/li>\n\n\n\n
      • Lokale Referenzen f\u00fcr innere Listen und deren Elemente m\u00fcssen gel\u00f6scht werden.<\/li>\n\n\n\n
      • Bei gro\u00dfen Datenmengen kann dies viele JNI-Methodenaufrufe erzeugen und die Performance belasten.<\/li>\n<\/ul>\n\n\n\n
        \n\n\n\n
        Performance-Optimierungen<\/strong><\/h4>\n\n\n\n
        Der Zugriff auf List-Elemente \u00fcber get(i) kann bei gro\u00dfen Listen ineffizient sein, da jedes get einen Methodenaufruf \u00fcber JNI bedeutet. Einige Optimierungen:<\/p>\n\n\n\n
          \n
        1. Konvertierung in Arrays<\/strong> Vor dem Aufruf in JNI kann die Liste in ein Object[] umgewandelt werden (toArray()), um die Anzahl der JNI-Aufrufe zu reduzieren:<\/li>\n<\/ol>\n\n\n
          List<\/span><String> list<\/span> = ...;\nString[] array<\/span> = list<\/span>.toArray(new<\/span> String[0<\/span>]);\nprocessArray(array<\/span>);<\/code><\/span>Code-Sprache:<\/span> PHP<\/span> (<\/span>php<\/span>)<\/span><\/small><\/pre>\n\n\n
            \n
          1. Im JNI-Code kann dann direkt auf das Array zugegriffen werden:<\/li>\n<\/ol>\n\n\n
            jobjectArray array<\/span> = ...;\njsize length = (*env)->GetArrayLength(env, array<\/span>);\nfor<\/span> (jsize i = 0<\/span>; i < length; i++) {\n    jstring element = (jstring)(*env)->GetObjectArrayElement(env, array<\/span>, i);\n    \/\/ ...<\/span>\n    (*env)->DeleteLocalRef(env, element);\n}<\/code><\/span>Code-Sprache:<\/span> PHP<\/span> (<\/span>php<\/span>)<\/span><\/small><\/pre>\n\n\n
              \n
            1. Minimierung von DeleteLocalRef-Aufrufen<\/strong> Bei sehr gro\u00dfen Listen kann es sinnvoll sein, Referenzen nur periodisch zu l\u00f6schen (z.\u202fB. nach jedem 1000. Element), um die JNI-Limitierung f\u00fcr lokale Referenzen zu umgehen.<\/li>\n\n\n\n
            2. Globale Referenzen f\u00fcr wiederverwendete Objekte<\/strong> Objekte, die mehrfach in JNI ben\u00f6tigt werden, k\u00f6nnen als globale Referenzen erstellt werden (NewGlobalRef) und am Ende freigegeben werden (DeleteGlobalRef), um wiederholte lokale Referenzen zu vermeiden.<\/li>\n\n\n\n
            3. Batch-Verarbeitung<\/strong> Statt jede Liste einzeln zu verarbeiten, kann die native Methode mehrere Listen auf einmal empfangen oder gro\u00dfe Datenbl\u00f6cke in einem Array aggregieren.<\/li>\n<\/ol>\n\n\n\n
              \n\n\n\n
              Erstellung verschachtelter Listen in JNI<\/strong><\/h4>\n\n\n\n
              Man kann auch verschachtelte Listen in JNI erzeugen. Beispiel: List<List<String>>:<\/p>\n\n\n
              jclass arrayListClass = (*env)->FindClass(env, \"java\/util\/ArrayList\"<\/span>);\njmethodID constructor = (*env)->GetMethodID(env, arrayListClass, \"<init>\"<\/span>, \"()V\"<\/span>);\njmethodID addMethod = (*env)->GetMethodID(env, arrayListClass, \"add\"<\/span>, \"(Ljava\/lang\/Object;)Z\"<\/span>);\n\njobject outerList = (*env)->NewObject(env, arrayListClass, constructor);\n\nfor<\/span> (int i = 0<\/span>; i < 3<\/span>; i++) {\n    jobject innerList = (*env)->NewObject(env, arrayListClass, constructor);\n    for<\/span> (int j = 0<\/span>; j < 2<\/span>; j++) {\n        char buffer[32<\/span>];\n        sprintf(buffer, \"Item %d-%d\"<\/span>, i, j);\n        jstring str = (*env)->NewStringUTF(env, buffer);\n        (*env)->CallBooleanMethod(env, innerList, addMethod, str);\n        (*env)->DeleteLocalRef(env, str);\n    }\n    (*env)->CallBooleanMethod(env, outerList, addMethod, innerList);\n    (*env)->DeleteLocalRef(env, innerList);\n}\n\n(*env)->DeleteLocalRef(env, arrayListClass);\nreturn<\/span> outerList;<\/code><\/span>Code-Sprache:<\/span> PHP<\/span> (<\/span>php<\/span>)<\/span><\/small><\/pre>\n\n\n
              Dies erzeugt eine \u00e4u\u00dfere ArrayList, die mehrere innere Listen enth\u00e4lt, jede wiederum gef\u00fcllt mit Strings.<\/p>\n\n\n\n
              Fazit<\/strong><\/h4>\n\n\n\n
              Die Arbeit mit Lists in JNI erfordert ein Verst\u00e4ndnis der Java-Objektmanipulation aus nativer Sicht. W\u00e4hrend der Zugriff auf Listenmethoden wie size() und get() recht direkt ist, erfordert die Speicherverwaltung, Typkonvertierung und Ausnahmebehandlung besondere Sorgfalt. Das Erstellen und Zur\u00fcckgeben von Listen zeigt die Flexibilit\u00e4t von JNI, erlaubt aber gleichzeitig tiefen Einblick in die Mechanismen von Java-Objekten. Wer diese Prinzipien beherrscht, kann die volle Leistungsf\u00e4higkeit nativer Bibliotheken nutzen, ohne auf die Vorteile von Java-Datenstrukturen verzichten zu m\u00fcssen.<\/p>\n\n\n\n
              <\/p>\n","protected":false},"excerpt":{"rendered":"
              Java Native Interface (JNI) ist eine m\u00e4chtige Schnittstelle, die es Java-Anwendungen erm\u00f6glicht, direkt mit nativem Code in C oder C++ zu interagieren. Dies ist besonders n\u00fctzlich, wenn bestimmte Aufgaben effizienter in nativer Sprache umgesetzt werden oder wenn existierende Bibliotheken wiederverwendet werden sollen, die nicht in Java verf\u00fcgbar sind. Ein h\u00e4ufig auftretender Anwendungsfall ist der Umgang […]<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[4],"tags":[],"class_list":["post-629","post","type-post","status-publish","format-standard","hentry","category-plain_java"],"_links":{"self":[{"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=\/wp\/v2\/posts\/629","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=%2Fwp%2Fv2%2Fcomments&post=629"}],"version-history":[{"count":1,"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=\/wp\/v2\/posts\/629\/revisions"}],"predecessor-version":[{"id":630,"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=\/wp\/v2\/posts\/629\/revisions\/630"}],"wp:attachment":[{"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=%2Fwp%2Fv2%2Fmedia&parent=629"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=%2Fwp%2Fv2%2Fcategories&post=629"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=%2Fwp%2Fv2%2Ftags&post=629"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}