JNI Part 5: JNI Arrays

Editorial Team — Mon, 22 Aug 2011 04:48:41 +0000

Arrays have dimension. An array’s dimension determines the number of indexes needed to access an element.
The standard convention for declaring arrays is:
- String[] s; // one-dimensional array
- String s[]; // one-dimensional array
- String[][] s; // two-dimensional array
Declaring the size of the array with the following notation is illegal:
- String[5] s; // illegal declaration
An array implicitly extends java.lang.Object. Therefore, an array is an instance of Object class. Hence, arrays in Java are objects.
Declaring an array does not create an array object or allocate space in memory; it creates a variable with a reference to an array.
Since arrays are Objects they can be initialized using the new operator.
When created, arrays are automatically initialized with the default value of their type.
- String[] s = new String[100]; // default values: null
- boolean[] b = new boolean[4]; // default values: false
- int[][] i = new int[10][10]; // default values: 0
The JNI treats primitive arrays and object arrays differently.
Primitive arrays contain elements that are of primitive types such as int and boolean.
Object arrays contain elements that are of reference types such as class instances and other arrays.
- int[] iarr;
- float[] farr;
- Object[] oarr;
- int[][] arr2;
Accessing primitive arrays in a native method requires the use of JNI functions similar to those used for accessing strings.
The JNI Get
ArrayRegion function copies all the elements in the JNI array into a C buffer of an appropriate type. The second argument is the starting index of the elements, and the third argument is the number of elements to be copied. Once the elements are in the C buffer, we can access them in native code.
- Example: env->GetCharArrayRegion(arr, 0, arrLength, chArrRWB);
The JNI also supports a corresponding SetArrayRegion function that allows native code to modify the array elements. Arrays of all the primitive types (such as boolean, short, and float) are also supported.
The JNI supports a family of Get/ReleaseArrayElements functions (for example, Get/ReleaseIntArrayElements) that allow the native code to obtain a direct pointer to the elements of primitive arrays.
The GetArrayLength function returns the number of elements in primitive or object arrays.

Example: Accessing intarray

JNIExport jint JNICALL Java_IntArray_sumArray(JNIEnv *env, jobject obj,
	jintArray arr){
		jsize len = *env->GetArrayLength(env,arr);
		jint *body = *env->GetIntArrayElements(env,arr,0);
		for (jint i = 0; i < len; ++i){
			sum += body[i];
		}
	*env->ReleastIntArrayElements(env, arr, body, 0);
}

JNI Function	Description
GetArrayRegion SetArrayRegion	Copies the contents of primitive arrays to or from a pre-allocated C buffer.
GetArrayElements ReleaseArrayElements	Obtains a pointer to the contents of a primitive array. May return a copy of the array.
GetArrayLength	Returns the number of elements in the array.
NewArray	Creates an array with the given length.
GetPrimitiveArrayCritical ReleasePrimitiveArrayCritical	Obtains or releases a pointer to the contents of a primitive array. These functions allow virtual machines to disable garbage collection while the native code accesses the contents of primitive arrays.

JNI Array Example program

Let’s write a JNI application that passes an unsorted integer array to a native method, which method sorts and sends it back to the application.

The Java code will be(SortArray.java):

class SortArray {
	private native int[] sort(int[] arr);  //native method 

	static   //static initializer code
	{
		System.loadLibrary("SortArray");
	} 

	public static void main(String[] args)
	{
		int iArr[] = {4,5,2,7,1,9}; // Input array
		int oArr[]; //Output array

		SortArray arr = new SortArray();

		System.out.println("Unsorted array: ");
		for(int i = 0; i < iArr.length; i++){
			System.out.println(iArr[i] + " ");
		}

		oArr = arr.sort(iArr);

		System.out.println("Sorted array: ");
		for(int i = 0; i < oArr.length; i++){
			System.out.println(oArr[i] + " ");
		}
	}
}

Compile SortArray.java (javac SortArray.java) and generate hedder file(javah -jni SortArray).

The generated with javah header file SortArray.h will be:

/* DO NOT EDIT THIS FILE - it is machine generated */
#include
/* Header for class SortArray */

#ifndef _Included_SortArray
#define _Included_SortArray
#ifdef __cplusplus
extern "C" {
#endif
/*
 * Class:     SortArray
 * Method:    sort
 * Signature: ([I)[I
 */
JNIEXPORT jintArray JNICALL Java_SortArray_sort
  (JNIEnv *, jobject, jintArray);

#ifdef __cplusplus
}
#endif
#endif

The C++ implementation file SortArray.cpp will be:

#include "SortArray.h"
#include "jni.h"

/*
 * Class:     SortArray
 * Method:    sort
 * Signature: ([I)[I
 */
JNIEXPORT jintArray JNICALL Java_SortArray_sort
    (JNIEnv *env, jobject obj, jintArray arr){

    jsize arrLength = env->GetArrayLength(arr);
    jintArray arrSorted = env->NewIntArray(arrLength); 

    jint *arrOut = NULL;
    arrOut = env->GetIntArrayElements(arr, 0);

    for(jsize x = 0; x < arrLength; x++){
        for(jsize y = 0; y < arrLength - 1; y++){
                        if(arrOut[y] > arrOut[y+1]){
				jsize temp = arrOut[y+1];
				arrOut[y+1] = arrOut[y];
				arrOut[y] = temp;
			}
		}
	}

    env->SetIntArrayRegion(arrSorted, 0, arrLength, arrOut);
    env->ReleaseIntArrayElements(arr, arrOut, 0);

    return arrSorted;
}

Run the program (java SortArray) and verify the output.

The post JNI Part 5: JNI Arrays first appeared on Student Projects.

SetIntArrayRegion | Student Projects

JNI Part 5: JNI Arrays