Susunan Pelbagai Dimensi Di Jawa

1. Gambaran keseluruhan

Susunan pelbagai dimensi di Jawa adalah susunan yang terdiri daripada susunan pelbagai ukuran sebagai elemennya. Ini juga disebut sebagai "array array" atau "array ragged" atau "array bergerigi".

Dalam tutorial ringkas ini, kita akan melihat lebih mendalam untuk menentukan dan bekerja dengan tatasusunan pelbagai dimensi.

2. Membuat Array Pelbagai Dimensi

Mari mulakan dengan melihat cara-cara di mana kita dapat membuat susunan pelbagai dimensi:

2.1. Bentuk Shorthand

Cara mudah untuk menentukan susunan pelbagai dimensi ialah:

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

Di sini, kami telah menyatakan dan menginisialisasi multiDimensionalArr dalam satu langkah.

2.2. Pengisytiharan dan Kemudian Permulaan

Kita mulakan dengan menyatakan pelbagai dimensi ukuran tiga:

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

Di sini, kami tidak dapat menentukan dimensi kedua kerana ia akan berbeza-beza .

Seterusnya, mari kita melangkah lebih jauh dengan menyatakan dan menginisialisasi elemen masing-masing dalam multiDimensionalArr :

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

Kita juga boleh menyatakan unsur-unsurnya tanpa memulakannya:

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

Ini kemudian dapat diinisialisasi, misalnya dengan menggunakan input pengguna.

Kita juga boleh menggunakan kaedah java.util.Arrays.fill untuk memulakan elemen array:

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

Semua elemen dalam susunan diinisialisasi dengan nilai yang sama.

3. Perwakilan Ingatan

Bagaimana gambaran memori multiDimensionalArr kita ?

Seperti yang kita ketahui, sebuah array di Java tidak lain hanyalah sebuah objek, unsur-unsurnya dapat menjadi primitif atau rujukan. Jadi, susunan dua dimensi di Jawa dapat dianggap sebagai susunan array satu dimensi.

Kami multiDimensionalArr dalam ingatan akan kelihatan sama dengan:

Jelas, multiDimensionalArr [0] merujuk kepada susunan satu dimensi bersaiz 2, multiDimensionalArr [1] merujuk kepada susunan satu dimensi ukuran 3 dan seterusnya.

Dengan cara ini Java memungkinkan kita menentukan dan menggunakan tatasusunan pelbagai dimensi.

4. Mengulangi Elemen

Kita boleh mengulangi array pelbagai dimensi seperti array lain di Java.

Mari kita cuba mengulangi dan memulakan elemen multiDimensionalArr menggunakan input pengguna:

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(); } } }

Di sini, panjang multiDimensionalArr [luar] adalah panjang array pada indeks luar dalam multiDimensionalArr .

Ini membantu kita memastikan bahawa kita mencari elemen hanya dalam julat yang sah dari setiap sub-array , dengan itu mengelakkan ArrayIndexOutOfBoundException .

5. Elemen Percetakan

Bagaimana jika kita mahu mencetak elemen array pelbagai dimensi kita?

Salah satu cara yang jelas adalah menggunakan logik iterasi yang telah kita bahas. Ini melibatkan pengulangan melalui setiap item dalam tatasusunan pelbagai dimensi kami, yang merupakan susunan, dan kemudian melakukan lelaran ke atas susunan anak - satu elemen pada satu masa.

Pilihan lain yang kita ada ialah menggunakan kaedah pembantu java.util.Arrays.toString () :

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

Dan akhirnya kami mempunyai kod yang bersih dan ringkas. Output konsol yang dihasilkan akan kelihatan seperti:

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

6. Panjang Unsur

Kita dapat mengetahui panjang tatasusunan dalam tatasusunan pelbagai dimensi dengan melakukan lelaran ke atas larik utama:

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; }

Kita juga dapat mengetahui panjang tatasusunan menggunakan aliran Java:

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

7. Salin Array 2-D

Kita boleh menyalin array 2-D menggunakan kaedah Arrays.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; }

Kami juga dapat mencapainya dengan menggunakan aliran Java:

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

8. Kesimpulannya

Dalam artikel ini, kami melihat apakah tatasusunan multi-dimensi, bagaimana susunannya dalam ingatan dan cara bagaimana kita dapat menentukan dan menggunakannya.

Seperti biasa, kod sumber contoh yang dikemukakan boleh didapati di GitHub.