Programacao Java: Convertendo arrays unidimensionais e bidimensionais

Um array de uma dimensão é basicamente uma seqüência de elementos:

[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]

Já um array bi-dimensional possui, como o próprio nome diz, duas dimensões:

[1, 2, 3],

[4, 5, 6],

[7, 8, 9],

[10, 11, 12]

Note que existem várias maneiras de transformar o array unidimensional em um array bidimensional. Veja algumas representações alternativas do exemplo anterior:

[1, 2],                          [1, 2, 3, 4],                              [1, 2, 3, 4, 5, 6],

[3, 4],                          [5, 6, 7, 8],                              [7, 8, 9, 10, 11, 12]

[5, 6],                          [9, 10, 11, 12]

[7, 8],

[9, 10],

[11, 12]

 Em Java, para declarar o array de uma dimensão no primeiro exemplo, basta fazer o seguinte:

int[] a = new int[]{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12};

Então vamos criar dois métodos, um que converte um array de uma dimensão em outro de duas dimensões, e o contrário, um método que recebe um array de duas dimensões e retorna um array unidimensional.

Esse é um problema bem interessante, e sugiro como um exercício para conhecer melhor o funcionamento de um array em Java. A assinatura das duas funções ficaria assim:

static int[][] dimensionar_uma_em_duas (int[] matriz, int largura)

static int[] dimensionar_duas_em_uma (int[][] matriz)

Note que o método dimensionar_uma_em_duas recebe um parâmetro que indica a largura de uma das dimensões. Isso é necessário para que o array retornado seja corretamente dimensionado. No primeiro exemplo de array com duas dimensões, temos uma matriz 4x3, e os exemplos seguintes representam matrizes 6x2, 3x4 e 2x6, respectivamente.

Lembre-se de implementar o método dimensionar_uma_em_duas declarando um array bidimensional que será o retorno do método, da seguinte forma:

int[][] ret = new int[altura][largura];

Onde “largura” é um dos parâmetros do método, e a “altura” pode ser calculada a partir daí, pois basta saber o tamanho do array, que pode ser obtido pela propriedade length.

Depois basta criar no método main alguns exemplos para testar as implementações.

public static void main(String[] args)

{

            int[] a = new int[]{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12};
            int[][] b1 = dimensionar_uma_em_duas (a, 3);
            int[][] b2 = dimensionar_uma_em_duas (a, 2);
            int[][] b3 = dimensionar_uma_em_duas (a, 4);
            int[][] b4 = dimensionar_uma_em_duas (a, 6);
            int[] c1 = dimensionar_duas_em_uma (b1);
            int[] c2 = dimensionar_duas_em_uma (b2);
            int[] c3 = dimensionar_duas_em_uma (b3);
            int[] c4 = dimensionar_duas_em_uma (b4);      
      }

Note que os arrays “c1”, “c2”, “c3” e “c4” são iguais ao array “a”.

Os métodos completos estão abaixo.
 
      static int [] dimensionar_duas_em_uma (int[][] matriz)

{

            int[] ret = new int[matriz.length * matriz[0].length];
            int pos = 0;
            for(int j=0;j<matriz.length; j++) {
                  for(int i=0;i<matriz[j].length; i++) {
                        ret[pos++] = matriz[j][i];
                  }
            }
            return ret;
      }
     
      static int[][] dimensionar_uma_em_duas (int[] matriz, int largura)

{

            int altura = matriz.length / largura;
            int[][] ret = new int[altura][largura];
            for(int i=0; i<matriz.length; i++) {
                  ret[i/largura][i%largura] = matriz[i];
            }
            return ret;
      }
 
O primeiro método, dimensionar_duas_em_uma, é bem simples. Ele percorre as duas dimensões do array de entrada em ordem e vai adicionando os elementos no novo array.
Já o segundo método, dimensionar_uma_em_duas, obtém a altura do array dividindo o tamanho total dele pela largura, que é um parâmetro de entrada. A partir daí ele percorre o vetor unidimensional de uma vez, utilizando as funções de divisão inteira e módulo para posicionar corretamente os elementos no novo vetor bidimensional. Para um vetor com altura 4 e largura 3, e a entrada do primeiro exemplo, os cálculos (i/largura) e (i%largura) retornarão as posições:

         0, 0; 0,1; 0,2; 1,0; 1,1; 1,2; 2,0; 2,1; 2,2; 3,0; 3,1 e 3,2; respectivamente.