Diferencia entre array multidimensional en C++ y Java

Requisitos previos: array multidimensional en C++ , array multidimensional en Java

Arrays multidimensionales :

Las arrays multidimensionales son una representación tabular de arrays para almacenar varios elementos. Estas dimensiones pueden ser arreglos 1D , arreglos 2D , etc. Los arreglos multidimensionales están disponibles tanto en C++ como en Java , pero su implementación y algunas propiedades son diferentes.

Implementación en C/C++ :

En C++, una array multidimensional se crea internamente como una array lineal gigante. La sintaxis de C++ abstrae este bloque lineal de memoria en un comportamiento de 2 o 3 dimensiones, lo que facilita al programador.

Ejemplos:

Una array 2D de dimensiones 2 filas x 3 columnas {{9, 45, 51}, {5, 25, 6}} se implementa de la siguiente manera (suponiendo que Integer ocupa 4 bytes):

Por lo tanto, la fórmula interna para el elemento interno en un índice particular se da como:

arr[índicefila][índicecol] = arr + (índicefila * noOfCols * sizeOfDataType) + coLIndex * sizeOfDataType

Supongamos que la dirección base es 3000 . Entonces arr[1][1] = 3000 + (1 * 3 * 4) + 1 * 4 = 3000 + 12 + 4 = 3016 .

Debido a tal implementación, el número de columnas debe ser igual para cada fila, y es obligatorio especificar el tamaño de columna durante la declaración para acceder a los elementos correctamente.

A continuación se muestra la implementación de la array multidimensional en C++:

// C++ program for multidimension array
// implementation
#include <iostream>
using namespace std;
 
// Driver Code
int main()
{
    // Create a 2d integer array,
    // dimensions: 3rows X 5cols
    int arr[3][5] = {
        { 23, 56, 34, 52, 63 },
        { 40, 20, 96, 43, 97 },
        { 75, 51, 10, 82, 43 }
    };
 
    // Traversing of 2D array
    cout << "Printing entire 2d array: "
         << endl;
 
    // Iterate over the rows
    for (int i = 0; i < 3; i++) {
 
        // Iterate over the cols
        for (int j = 0; j < 5; j++) {
 
            cout << "arr[" << i << "][" << j
                 << "]:" << arr[i][j]
                 << "      ";
        }
        cout << endl;
    }
 
    return 0;
}

Printing entire 2d array: 
arr[0][0]:23      arr[0][1]:56      arr[0][2]:34      arr[0][3]:52      arr[0][4]:63      
arr[1][0]:40      arr[1][1]:20      arr[1][2]:96      arr[1][3]:43      arr[1][4]:97      
arr[2][0]:75      arr[2][1]:51      arr[2][2]:10      arr[2][3]:82      arr[2][4]:43

 Implementación en Java:

En Java, una array multidimensional se implementa como una array de arrays donde cada índice de la array base se refiere a una array completamente diferente. Entonces, arr[rowIndex] devuelve una array unidimensional completa y arr[rowIndex][coLIndex] devuelve el elemento en el índice coLIndex en esa array unidimensional.

Ejemplos:

Una array 2D de dimensiones 3 filas x 5 columnas se implementa de la siguiente manera:

Debido a esta estructura, es posible tener arrays 2D con diferentes tamaños de columna (incluso valores nulos) en Java.

A continuación se muestra la implementación de la array multidimensional en Java: 

// Java program for multidimensional
// array implementation
import java.io.*;
 
class GFG {
 
    // Driver Code
    public static void main(String[] args)
    {
 
        // Create a 2D integer array
        // dimensions: 3rows X 5cols
        int[][] arr = {
            { 23, 56, 34, 52, 63 },
            { 40, 20, 96, 43, 97 },
            { 75, 51, 10, 82, 43 }
        };
 
        // Traversing the 2D array
        System.out.println("Printing entire 2d array: ");
 
        // Iterate over the rows
        for (int i = 0;
             i < arr.length; i++) {
 
            // Iterate over the cols
            for (int j = 0;
                 j < arr[i].length; j++) {
                System.out.print(
                    "arr[" + i + "][" + j
                    + "]:" + arr[i][j]
                    + "    ");
            }
            System.out.println();
        }
        System.out.println();
 
        // Reassigning arr[2] to another
        // array
 
        // This is not possible in 2D
        // arrays in C++, instead of
        // there is array of pointers
        arr[2] = new int[] { 82, 53, 64,
                             12, 45, 3 };
 
        // Traversing the array again
        System.out.println(
            "Printing entire 2d array "
            + "after modification: ");
 
        // Iterate over the rows
        for (int i = 0;
             i < arr.length; i++) {
 
            // Iterate over the cols
            for (int j = 0;
                 j < arr[i].length; j++) {
 
                System.out.print(
                    "arr[" + i + "][" + j
                    + "]:" + arr[i][j]
                    + "    ");
            }
            System.out.println();
        }
    }
}

Printing entire 2d array: 
arr[0][0]:23    arr[0][1]:56    arr[0][2]:34    arr[0][3]:52    arr[0][4]:63    
arr[1][0]:40    arr[1][1]:20    arr[1][2]:96    arr[1][3]:43    arr[1][4]:97    
arr[2][0]:75    arr[2][1]:51    arr[2][2]:10    arr[2][3]:82    arr[2][4]:43    

Printing entire 2d array after modification: 
arr[0][0]:23    arr[0][1]:56    arr[0][2]:34    arr[0][3]:52    arr[0][4]:63    
arr[1][0]:40    arr[1][1]:20    arr[1][2]:96    arr[1][3]:43    arr[1][4]:97    
arr[2][0]:82    arr[2][1]:53    arr[2][2]:64    arr[2][3]:12    arr[2][4]:45    arr[2][5]:3