Matrizes multidimensionais em Java

1. Visão geral

Uma matriz multidimensional em Java é uma matriz que compreende matrizes de tamanhos variados como seus elementos. Também é conhecido como "uma matriz de matrizes" ou "matriz irregular" ou "matriz denteada".

Neste tutorial rápido, veremos mais a fundo como definir e trabalhar com matrizes multidimensionais.

2. Criando uma matriz multidimensional

Vamos começar examinando as maneiras pelas quais podemos criar uma matriz multidimensional:

2.1. A forma abreviada

Uma maneira fácil de definir uma matriz multidimensional seria:

int[][] multiDimensionalArr = {{1, 2}, {3, 4, 5}, {6, 7, 8, 9}};

Aqui, declaramos e inicializamosmultiDimensionalArr em uma única etapa.

2.2. Declaração e Inicialização

Começamos declarando uma matriz multidimensional de tamanho três:

int[][] multiDimensionalArr = new int[3][];

Aqui,we’ve omitted to specify the second dimension since it will vary.

A seguir, vamos prosseguir declarando e inicializando os respectivos elementos emmultiDimensionalArr:

multiDimensionalArr[0] = new int[] {1, 2};
multiDimensionalArr[1] = new int[] {3, 4, 5};
multiDimensionalArr[2] = new int[] {6, 7, 8, 9};

Também podemos simplesmente declarar seus elementos sem inicializá-los:

multiDimensionalArr[0] = new int[2];
multiDimensionalArr[1] = new int[3];
multiDimensionalArr[2] = new int[4];

Eles podem ser inicializados posteriormente, por exemplo, usando entradas do usuário.

Também podemos usar o métodojava.util.Arrays.fill para inicializar os elementos da matriz:

void initialize2DArray(int[][] multiDimensionalArray) {
    for (int[] array : multiDimensionalArray) {
        Arrays.fill(array, 7);
    }
}

Todos os elementos nas matrizes são inicializados com o mesmo valor.

3. Representação de memória

Como será a representação da memória de nossomultiDimensionalArr?

Como sabemos, uma matriz em Java nada mais é que um objeto, cujos elementos podem ser primitivos ou referências. Portanto, uma matriz bidimensional em Java pode ser vista como uma matriz de matrizes unidimensionais.

NossomultiDimensionalArr na memória seria semelhante a:

Claramente,multiDimensionalArr[0] contém uma referência a uma matriz unidimensional de tamanho 2,multiDimensionalArr[1] contém uma referência a outra matriz unidimensional de tamanho 3 e assim por diante.

Dessa maneira, o Java permite definir e usar matrizes multidimensionais.

4. Iterando sobre Elementos

Podemos iterar uma matriz multidimensional como qualquer outra matriz em Java.

Vamos tentar iterar e inicializar os elementosmultiDimensionalArr usando entradas do usuário:

void initializeElements(int[][] multiDimensionalArr) {
    Scanner sc = new Scanner(System.in);
    for (int outer = 0; outer < multiDimensionalArr.length; outer++) {
        for (int inner = 0; inner < multiDimensionalArr[outer].length; inner++) {
            multiDimensionalArr[outer][inner] = sc.nextInt();
        }
    }
}

Aqui,multiDimensionalArr[outer].length é o comprimento de uma matriz em um índiceouter emmultiDimensionalArr.

It helps us to ensure that we are looking for elements only within a valid range of each sub-array, evitando assim umArrayIndexOutOfBoundException.

5. Elementos de impressão

E se quisermos imprimir os elementos da nossa matriz multidimensional?

Uma maneira óbvia seria usar a lógica de iteração que já cobrimos. Isso envolve a iteração através de cada item em nossa matriz multidimensional, que por si só é uma matriz, e a iteração nessa matriz filho - um elemento de cada vez.

Outra opção que temos é usar o método auxiliarjava.util.Arrays.toString():

void printElements(int[][] multiDimensionalArr) {
    for (int index = 0; index < multiDimensionalArr.length; index++) {
        System.out.println(Arrays.toString(multiDimensionalArr[index]));
    }
}

E acabamos tendo um código limpo e simples. A saída do console gerada seria semelhante a:

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

6. Comprimento dos elementos

Podemos encontrar o comprimento das matrizes em uma matriz multidimensional iterando sobre a matriz principal:

int[] findLengthOfElements(int[][] multiDimensionalArray) {
    int[] arrayOfLengths = new int[multiDimensionalArray.length];
    for (int i = 0; i < multiDimensionalArray.length; i++) {
        arrayOfLengths[i] = multiDimensionalArray[i].length;
    }
    return arrayOfLengths;
}

Também podemos encontrar o comprimento de matrizes usando fluxos Java:

Integer[] findLengthOfArrays(int[][] multiDimensionalArray) {
    return Arrays.stream(multiDimensionalArray)
      .map(array -> array.length)
      .toArray(Integer[]::new);
}

7. Copiar uma matriz 2D

Podemos copiar uma matriz 2-D usando o métodoArrays.copyOf:

int[][] copy2DArray(int[][] arrayOfArrays) {
    int[][] copied2DArray = new int[arrayOfArrays.length][];
    for (int i = 0; i < arrayOfArrays.length; i++) {
        int[] array = arrayOfArrays[i];
        copied2DArray[i] = Arrays.copyOf(array, array.length);
    }
    return copied2DArray;
}

Também podemos conseguir isso usando fluxos Java:

Integer[][] copy2DArray(Integer[][] arrayOfArrays) {
    return Arrays.stream(arrayOfArrays)
      .map(array -> Arrays.copyOf(array, array.length))
      .toArray(Integer[][]::new);
}

8. Conclusão

Neste artigo, vimos o que são matrizes multidimensionais, como elas ficam na memória e as maneiras pelas quais podemos defini-las e usá-las.

Como sempre, o código-fonte dos exemplos apresentados pode ser encontradoover on GitHub.

TOC

Matrizes multidimensionais em Java