via più breve per lanciare una matrice 2D int in 2d doppia

Question

Ho un metodo che ottiene soltanto double[][] a cui vorrei passare int[][], c'è una breve modo di fare questo in Java, qualcosa di semplice come:

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

Answer 1

Sfortunatamente l'unico modo per trasmettere l'array è iterare attraverso ciascun elemento e lanciarli uno alla volta mentre si reinserisce nel nuovo array double[][].

Nessuna connessione.

Answer 2

Non puoi scriverli, i doppi sono disposti in memoria diversi da quelli di Ints, questo non è il caso di cambiare semplicemente il loro nome.

EDIT: Solo se doppia era un super o sottoclasse classe di int allora potrebbe essere possibile.

Answer 3

No, non è la digitazione corretta. int [] è un tipo e double [] è un tipo e non hanno alcuna relazione, quindi tali assegnazioni non sono consentite. Pertanto, non c'è modo di lanciarlo.

Dovrai copiare gli elementi (puoi assegnare un int a un doppio senza eseguire il casting).

Answer 4

Si può fare in questo modo:

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: come Andreas_D sottolineato, questo funziona solo se tutte le righe sono della stessa lunghezza, se si vuole lunghezza variabile, dovrete attraversare il secondo ciclo per una quantità variabile di colonne.

Answer 5

Hmm, il mio codice scritto in Java 8 è chiamato il collegamento?

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 6

In Java 8 si può lanciare una matrice 1-dimensionale int s in una matrice di double s:

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

ho pertanto scritto quello che ho assunto sarebbe una versione più veloce dal loop sopra la righe:

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(); 
} 

Stavo per pubblicare questa risposta, ma ho pensato di postare alcuni parametri su quanto più veloce è stato che ingenuamente ciclare su ogni elemento. Si scopre che era intorno a 10x più lento! L'ho testato con un array di zeri 10000x1000. Suppongo che sia la creazione di oggetti extra che causa il rallentamento.

A meno che qualcun altro può dimostrare il contrario, penso che la soluzione più semplice è in realtà il più veloce:

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