¿Cómo convertir una matriz de 1d a una matriz de 2d?

Diga, tengo una matriz de 1d con 30 elementos:

array1d[0] = 1 array1d[1] = 2 array1d[2] = 3 . . . array1[29] = 30 

¿Cómo convertir el 1d array a 2d array?
Digamos 10×3?

 array2d[0][0] = 1 array2d[0][1] =2 array2d[0][2] =3 . . . array2d[9][0] = 28 array2d[9][1] =29 array2d[9][2] =30 

¿Debo usar un bucle for?
Pero no puedo resolverlo.

Sin escribir ningún código para ti …

  • Piense en lo grande que debe ser su matriz 2d.
  • Reconozca que tendrá que recorrer el contenido de su matriz fuente para obtener cada valor en su matriz de destino.

Entonces se verá algo así como …

  • Crea una matriz 2d del tamaño apropiado.
  • Use un bucle for para recorrer su matriz de 1d.
  • Dentro de ese ciclo for, necesitarás averiguar a dónde debe ir cada valor en la matriz 1d en la matriz 2d. Intente usar la función mod contra su variable de contador para “envolver” los índices de la matriz 2d.

Estoy intencionalmente vago, ya que esto es tarea. Intenta publicar un código para que podamos ver dónde te quedas atascado.

 int array2d[][] = new int[10][3]; for(int i=0; i<10;i++) for(int j=0;j<3;j++) array2d[i][j] = array1d[(j*10) + i]; 
 public class Test{ public static void main(String[] argv) { int x,y; for(int num =0; num<81;num++) { if((num % 9)>0) { x = num/9; y = num%9; }else { x = num/9; y = 0; } System.out.println("num ["+num+"]---["+x+","+y+"]"); } } } /* Replace 9 by the size of single row of your 2D array */ 

Aquí una función genérica para convertir de 1D -> matriz 2D:

 public int[][] monoToBidi( final int[] array, final int rows, final int cols ) { if (array.length != (rows*cols)) throw new IllegalArgumentException("Invalid array length"); int[][] bidi = new int[rows][cols]; for ( int i = 0; i < rows; i++ ) System.arraycopy(array, (i*cols), bidi[i], 0, cols); return bidi; } 

Si quieres hacer lo contrario (2D -> 1D), aquí la función:

 public int[] bidiToMono( final int[][] array ) { int rows = array.length, cols = array[0].length; int[] mono = new int[(rows*cols)]; for ( int i = 0; i < rows; i++ ) System.arraycopy(array[i], 0, mono, (i*cols), cols); return mono; } 
 int[] oneDArray = new int[arr.length*arr.length]; //Flatten 2D array to 1D array... int s = 0; for(int i = 0; i < arr.length; i ++) for(int j = 0; j < arr.length; j ++){ oneDArray[s] = arr[i][j]; s++; } 

A menudo encontrará el mismo problema: cómo manipular una matriz 2D como matriz 1D. Escribí una clase genérica Grid, que permite acceder a objetos por índice o por (x, y) .

Vea la siguiente clase y comprenda la idea detrás de esto. 🙂

Puede utilizar la siguiente clase para la manipulación de datos como matriz 2D o matriz 1D. Aquí está el código que escribí y uso.

 /** * Grid represents a 2 dimensional grid. * * @param  the type of elements in this grid */ import java.util.List; import java.util.ArrayList; import java.util.Collections; import java.util.Iterator; public class Grid { private int size ; private int width ; private int height ; private List elements; public int getCapacity() { return getWidth() * getHeight(); } /** * @return number of elements in grid. Null is also an element. */ public int getSize() { return getElements().size(); } /** * @param sideSize size of the grid side */ public Grid(int sideSize) { this(sideSize,sideSize); } /** * @param width of the grid * @param height of the grid */ public Grid(int width, int height) { this.width = width ; this.height = height; this.elements = new ArrayList( Collections.nCopies(width*height, (E)null)); } public int getHeight() { return height; } public int getWidth() { return width; } /** * @return all elements of the grid */ public List getElements() { return elements; } /** * @return iterator for a grid */ public Iterator iterator() { return getElements().iterator(); } /** * Returns the element at position (x,y). * * @return the element at position (x,y) */ public E get(int x, int y) { return getElements().get( idx(x,y)); } /** * Returns the element at index idx. * * @return the element at given index */ public E get(int idx) { return getElements().get(idx); } /** * Puts an element to the position idx * * @param element to be added * * @param x position x to add element to * * @param y position y to add element to */ public void put(int x, int y, E element) { put(idx(x,y), element); } /** * Puts an element to the position idx * * @param element to be added * * @param idx to add element at */ public void put(int idx, E element) { getElements().add(idx, element); } /** * Returns the x coordinate from the index. * * @return x coordinate of the index */ public int x(int idx) { return idx % getHeight(); } /** * Returns the y coordinate from the index. * * @return y coordinate of the index */ public int y(int idx) { return (idx - idx % getHeight()) / getHeight(); } /** * Returns index of element at (x,y). * * @return index of the coordinates */ public int idx(int x, int y) { return y*getHeight() + x; } } 

Aquí se explica cómo usar la clase (ver un ejemplo de prueba):

 public class TestGrid { public static final int SIZE = 10; public static final Integer el1 = new Integer(2); public static final Integer el2 = new Integer(3); public static final Integer el3 = new Integer(3); public static void main(String[] args) { Grid grid = new Grid<>(SIZE); assert grid.getCapacity() == SIZE*SIZE ; assert grid.idx(0,0) == 0 ; assert grid.idx(1,0) == 1 ; assert grid.idx(0,1) == 10; assert grid.idx(6,1) == 16; assert grid.idx(9,9) == 99; grid.put(1, el1); assert grid.get(1) == el1 : grid.get(1); grid.put(0, 1, el2); assert grid.get(0,1) != el1 && el1 != el2 && grid.get(0,1) == el2; grid.put(15, el3); assert grid.get(5,1) == el3; } } 

No puede “convertir” una matriz 1D a una matriz 2D, pero una matriz puede ser multidimensional cuando la declara.

 int myArray2d[][] = new int[10][3]