How do I convert Double[] to double[]?

Question

I'm implementing an interface that has functionality similar to a table that can contain an types of objects. The interface specifies the following function:

double[] getDoubles(int columnIndex);

Where I'm stumped is that in my implementation, I'm storing the table data in a 2D Object array (Object[][] data). When I need to return the values, I want to do the following (it is assumed that getDoubles() will only be called on a column that contains doubles, so there will be no ClassCastExceptions):

double[] getDoubles(int columnIndex) {
    return (double[]) data[columnIndex];
}

But - Java doesn't allow Object[] to be cast to double[]. Casting it to Double[] is ok because Double is an object and not a primitive, but my interface specifies that data will be returned as a double[].

So I have two questions:

1. Is there any way I can get the column data out of the Object[][] table and return the array of primitives?
2. If I do change the interface to return Double[], will there be any performance impact?

Answer 1

Unfortunately you will need to loop through the entire list and unbox the Double if you want to convert it to a double[].

As far as performance goes, there is some time associated with boxing and unboxing primitives in Java. If the set is small enough, you won't see any performance issues.

Answer 2

If you wanted to return a double[], you would need to create a new double[], populate it, and return that.

That may be a good architecture decision. First, it doesn't make a lot of sense to cast an Object[] to a Double[]; it's not really an array of Double because there could be Objects in it too. Second, if you return the array directly, the user code can modify it and alter the internal structure of your object.

The main performance impact would be in returning an array of double[], due to unboxing and the cost of allocation.

Answer 3

You could use a for each loop to construct a temp array of the same size then cast each individual element to double and but it in the array.

SO:

double[] tempArray = new double[data[columnIndex].length];
int i = 0;
for(Double d : (Double) data[columnIndex]) {
  tempArray[i] = (double) d;
  i++;
}

Please correct me if I am dead wrong here.

Answer 4

Your 2D array should just be

Object[] data = new Object[100];

because you don't need to know the type of data stored in the sub arrays.

data[index] = new double[]{0,1};

works. as well as :

double[] getDoubles(int columnIndex) {
    return (double[]) data[columnIndex];
}

Answer 5

If you don't mind using a 3rd party library, commons-lang has the ArrayUtils type with various methods for manipulation.

Double[] doubles;
...
double[] d = ArrayUtils.toPrimitive(doubles);

There is also the complementary method

doubles = ArrayUtils.toObject(d);

Edit: To answer the rest of the question. There will be some overhead to doing this, but unless the array is really big you shouldn't worry about it. Test it first to see if it is a problem before refactoring.

Implementing the method you had actually asked about would give something like this.

double[] getDoubles(int columnIndex) {
    return ArrayUtils.toPrimitive(data[columnIndex]);
}

Answer 6

I would second the ArrayUtils answer and add that the 1.5 autoboxing documentation(via) kinda reveals that there is no builtin way:

There is no permitted conversion from array type SC[] to array type TC[] if there is no permitted conversion other than a string conversion from SC to TC

Answer 7

I don't have anything to add to the real question beyond what jjnguy and Eric Koslow said.

But just a side note: You mention casting an Object array to a Double array. The following will NOT work:

Object[] oa=new Object[3];
oa[0]=new Double("1.0");
oa[1]=new Double("2.0");
oa[2]=new Double("3.0");
Double[] da=(Double[])oa;

The last line will throw a class cast exception. Even though every element in the array is indeed a Double, the array was created as an array of Objects, not an array of Doubles, so the cast is invalid.