Tatasusunan berbilang dimensi

• Tatasusunan berbilang dimensi, sintaks umum
• Tatasusunan dua dimensi
• Mengisytiharkan, mencipta dan memulakan tatasusunan dua dimensi
• Memaparkan tatasusunan dua dimensi pada skrin
• Keluaran pantas tatasusunan dua dimensi
• "Panjang" tatasusunan dua dimensi
• Contoh penggunaan tatasusunan dua dimensi: papan dam
• Contoh penggunaan tatasusunan dua dimensi: pendaraban matriks
• Tatasusunan dua dimensi bukan segi empat tepat
• Tatasusunan tiga dimensi
• Tatasusunan berbilang dimensi dalam kerja sebenar pengaturcara Java
• Masalah menarik pada tatasusunan dua dimensi dan tiga dimensi

Apakah tatasusunan Java satu dimensi?

Tatasusunan ialah set tertib unsur-unsur dari jenis, primitif atau rujukan yang sama. Maklumat am tentang tatasusunan (kebanyakannya satu dimensi) boleh didapati dalam artikel " Tatasusunan dalam Java " dan dalam kursus JavaRush . Dalam artikel ini kita akan bercakap tentang tatasusunan yang elemennya ialah tatasusunan lain. Tatasusunan sedemikian dipanggil multidimensi. Tatasusunan yang elemennya ialah tatasusunan lain, iaitu tatasusunan tatasusunan, dipanggil dua dimensi. Tidak semua bahasa mempunyai tatasusunan berbilang dimensi yang distrukturkan dengan cara ini, tetapi di Jawa ini berlaku.

Tatasusunan Berbilang Dimensi Java, Sintaks Umum

Secara umum, tatasusunan multidimensi dalam Java kelihatan seperti ini:

Data_type[dimension1][dimension2][]..[dimensionN] array_name = new data_type[size1][size2]….[sizeN];

Di manakah Data_typejenis elemen dalam tatasusunan. Boleh jadi primitif atau rujukan (kelas). Bilangan pasangan kurungan dengan dimensionbahagian dalam ialah dimensi tatasusunan (dalam kes kami - N). array_name— nama tatasusunan size1...sizN— bilangan elemen dalam setiap dimensi tatasusunan. Mengisytiharkan tatasusunan berbilang dimensi:

int[][] twoDimArray; //two-dimensional array
String[][][] threeDimArray; //three-dimensional array
double[][][][][] fiveDimArray; // five-dimensional array

Mungkin semua ini kelihatan sangat abstrak, jadi sekarang mari kita beralih kepada manifestasi konkrit tatasusunan multidimensi - dua dimensi dan tiga dimensi. Hakikatnya ialah pembangun Java kadangkala menggunakan tatasusunan dua dimensi, lebih jarang - tatasusunan tiga dimensi, malah tatasusunan yang lebih besar amat jarang berlaku. Terdapat kebarangkalian tinggi bahawa anda tidak akan menemui mereka.

Apakah tatasusunan Java dua dimensi?

Tatasusunan dua dimensi dalam Java ialah tatasusunan tatasusunan, iaitu setiap sel mengandungi rujukan kepada tatasusunan. Tetapi lebih mudah untuk membentangkannya dalam bentuk jadual yang mempunyai bilangan baris tertentu (dimensi pertama) dan bilangan lajur (dimensi kedua). Tatasusunan dua dimensi di mana semua baris mempunyai bilangan elemen yang sama dipanggil segi empat tepat.

Mengisytiharkan, mencipta dan memulakan tatasusunan dua dimensi

Prosedur untuk mengisytiharkan dan mencipta tatasusunan dua dimensi adalah hampir sama seperti dalam kes satu dimensi:

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

Tatasusunan ini mempunyai 3 baris dan 4 lajur. Saiz tatasusunan dua dimensi segi empat tepat (ia mungkin bukan segi empat tepat, lebih banyak lagi di bawah), iaitu, jumlah bilangan elemen boleh ditentukan dengan mendarabkan bilangan baris dengan bilangan lajur. Ia kini dimulakan (diisi) dengan nilai lalai. Iaitu, sifar. Mari kita isi dengan nilai yang kita perlukan.

twoDimArray[0][0] = 5;//write the value 5 into the cell at the intersection of the zero row and zero column
twoDimArray[0][1] = 7; //write the value 7 into the cell at the intersection of the zero row and the first column
twoDimArray[0][2]  = 3;
twoDimArray[0][3] = 17;
twoDimArray[1][0] = 7;
twoDimArray[1][1] = 0;
twoDimArray[1][2] = 1;
twoDimArray[1][3] = 12;
twoDimArray[2][0] = 8;
twoDimArray[2][1] = 1;
twoDimArray[2][2] = 2;
twoDimArray[2][3] = 3;

Seperti tatasusunan satu dimensi, anda boleh melakukan prosedur permulaan dengan lebih cepat:

int [][] twoDimArray = {{5,7,3,17}, {7,0,1,12}, {8,1,2,3}};

Dalam kedua-dua kes, kita akan mendapat tatasusunan dua dimensi dengan tiga baris dan empat lajur, diisi dengan integer.

Memaparkan tatasusunan dua dimensi pada skrin

Cara yang paling logik untuk melakukan operasi ini ialah dengan mula-mula mengeluarkan elemen baris sifar mengikut elemen, kemudian yang kedua, dan seterusnya. Cara paling biasa untuk mengeluarkan tatasusunan dua dimensi dalam Java ialah menggunakan dua gelung bersarang.

int [][] twoDimArray = {{5,7,3,17}, {7,0,1,12}, {8,1,2,3}};//declared an array and filled it with elements
for (int i = 0; i < 3; i++) {  //go through the lines
            for (int j = 0; j < 4; j++) {//go through the columns
                System.out.print(" " + twoDimArray[i][j] + " "); //output element
            }
            System.out.println();// line wrap for the visual preservation of the tabular form
        }

Keluaran pantas tatasusunan dua dimensi

Cara terpendek untuk memaparkan senarai elemen tatasusunan dua dimensi pada skrin adalah dengan menggunakan kaedah deepToStringkelas Arrays. Contoh:

int[][] myArray = {{18,28,18},{28,45,90},{45,3,14}};
System.out.printLn(Arrays.deepToString(myArray));

Hasil program ialah output berikut: [[18, 28, 18], [28, 45, 90], [45, 3, 14]]

"Panjang" tatasusunan dua dimensi

Untuk mendapatkan panjang tatasusunan satu dimensi (iaitu, bilangan elemen di dalamnya), anda boleh menggunakan pembolehubah length. Iaitu, jika kita mentakrifkan tatasusunan int a[] = {1,2,3}, maka operasi itu a.lengthmengembalikan 3. Tetapi bagaimana jika kita menggunakan prosedur yang sama pada tatasusunan dua dimensi kami?

int [][] twoDimArray = {{5,7,3,17}, {7,0,1,12}, {8,1,2,3}};
System.out.println(twoDimArray.length);

Output: 3 Jadi operasi ini mengeluarkan bilangan baris dalam tatasusunan. Bagaimana untuk mendapatkan bilangan lajur? Jika kita berurusan dengan tatasusunan dua dimensi segi empat tepat (iaitu, yang mana semua baris adalah sama panjang), maka kita boleh menggunakan operasi twoDimArray[0].lengthatau bukannya elemen sifar (pada asasnya garisan sifar) - mana-mana yang sedia ada. Kita boleh melakukan ini kerana dalam Java, tatasusunan dua dimensi ialah tatasusunan tatasusunan, dan sifar elemen twoDimArray[0]ialah tatasusunan panjang 4. Anda boleh menyemaknya sendiri.

Contoh penggunaan tatasusunan dua dimensi: papan dam

Tatasusunan dua dimensi boleh digunakan untuk mencipta sebarang medan dua dimensi terhingga, contohnya dalam permainan, dan khususnya dalam catur. Sangat mudah untuk memikirkan papan catur sebagai tatasusunan dua dimensi. Anda boleh "lampirkan" grafik pada ini, tetapi buat masa ini, mari kita tentukan papan catur menggunakan simbol dan keluarkannya ke konsol. Petak kiri bawah papan catur dicat hitam, yang seterusnya berwarna putih, seperti yang ada di atasnya. Jadi, warna berubah setiap kali anda berpindah ke sel bersebelahan dengan sisi. Untuk menetapkan pewarnaan catur bukan secara manual, tetapi menggunakan algoritma, anda boleh menggunakan semakan pariti: jika jumlah indeks baris dan lajur adalah genap atau sifar, maka sel akan menjadi putih, jika tidak, ia akan menjadi hitam. Untuk semakan ini, kami menggunakan operator baki % dalam algoritma. Oleh kerana kami tidak bekerja dengan grafik, tetapi dengan simbol, kami akan menandakan sel putih dengan huruf W(putih), dan sel hitam dengan huruf B(hitam).

//set the chessboard as a two-dimensional array
String [][] chessBoard = new String[8][8];
        for (int i = 0; i< chessBoard.length; i++) {
            for (int j = 0; j < chessBoard[0].length; j++) {
                if ((i + j) % 2 == 0) chessBoard[i][j] = "W";
                else chessBoard[i][j] = "B";
            }
        }

Output program adalah seperti berikut: WBWBWBWBBWBWBWBWWBWBW BWBBWBWBWBWWBWBWBWBBW BWBWBWWBWBWBWBWBWBWB W Semuanya seperti di papan catur sebenar, anda boleh menyemaknya. Sekarang mari kita tulis kaedah untuk menomborkan sel dengan betul bukan dalam bahasa tatasusunan, tetapi dalam bahasa "catur". Sel kiri bawah pada papan dipanggil A1, manakala dalam tatasusunan kami ialah chessBoard[7][0]. Marilah kita mengaitkan setiap pasangan indeks tatasusunan dua dimensi dengan persamaan "catur" mereka. Untuk melakukan ini, kami menggunakan dua baris - " abcdefgh" dan " 87654321" (dalam susunan terbalik - untuk kesederhanaan, supaya papan dam 8 sepadan dengan lajur sifar).

public static String chessBoardCoord(int a, int b) {
            String letters = "abcdefgh";
            String numbers = "87654321";
            if ((a > 7)|| (b>7)) return null; //if the number is outside the board, return the default value - null
            else return (Character.toString(letters.charAt(a)) + numbers.charAt(b)); /*charAt - a method with which we extract from the string the element under the passed number, here - under the numbers a and b. Character.toString - a method that converts the received character into a string */
        }

Sekarang mari kita paparkan dalam setiap sel bukan sahaja warnanya, tetapi juga nombornya, menggunakan kaedah tersebutchessBoardCoord

String [][] chessBoard = new String[8][8];
        for (int i = 0; i < chessBoard.length; i++) {
            for (int j = 0; j < chessBoard[0].length; j++) {
                if ((i + j) % 2 == 0) chessBoard[i][j] = "W" + chessBoardCoord(j,i);
                else chessBoard[i][j] = "B"+ chessBoardCoord(j,i);
            }
        }

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

Keluaran atur cara: Wa8 Bb8 Wc8 Bd8 We8 Bf8 Wg8 Bh8 Ba7 Wb7 Bc7 Wd7 Be7 Wf7 Bg7 Wh7 Wa6 Bb6 Wc6 Bd6 We6 Bf6 Wg6 Bh6 Ba5 Wb5 Bc5 Wd5 Be5 Wf5 Bg5 Wh5 Wa4 Bb4 We Wc4 3 Be3 Wf3 Bg3 Wh3 Wa2 Bb2 Wc2 Bd2 We2 Bf2 Wg2 Bh2 Ba1 Wb1 Bc1 Wd1 Be1 Wf1 Bg1 Wh1 Di mana We2bermaksud petak putih bernombor e2.

Contoh penggunaan tatasusunan dua dimensi: pendaraban matriks

Perhatian!Contoh ini memerlukan pengetahuan asas tentang matriks. Di sini sangat sedikit yang akan dikatakan tentang mereka, dan maklumat ini bertujuan untuk mereka yang telah belajar, tetapi agak terlupa, aritmetik matriks. Walau bagaimanapun, pengetahuan ini boleh diperoleh daripada sumber terbuka, khususnya daripada artikel di Wikipedia . Ini adalah contoh yang baik untuk menggunakan tatasusunan dua dimensi, tetapi kita boleh meneruskan tanpanya. Jadi jika ia kelihatan tidak dapat difahami oleh anda sekarang dari sudut pandangan matematik, dan anda tidak benar-benar mahu menyelidikinya, jangan ragu untuk melangkau contoh. Jika anda telah mempelajari algebra linear asas, anda mungkin telah mempelajari tentang tatasusunan segi empat tepat sebagai matriks segi empat tepat. Di mana a11, a12... aNN ialah beberapa nombor. Dalam rajah itu, matriks bukan segi empat tepat, tetapi segi empat sama (bilangan baris adalah sama dengan bilangan lajur, tetapi ini tidak selalu berlaku). Dalam kehidupan sebenar, matriks sedemikian jarang ditemui, tetapi dalam pengaturcaraan dan sains komputer ia sangat biasa. Khususnya, ia digunakan dalam grafik komputer dan enjin permainan. Contohnya, putaran objek pada skrin ke mana-mana sudut boleh diprogramkan menggunakan matriks putaran. Dalam ruang dua dimensi, matriks putaran kelihatan seperti ini: Di ​​mana theta ialah sudut di mana objek perlu diputar. Matriks dengan dimensi yang sama boleh ditambah antara satu sama lain, dan penambahan berlaku elemen demi elemen (kami menambah elemen dengan indeks yang sama). Tetapi operasi pendaraban matriks kurang biasa. Oleh itu, matriks boleh didarab dan matriks yang terhasil hanya boleh diperolehi jika bilangan lajur matriks pertama bertepatan dengan bilangan baris kedua. Matriks hasil akan mempunyai bilangan baris yang sama dengan yang pertama dan bilangan lajur yang sama dengan yang kedua. Pendaraban dilakukan seperti berikut. Marilah kita mempunyai matriks a[l][m]dan b[m][n]. Hasil daripada pendaraban mereka, kita harus mendapatkan matriks c[l][n]. Untuk mendapatkan unsur c[0][0]matriks produk, anda perlu a[0][0]mendarab unsur sifar baris sifar matriks pertama dengan unsur sifar matriks kedua, kemudian darab unsur pertama baris pertama matriks pertama dengan unsur pertama. lajur pertama matriks kedua, dan seterusnya, selepas itu semua produk yang terhasil ditambah.

a[0][0]*b[0][0] + a[0][1]*b[1][0] + … + a[0][m-1]*b[m-1][0]

Untuk mendapatkan elemen kedua baris pertama matriks hasil, kami melakukan prosedur yang sama dengan baris kedua

a[1][0]*b[0][0] + a[1][1]*b[0][1] + … + a[0][m-1]*b[m-1][0]

Dan seterusnya sehingga tamat talian. Kemudian kami beralih ke baris seterusnya dan ulangi prosedur sehingga kami kehabisan baris. Iaitu, kita mendarabkan baris matriks pertama dengan lajur matriks kedua. Di bawah ialah kod untuk pendaraban matriks. Anda boleh menambahnya dengan semakan untuk pematuhan syarat yang dinyatakan di atas pada bilangan baris dan lajur.

//declaring two matrices
int [][] twoDimArray1 = {{1,0,0,0},{0,1,0,0},{0,0,0,0}};
int[][] twoDimArray2 = {{1,2,3},{1,1,1},{0,0,0},{2,1,0}};

//matrix multiplication process
int[][]twoDimArray3 = new int [twoDimArray1.length][twoDimArray2[0].length];
        for (int i=0; i<twoDimArray3[0].length; i++)
            for (int j=0; j<twoDimArray3.length; j++)
                for (int k=0; k<twoDimArray1[0].length; k++)
                              twoDimArray3[i][j] = twoDimArray3[i][j] + twoDimArray1[i][k] * twoDimArray2[k][j];

//output on display
        for (int i = 0; i < twoDimArray3.length; i++) {
            for (int j = 0; j < twoDimArray3[0].length; j++) {
                System.out.print(" " + twoDimArray3[i][j] + " ");
            }
            System.out.println();
        }

Program mengeluarkan keputusan berikut: 1 2 3 1 1 1 0 0 0

Tatasusunan dua dimensi bukan segi empat tepat

Memandangkan tatasusunan dua dimensi dalam Java ialah tatasusunan tatasusunan, setiap tatasusunan dalam boleh mempunyai panjang yang berbeza. Apabila membuat tatasusunan, kita hanya boleh menentukan bilangan baris dan bukan bilangan lajur (iaitu, sebenarnya, panjang baris yang sama ini). Mari kita lihat contoh.

//declaring and creating an array, specifying only the number of rows
int [][] twoDimArray = new int[5][];

//initialize the array, filling it with arrays of different lengths
        twoDimArray[0] = new int[]{1, 2, 3, 4, 5};
        twoDimArray[1] = new int[]{1,2,3,4};
        twoDimArray[2] = new int[]{1,2,3};
        twoDimArray[3] = new int[]{1,2};
        twoDimArray[4] = new int[]{1};
//display the resulting non-rectangular two-dimensional array on the screen
        for (int i = 0; i < twoDimArray.length; i++) {
            for (int j = 0; j < twoDimArray[i].length; j++) {
                System.out.print(" " + twoDimArray[i][j] + " ");
            }
            System.out.println();
        }

Output program: 1 2 3 4 5 1 2 3 4 1 2 3 1 2 1 Oleh itu, baris sifar tatasusunan kami mengandungi tatasusunan {1,2,3,4,5}, dan baris keempat mengandungi tatasusunan {1}.

Tatasusunan tiga dimensi dalam Java

Mengikuti akal dan logik bahasa Java, tatasusunan tiga dimensi boleh dipanggil "tatasusunan tatasusunan" atau "tatasusunan yang setiap elemennya ialah tatasusunan dua dimensi." Selain itu, tatasusunan dua dimensi ini boleh berbeza. Contoh:

// create a three-dimensional array consisting of two two-dimensional arrays
int[][][] threeDimArr = new int[2][][];
//create the first 2D array of a 5x2 3D array
        threeDimArr[0] = new int[5][2];
//create a second 2D array of a 1x1 3D array
        threeDimArr[1] = new int[1][1];

Tetapi lebih kerap dalam amalan terdapat tatasusunan tiga dimensi di mana ketiga-tiga kuantiti ditakrifkan sekali gus, analog tatasusunan dua dimensi segi empat tepat. Seperti yang telah kami nyatakan, tatasusunan tiga dimensi atau lebih jarang digunakan. Walau bagaimanapun, anda boleh memprogramkan sesuatu yang menarik dengan tatasusunan 3D. Contohnya, tempat letak kereta bertingkat. Setiap tingkat boleh dianggap sebagai tatasusunan dua dimensi, dan ruang letak kereta boleh dianggap sebagai elemen khusus tatasusunan tiga dimensi. Elemen tatasusunan sedemikian boleh diwakili oleh jenis booleandengan nilai palsu jika ruang kosong dan benar jika ruang diduduki.

//set a boolean three-dimensional array. This car park has 3 floors, each of which can accommodate 2x5 = 10 cars. By default, all cells are empty (false)
boolean[][][] parkingLot = new boolean[3][2][5];
//two cars arrived and parked on the ground floor in cell [1][0] and [1][3]
        parkingLot[0][1][0] = true;
        parkingLot[0][1][3] = true;

//Output the array to the console
        for (int i = 0; i < 3; i++) {
            for (int j = 0; j < 2; j++) {
                for (int k = 0; k < 5; k++) {
                    System.out.print("arr[" + i + "][" + j + "][" + k + "] = " + parkingLot[i][j][k] + "\t");

                }
                System.out.println();
            }
        }

Masalah menarik pada tatasusunan dua dimensi dan tiga dimensi

Anda cukup tahu tentang tatasusunan berbilang dimensi di Jawa dan, jika anda berasa yakin, anda boleh cuba menyelesaikan beberapa masalah di bawah. Mereka tidak mudah, tetapi menarik. Tic-tac-toe. Sediakan padang 3x3, cipta dua pemain yang bergilir-gilir. Pada mulanya, medan itu kosong, dan dalam setiap medan kosong pemain pertama boleh meletakkan salib, dan yang kedua sifar. Pemenang ialah orang yang mula-mula mengumpul tiga silang atau tiga sifar yang disusun dalam satu baris, satu lajur atau menyerong. Semut Langton . Terdapat medan tertentu, dibahagikan kepada sel (susunan dua dimensi), dicat hitam atau putih (boleh ditetapkan oleh fungsi rawak). “Semut” secara rawak menjelma dalam salah satu sel, dan pada setiap langkah ia boleh bergerak dalam satu daripada empat arah ke sel bersebelahan, secara mendatar atau menegak. Peraturan pergerakan semut:

• Pada petak hitam, semut mesti membelok 90° ke kiri, menukar warna selnya kepada putih, kemudian melangkah ke hadapan ke petak seterusnya.
• Pada petak putih, semut membelok 90° ke kanan dan menukar warna selnya kepada hitam, kemudian melangkah ke hadapan ke petak seterusnya.

Tulis kaedah yang mengira lelaran pada nombor langkah ndiberi kedudukan awal semut. Medan boleh diisi secara rawak dengan sifar dan satu (atau dilambangkan dengan huruf Wdan B, seperti yang kita lakukan dalam contoh papan catur). Kami juga memerlukan dua lagi parameter - kedudukan mendatar dan menegak semut, serta arahnya pada langkah ini (utara, selatan, barat, timur), manakala secara lalai semut melihat ke utara. Anda boleh cuba memodelkan kiub Rubik menggunakan tatasusunan tiga dimensi. Kiub Rubik standard mempunyai 6 muka, dan setiap satu daripadanya ialah susunan tiga dimensi petak berwarna Color[][][] rubik = new Color[6][3][3]. Walau bagaimanapun, melaksanakan kiub Rubik bukanlah satu tugas yang remeh.

Bahan berguna tentang tatasusunan

Banyak artikel tentang JavaRush ditumpukan kepada tatasusunan (terutamanya yang satu dimensi, kerana ia lebih kerap digunakan dalam amalan). Beri perhatian kepada mereka.

1. Tatasusunan dalam Java - tentang tatasusunan untuk pemula dengan contoh
2. Sesuatu Mengenai Tatasusunan - Artikel terperinci yang bagus tentang tatasusunan
3. Kelas Arrays dan penggunaannya - artikel menerangkan beberapa kaedah kelasArray
4. Arrays ialah kuliah JavaRush pertama yang didedikasikan untuk tatasusunan.
5. Kembalikan tatasusunan sifar panjang, bukan nol - Pengarang Pengaturcaraan Berkesan Joshua Bloch bercakap tentang cara untuk mengembalikan tatasusunan kosong dengan lebih baik