将2d int数组转换为2d double的最短方法

Question

I have a method which only gets double[][] to which I would like to pass int[][] , is there a short way of doing this in java, something as simple as:

int [][] iArray = {
          { 1, 2, },
          { 5, 6, }
        };
double [][] dArray = (double[][]) iArray ; ???

Answer 1

Unfortunately the only way to cast your array is to iterate through each element and cast them one by one while re-inserting in your new double[][] array.

There is no shortcut.

Answer 2

No, that is not correct typing. int[] is a type and double[] is a type and they have no relation, so such assignments are not allowed. Therefore, there is no way to cast this.

You will have to copy the elements (you can assign an int to a double without casting).

Answer 3

Hmm, is my code written in Java 8 worth being called the shortcut ?

import java.util.Arrays;

// ...

/// Cast!
int[][] int2DArray = {{3, 1}, {3, 3, 7}, {}};
Object[] arrayOfUntypedArraies = Arrays.stream(int2DArray).map(intArray -> Arrays.stream(intArray).asDoubleStream().toArray()).toArray();
double[][] double2DArray = Arrays.copyOf(arrayOfUntypedArraies, arrayOfUntypedArraies.length, double[][].class);

/// Print!
System.out.println(Arrays.deepToString(int2DArray));
// [[1, 2], [5, 6, 7], []]
System.out.println(Arrays.deepToString(double2DArray));
// [[1.0, 2.0], [5.0, 6.0, 7.0], []]

Answer 4

In Java 8 you can cast a 1-dimensional array of int s into an array of double s :

double[] singleDimensionDoubleArray = 
        Arrays.stream(singleDimensionIntArray).asDoubleStream().toArray()

I therefore wrote what I assumed would be a faster version by looping over the rows:

int[][] iArray = {
    {1, 2,},
    {5, 6,}
};

double[][] dArray = new double[iArray.length][];
for (int row = 0; row < iArray.length; row++) {
    dArray[row] = Arrays.stream(iArray[row]).asDoubleStream().toArray();
}

I was just about to post this answer but thought I'd post some metrics about how much faster it was that naively looping over every element. It turns out it was around 10x slower ! I tested it with a 10000x1000 array of zeroes. I suppose it's the extra object creation that causes the slowdown.

Unless someone else can prove otherwise, I think the simplest solution is actually the fastest:

for (int row = 0; row < iArray.length; row++) {
    for (int column = 0; column < iArray[0].length; column++) {
        dArray[row][column] = (double) iArray[row][column];
    }
}

Answer 5

You can't cast them, doubles are laid out different in memory than ints, this isn't a case of simply changing their name.

EDIT: Only if double was a super or subclass class of int then it might be possible.

Answer 6

You can do it like this:

    int[][] intarray = {{1, 2}, {5, 6}};

    double[][] doublearray = new double[intarray.length][intarray[0].length];

    for(int i = 0; i < intarray.length; i++)
    {
        for(int j = 0; j < intarray[0].length; j++)
            doublearray[i][j] = (double) intarray[i][j];
    }

Edit: as Andreas_D pointed out, this only works if all rows are of the same lenght, if you want variable lenght, you'll have to traverse the second for loop for a variable amount of columns.