Sintaks untuk membuat array dua dimensi

Mempertimbangkan:

int[][] multD = new int[5][];
multD[0] = new int[10];

Apakah ini cara Anda membuat array dua dimensi dengan 5 baris dan 10 kolom?

Saya melihat kode ini online, tetapi sintaksinya tidak masuk akal.

Coba yang berikut ini:

int[][] multi = new int[5][10];

... yang merupakan kependekan dari sesuatu seperti ini:

int[][] multi = new int[5][];
multi[0] = new int[10];
multi[1] = new int[10];
multi[2] = new int[10];
multi[3] = new int[10];
multi[4] = new int[10];

Perhatikan bahwa setiap elemen akan diinisialisasi dengan nilai default untuk int, 0sehingga di atas adalah juga setara dengan:

int[][] multi = new int[][]{
  { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
  { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
  { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
  { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
  { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }
};

Kita dapat mendeklarasikan array dua dimensi dan langsung menyimpan elemen pada saat deklarasi sebagai:

int marks[][]={{50,60,55,67,70},{62,65,70,70,81},{72,66,77,80,69}};

Di sini int mewakili elemen tipe integer yang disimpan ke dalam array dan nama array adalah 'tanda'. int adalah tipe data untuk semua elemen yang direpresentasikan di dalam kurung "{" dan "}" karena array adalah kumpulan elemen yang memiliki tipe data yang sama.

Kembali ke pernyataan kami yang tertulis di atas: setiap baris elemen harus ditulis di dalam kurung kurawal. Baris dan elemen di setiap baris harus dipisahkan oleh koma.

Sekarang perhatikan pernyataan: Anda bisa mendapatkan ada 3 baris dan 5 kolom, sehingga JVM menciptakan 3 * 5 = 15 blok memori. Blok-blok ini dapat secara individual disebut sebagai:

marks[0][0]  marks[0][1]  marks[0][2]  marks[0][3]  marks[0][4]
marks[1][0]  marks[1][1]  marks[1][2]  marks[1][3]  marks[1][4]
marks[2][0]  marks[2][1]  marks[2][2]  marks[2][3]  marks[2][4]

CATATAN:
Jika Anda ingin menyimpan n elemen maka indeks array dimulai dari nol dan berakhir pada n-1 . Cara lain untuk membuat array dua dimensi adalah dengan mendeklarasikan array terlebih dahulu dan kemudian mengalokasikan memori untuknya dengan menggunakan operator baru.

int marks[][];           // declare marks array
marks = new int[3][5];   // allocate memory for storing 15 elements

Dengan menggabungkan dua di atas kita dapat menulis:

int marks[][] = new int[3][5];

Anda dapat membuatnya seperti yang orang lain katakan. Satu hal lagi untuk ditambahkan: Anda bahkan dapat membuat array dua dimensi yang miring pada setiap baris, tidak harus memiliki jumlah kolom yang sama, seperti ini:

int array[][] = new int[3][];
array[0] = new int[3];
array[1] = new int[2];
array[2] = new int[5];

Idiom paling umum untuk membuat array dua dimensi dengan 5 baris dan 10 kolom adalah:

int[][] multD = new int[5][10];

_{Atau, Anda dapat menggunakan yang berikut, yang lebih mirip dengan yang Anda miliki, meskipun Anda perlu menginisialisasi setiap baris secara eksplisit:}

int[][] multD = new int[5][];
for (int i = 0; i < 5; i++) {
  multD[i] = new int[10];
}

Dimungkinkan juga untuk menyatakannya dengan cara berikut. Ini bukan desain yang bagus, tapi itu berfungsi.

int[] twoDimIntArray[] = new int[5][10];

Mencoba:

int[][] multD = new int[5][10];

Perhatikan bahwa dalam kode Anda hanya baris pertama dari array 2D diinisialisasi ke 0. Baris 2 hingga 5 bahkan tidak ada. Jika Anda mencoba mencetaknya, Anda akan mendapatkannya nulluntuk semua orang.

int [][] twoDim = new int [5][5];

int a = (twoDim.length);//5
int b = (twoDim[0].length);//5

for(int i = 0; i < a; i++){ // 1 2 3 4 5
    for(int j = 0; j <b; j++) { // 1 2 3 4 5
        int x = (i+1)*(j+1);
        twoDim[i][j] = x;
        if (x<10) {
            System.out.print(" " + x + " ");
        } else {
            System.out.print(x + " ");
        }
    }//end of for J
    System.out.println();
}//end of for i

Di Jawa, array dua dimensi dapat dinyatakan sama dengan array satu dimensi. Dalam array satu dimensi Anda dapat menulis suka

  int array[] = new int[5];

di mana int adalah tipe data, array [] adalah deklarasi array, dan new arraymerupakan array dengan objeknya dengan lima indeks.

Seperti itu, Anda dapat menulis array dua dimensi sebagai berikut.

  int array[][];
  array = new int[3][4];

Ini arrayadalah tipe data int. Saya pertama kali mendeklarasikan pada array satu dimensi dari tipe-tipe itu, kemudian array 3 baris dan 4 kolom dibuat.

Dalam kode Anda

int[][] multD = new int[5][];
multD[0] = new int[10];

berarti Anda telah membuat array dua dimensi, dengan lima baris. Di baris pertama ada 10 kolom. Di Jawa, Anda dapat memilih ukuran kolom untuk setiap baris sesuai keinginan.

int rows = 5;
int cols = 10;

int[] multD = new int[rows * cols];

for (int r = 0; r < rows; r++)
{
  for (int c = 0; c < cols; c++)
  {
     int index = r * cols + c;
     multD[index] = index * 2;
  }
}

Nikmati!

Coba dengan cara ini:

int a[][] = {{1,2}, {3,4}};

int b[] = {1, 2, 3, 4};

Jenis-jenis array ini dikenal sebagai array bergerigi di Jawa:

int[][] multD = new int[3][];
multD[0] = new int[3];
multD[1] = new int[2];
multD[2] = new int[5];

Dalam skenario ini setiap baris array menampung jumlah kolom yang berbeda. Pada contoh di atas, baris pertama akan menampung tiga kolom, baris kedua akan menampung dua kolom, dan baris ketiga berisi lima kolom. Anda dapat menginisialisasi array ini pada waktu kompilasi seperti di bawah ini:

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

Anda dapat dengan mudah mengulangi semua elemen dalam array Anda:

for (int i = 0; i<multD.length; i++) {
    for (int j = 0; j<multD[i].length; j++) {
        System.out.print(multD[i][j] + "\t");
    }
    System.out.println();
}

Sebenarnya Java tidak memiliki array multi-dimensi dalam arti matematika. Apa yang dimiliki Java hanyalah array array, sebuah array di mana setiap elemen juga merupakan array. Itulah sebabnya syarat mutlak untuk menginisialisasi adalah ukuran dimensi pertama. Jika sisanya ditentukan maka akan membuat array yang diisi dengan nilai default.

int[][]   ar  = new int[2][];
int[][][] ar  = new int[2][][];
int[][]   ar  = new int[2][2]; // 2x2 array with zeros

Itu juga memberi kita kekhasan. Ukuran sub-array tidak dapat diubah dengan menambahkan lebih banyak elemen, tetapi kita dapat melakukannya dengan menetapkan array baru ukuran sewenang-wenang.

int[][]   ar  = new int[2][2];
ar[1][3] = 10; // index out of bound
ar[1]    = new int[] {1,2,3,4,5,6}; // works