## With Safari, you learn the way you learn best. Get unlimited access to videos, live online training, learning paths, books, tutorials, and more.

No credit card required

# 1.10. Transforming Between Object Arraysand Primitive Arrays

## Problem

You need a way to convert an object array to a primitive array.

## Solution

Use `ArrayUtils.toObject()` and `ArrayUtils.toPrimitive()` to translate between primitive arrays and object arrays. The following example demonstrates the translation from a primitive array to an object array and vice versa:

```import org.apache.commons.lang.ArrayUtils;

long[] primitiveArray = new long[] { 12, 100, 2929, 3323 };
Long[] objectArray = ArrayUtils.toObject( primitiveArray );

Double[] doubleObjects = new Double[] { new Double( 3.22, 5.222, 3.221 ) };
double[] doublePrimitives = ArrayUtils.toPrimitive( doubleObject );```

The result from both translations is an array of equal length and equal contents. The first translation takes a `long[]` and translates the array to a `Long[]`, and the second translation takes a `Double[]` and turns it into a `double[]`.

## Discussion

Assume that the following example uses an external library that expects a list of `Double` objects. The existing system uses an array of double primitives, and you need to “step up” from a primitive array to an object array in order to pass a parameter to the `complexCalculation()` method:

```// Assume that temps is a 4000 element double[]

// Turn the double[] into an array of Double objects
Double[] objectArray = ArrayUtils.toObject( temps );

List inputList = Arrays.asList( objectArray );

// Assume that some process returns results as a List of Double
// objects
List outputList = externalLib.complexCalculation( inputList );

// Transform this List of doubles to an array of double primitives
Double[] resultObjArray =
(Double[]) outputList.toArray( new Double[0] );

double[] result =
ArrayUtils.toPrimitive( resultObjArray, Double.NaN  );```

The primitive array, `temps`, is transformed to an object array using `ArrayUtils.toObject( )`, and the results of our calculation are translated from a list to an array of primitives using `ArrayUtils.toPrimitive( )`. While an object array can contain a `null` element, a primitive array cannot; the second argument to `ArrayUtils.toPrimitive( )` specifies a double value to be used if there is a `null` in the object array. In this example, `null` values in the object array are stored as `Double.NaN` in our primitive array. The second argument to `ArrayUtils.toPrimitive( )` is optional; if it is not present and a `null` value is present in the object array, a `NullPointerException` is thrown.

`ArrayUtils` offers various static methods to transform between primitive and object arrays. Tables Table 1-2 and Table 1-3 summarize both the `toObject( )` and `toPrimitive()` methods.

Table 1-2. The various flavors of ArrayUtils.toObject( )

Return type

Method signature

`Boolean[]`

`ArrayUtils.toObject( boolean[] array )`

`Byte[]`

`ArrayUtils.toObject( byte[] array )`

`Double[]`

`ArrayUtils.toObject( double[] array )`

`Float[]`

`ArrayUtils.toObject( float[] array )`

`Integer[]`

`ArrayUtils.toObject( int[] array )`

`Short[]`

`ArrayUtils.toObject( short[] array )`

`Long[]`

`ArrayUtils.toObject( long[] array )`

Table 1-3. The various flavors of ArrayUtils.toPrimitive( )

Return type

Method signature

`Boolean[]`

`ArrayUtils.toPrimitive( boolean[] array )`

`Byte[]`

`ArrayUtils.toPrimitive( byte[] array )`

`Double[]`

`ArrayUtils.toPrimitive( double[] array )`

`Float[]`

`ArrayUtils.toPrimitive( float[] array )`

`Integer[]`

`ArrayUtils.toPrimitive( integer[] array )`

`Short[]`

`ArrayUtils.toPrimitive( short[] array )`

`Long[]`

`ArrayUtils.toPrimitive( long[] array )`