Array-Basics Javassa Moniulotteiset taulukot voidaan määritellä yksinkertaisilla sanoilla taulukoiden joukoksi. Moniulotteisten taulukoiden tiedot tallennetaan taulukkomuodossa (rivin pääjärjestyksessä).
Syntaksi:
tietotyyppi [1. ulottuvuus][2. ulottuvuus][]..[N. ulottuvuus] taulukon_nimi = uusi tietotyyppi [koko1][koko2]…[kokoN];
missä:
- tietotyyppi : taulukkoon tallennettavien tietojen tyyppi. Esimerkiksi: int, char jne.
- ulottuvuus : Luodun taulukon ulottuvuus. Esimerkiksi: 1D, 2D jne.
- taulukon_nimi : taulukon nimi
- koko1, koko2, …, kokoN : Mittojen koot vastaavasti.
Esimerkkejä:
Two dimensional array: int[][] twoD_arr = new int[10][20]; Three dimensional array: int[][][] threeD_arr = new int[10][20][30];>
Moniulotteisten taulukoiden koko : Moniulotteiseen taulukkoon tallennettavien elementtien kokonaismäärä voidaan laskea kertomalla kaikkien ulottuvuuksien koko.
Esimerkiksi: Joukko int[][] x = uusi int[10][20] voi tallentaa yhteensä (10*20) = 200 elementtiä. Samoin array int[][][] x = uusi int[5][10][20] voi tallentaa yhteensä (5*10*20) = 1000 elementtiä.
Moniulotteisen taulukon soveltaminen
● Moniulotteisia taulukoita käytetään tietojen tallentamiseen taulukkomuodossa. Esimerkiksi opiskelijan rullan numeron ja merkintöjen tallentaminen onnistuu helposti moniulotteisten taulukoiden avulla. Toinen yleinen käyttötapa on kuvien tallentaminen 3D-taulukoihin.
● Dynaamisissa ohjelmointikysymyksissä käytetään moniulotteisia taulukoita, jotka edustavat tehtävän tiloja.
● Näiden lisäksi niillä on sovelluksia moniin vakioalgoritmisihin ongelmiin, kuten: matriisikertolasku, vierekkäisyysmatriisiesitys kaavioissa, ruudukkohakuongelmat.
Kaksiulotteinen taulukko (2D-taulukko)
Kaksiulotteinen taulukko on moniulotteisen taulukon yksinkertaisin muoto. Kaksiulotteinen taulukko voidaan nähdä yksiulotteisen matriisina, jotta se on helpompi ymmärtää.
Epäsuora ilmoitustapa:
- Ilmoitus – syntaksi:
data_type[][] array_name = new data_type[x][y]; For example: int[][] arr = new int[10][20];>
- Alustus – syntaksi:
array_name[row_index][column_index] = value; For example: arr[0][0] = 1;>
Esimerkki: 1
Java
import> java.io.*;> public> class> GFG {> >public> static> void> main(String[] args)> >{> >int>[][] arr =>new> int>[>10>][>20>];> >arr[>0>][>0>] =>1>;> >System.out.println(>'arr[0][0] = '> + arr[>0>][>0>]);> >}> }> |
>
>Lähtö
arr[0][0] = 1>
Esimerkki: 2D-taulukon toteuttaminen oletusarvoilla 4*4-matriisilla
Java
public> class> TwoDArray {> >public> static> void> main(String[] args) {> >int> rows =>4>;> >int> columns =>4>;> >int>[][] array =>new> int>[rows][columns];> >int> value =>1>;> >for> (>int> i =>0>; i for (int j = 0; j array[i][j] = value; value++; } } System.out.println('The 2D array is: '); for (int i = 0; i for (int j = 0; j System.out.print(array[i][j] + ' '); } System.out.println(); } } }> |
>
>Lähtö
The 2D array is: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16>
Selitys:
- Rivien ja sarakkeiden lukumäärä määritetään muuttujilla rivit ja sarakkeet. 2D-taulukko luodaan käyttämällä uutta operaattoria, joka varaa taulukolle muistia. Taulukon koko määritetään riveillä ja sarakkeilla.
Suora ilmoitustapa: Syntaksi:
data_type[][] array_name = { {valueR1C1, valueR1C2, ....}, {valueR2C1, valueR2C2, ....} }; For example: int[][] arr = {{1, 2}, {3, 4}};> Esimerkki:
Java
import> java.io.*;> class> GFG {> >public> static> void> main(String[] args)> >{> >int>[][] arr = { {>1>,>2> }, {>3>,>4> } };> >for> (>int> i =>0>; i <>2>; i++)> >for> (>int> j =>0>; j <>2>; j++)> >System.out.println(>'arr['> + i +>']['> + j +>'] = '> >+ arr[i][j]);> >}> }> |
>
>Lähtö
arr[0][0] = 1 arr[0][1] = 2 arr[1][0] = 3 arr[1][1] = 4>
Kaksiulotteisten taulukoiden elementtien käyttäminen
Kaksiulotteisten taulukoiden elementtejä kutsutaan yleisesti nimellä x[i][j] jossa 'i' on rivin numero ja 'j' on sarakkeen numero.
Syntaksi:
x[row_index][column_index]>
Esimerkiksi:
int[][] arr = new int[10][20]; arr[0][0] = 1;>
Yllä oleva esimerkki edustaa ensimmäisessä rivissä ja ensimmäisessä sarakkeessa olevaa elementtiä. Huomautus : Tauluissa, jos taulukon koko on N. Sen indeksi on 0 - N-1. Siksi rivin_indeksille 2 todellinen rivinumero on 2+1 = 3. Esimerkki:
Java
import> java.io.*;> class> GFG {> >public> static> void> main(String[] args)> >{> >int>[][] arr = { {>1>,>2> }, {>3>,>4> } };> >System.out.println(>'arr[0][0] = '> + arr[>0>][>0>]);> >}> }> |
>
>Lähtö
arr[0][0] = 1>
2D-taulukon esitys taulukkomuodossa:
Kaksiulotteinen matriisi voidaan nähdä taulukkona, jossa on 'x'-rivejä ja 'y-sarakkeita, joissa rivinumero vaihtelee välillä 0 - (x-1) ja sarakkeen numero 0 - (y-1). Kaksiulotteinen taulukko 'x', jossa on 3 riviä ja 3 saraketta, on esitetty alla:
Tulosta 2D-taulukko taulukkomuodossa:
Jos haluat tulostaa kaikki kaksiulotteisen taulukon elementit, käytä sisäkkäisiä silmukoita. Tätä varten tarvitaan kaksi for-silmukkaa, joista yksi kulkee rivien läpi ja toinen sarakkeiden läpi.
Esimerkki:
Java
import> java.io.*;> class> GFG {> >public> static> void> main(String[] args)> >{> >int>[][] arr = { {>1>,>2> }, {>3>,>4> } };> >for> (>int> i =>0>; i <>2>; i++) {> >for> (>int> j =>0>; j <>2>; j++) {> >System.out.print(arr[i][j] +>' '>);> >}> >System.out.println();> >}> >}> }> |
>
>Lähtö
1 2 3 4>
Esimerkki: 2D-taulukon toteutus käyttäjän syötteellä
Java
import> java.util.Scanner;> public> class> Main {> >public> static> void> main(String[] args)> >{> >Scanner scan =>new> Scanner(System.in);> >System.out.print(>'Enter number of rows: '>);> >int> rows = scan.nextInt();> >System.out.print(>'Enter number of columns: '>);> >int> columns = scan.nextInt();> >int>[][] multidimensionalArray=>new> int>[rows][columns];> >// Now you can use the array like a regular> >// 2-dimensional array> >for> (>int> i =>0>; i for (int j = 0; j multidimensionalArray[i][j]= (i + 1) * (j + 1); } } for (int i = 0; i for (int j = 0; j System.out.print(multidimensionalArray[i][j]+ ' '); } System.out.println(); } scan.close(); } }> |
>
>
Lähtö
Enter number of rows: 3 Enter number of columns: 3 1 2 3 2 4 6 3 6 9>
- Tämä koodi kehottaa käyttäjää syöttämään 2-ulotteisen taulukon rivien ja sarakkeiden lukumäärän. Scanner-luokkaa käytetään käyttäjän syötteiden lukemiseen. Sitten se luo 2-ulotteisen kokonaislukutaulukon, jossa on määritetty määrä rivejä ja sarakkeita, ja määrittää taulukon kullekin elementille i*j:n.
- Jos haluat luoda moniulotteisen taulukon, jossa on enemmän kuin kaksi ulottuvuutta, voit käyttää samaa lähestymistapaa taulukoiden taulukon luomiseen. Jos haluat esimerkiksi luoda kolmiulotteisen taulukon, voit luoda 2-ulotteisen taulukon.
Kolmiulotteinen taulukko (3D-taulukko)
Kolmiulotteinen taulukko on moniulotteisen taulukon monimutkainen muoto. Kolmiulotteinen matriisi voidaan nähdä kaksiulotteisena matriisina ymmärtämisen helpottamiseksi.
Epäsuora ilmoitustapa:
- Ilmoitus – syntaksi:
data_type[][][] array_name = new data_type[x][y][z]; For example: int[][][] arr = new int[10][20][30];>
- Alustus – syntaksi:
array_name[array_index][row_index][column_index] = value; For example: arr[0][0][0] = 1;>
Esimerkki:
Java
import> java.io.*;> class> GFG {> >public> static> void> main(String[] args)> >{> >int>[][][] arr =>new> int>[>10>][>20>][>30>];> >arr[>0>][>0>][>0>] =>1>;> >System.out.println(>'arr[0][0][0] = '> + arr[>0>][>0>][>0>]);> >}> }> |
>
>Lähtö
arr[0][0][0] = 1>
Suora ilmoitustapa: Syntaksi:
data_type[][][] array_name = { { {valueA1R1C1, valueA1R1C2, ....}, {valueA1R2C1, valueA1R2C2, ....} }, { {valueA2R1C1, valueA2R1C2, ....}, {valueA2R2C1, valueA2R2C2, ....} } }; For example: int[][][] arr = { {{1, 2}, {3, 4}}, {{5, 6}, {7, 8}} };> Esimerkki:
Java
import> java.io.*;> class> GFG {> >public> static> void> main(String[] args)> >{> >int>[][][] arr = { { {>1>,>2> }, {>3>,>4> } }, { {>5>,>6> }, {>7>,>8> } } };> >for> (>int> i =>0>; i <>2>; i++)> >for> (>int> j =>0>; j <>2>; j++)> >for> (>int> z =>0>; z <>2>; z++)> >System.out.println(>'arr['> + i> >+>']['> >+ j +>']['> >+ z +>'] = '> >+ arr[i][j][z]);> >}> }> |
>
>Lähtö
arr[0][0][0] = 1 arr[0][0][1] = 2 arr[0][1][0] = 3 arr[0][1][1] = 4 arr[1][0][0] = 5 arr[1][0][1] = 6 arr[1][1][0] = 7 arr[1][1][1] = 8>
Kolmiulotteisten taulukoiden elementtien käyttö
Kolmiulotteisten taulukoiden elementtejä kutsutaan yleisesti nimellä x[i][j][k] missä 'i' on taulukon numero, 'j' on rivin numero ja 'k' on sarakkeen numero.
Syntaksi:
x[array_index][row_index][column_index]>
Esimerkiksi:
int[][][] arr = new int[10][20][30]; arr[0][0][0] = 1;>
Yllä oleva esimerkki edustaa ilmoitetun 3D-taulukon ensimmäisen taulukon ensimmäisellä rivillä ja ensimmäisessä sarakkeessa olevaa elementtiä.
Huomautus : Tauluissa, jos taulukon koko on N. Sen indeksi on 0 - N-1. Siksi rivin_indeksille 2 todellinen rivinumero on 2+1 = 3.
Esimerkki:
Java
import> java.io.*;> class> GFG {> >public> static> void> main(String[] args)> >{> >int>[][][] arr = { { {>1>,>2> }, {>3>,>4> } }, { {>5>,>6> }, {>7>,>8> } } };> >System.out.println(>'arr[0][0][0] = '> + arr[>0>][>0>][>0>]);> >}> }> |
>
>Lähtö
arr[0][0][0] = 1>
3D-taulukon esitys taulukkomuodossa:
Kolmiulotteinen matriisi voidaan nähdä taulukkona taulukoista, joissa on 'x'-rivejä ja 'y'-sarakkeita, joissa rivinumero vaihtelee välillä 0 - (x-1) ja sarakkeen numero vaihtelee välillä 0 - (y-1). Alla näkyy kolmiulotteinen taulukko, jossa on 3 taulukkoa, jotka sisältävät 3 riviä ja 3 saraketta:
Tulosta 3D-taulukko taulukkomuodossa:
Jos haluat tulostaa kaikki kolmiulotteisen taulukon elementit, käytä sisäkkäisiä silmukoita. Tätä varten tarvitaan kolme for-silmukkaa, yksi kulkemaan taulukoiden läpi, toinen kulkemaan riveissä ja toinen kulkemaan sarakkeiden läpi.
Esimerkki:
Java
import> java.io.*;> class> GFG {> >public> static> void> main(String[] args)> >{> >int>[][][] arr = { { {>1>,>2> }, {>3>,>4> } },> >{ {>5>,>6> }, {>7>,>8> } } };> >for> (>int> i =>0>; i <>2>; i++) {> >for> (>int> j =>0>; j <>2>; j++) {> >for> (>int> k =>0>; k <>2>; k++) {> >System.out.print(arr[i][j][k] +>' '>);> >}> >System.out.println();> >}> >System.out.println();> >}> >}> }> |
>
>Lähtö
1 2 3 4 5 6 7 8>
Moniulotteisen taulukon lisääminen ajon aikana:
Tämä aihe on pakotettu n ottamaan käyttäjän määrittämää syötettä moniulotteiseen taulukkoon suorituksen aikana. Se keskittyy siihen, että käyttäjä antaa ensin kaiken syötteen ohjelmalle ajon aikana, ja kaikkien syötettyjen syötteiden jälkeen ohjelma antaa tulosteen kunkin syötteen osalta vastaavasti. Se on hyödyllistä, kun käyttäjä haluaa ensin syöttää useita testitapauksia useilla eri arvoilla ja kun kaikki nämä asiat on tehty, ohjelma alkaa tuottaa tulosta. Esimerkkinä etsitään parillisten ja parittomien lukujen kokonaismäärä syöttötaulukosta. Tässä käytämme 2-ulotteisen taulukon käsitettä.
Tässä on muutamia kohtia, jotka selittävät tulevan koodin eri elementtien käytön:
- Rivin kokonaislukua pidetään testitapausten lukumääränä ja sarakkeen arvoja arvoina jokaisessa testitapauksessa.
- Yhtä for()-silmukkaa käytetään Test-Case-numeron päivittämiseen ja toista for()-silmukkaa käytetään vastaavien taulukkoarvojen ottamiseen.
- Kun kaikki syötteet on tehty, kahta for()-silmukkaa käytetään samalla tavalla ohjelman suorittamiseen määritetyn ehdon mukaisesti.
- Ensimmäinen syöttörivi on TestCaseiden kokonaismäärä.
- Toinen rivi näyttää ensimmäisten taulukoiden arvojen kokonaismäärän.
- Kolmas rivi antaa taulukon arvot ja niin edelleen.
Toteutus:
roomalaiset numerot 1-100
Java
import> java.io.*;> import> java.util.Scanner;> class> GFGTestCase {> >public> static> void> main(String[] args)> >{> >// Scanner class to take> >// values from console> >Scanner scanner =>new> Scanner(System.in);> >// totalTestCases = total> >// number of TestCases> >// eachTestCaseValues => >// values in each TestCase as> >// an Array values> >int> totalTestCases, eachTestCaseValues;> >// takes total number of> >// TestCases as integer number> >totalTestCases = scanner.nextInt();> >// An array is formed as row> >// values for total testCases> >int>[][] arrayMain =>new> int>[totalTestCases][];> >// for loop to take input of> >// values in each TestCase> >for> (>int> i =>0>; i eachTestCaseValues = scanner.nextInt(); arrayMain[i] = new int[eachTestCaseValues]; for (int j = 0; j arrayMain[i][j] = scanner.nextInt(); } } // All input entry is done. // Start executing output // according to condition provided for (int i = 0; i // Initialize total number of // even & odd numbers to zero int nEvenNumbers = 0, nOddNumbers = 0; // prints TestCase number with // total number of its arguments System.out.println('TestCase ' + i + ' with ' + arrayMain[i].length + ' values:'); for (int j = 0; j System.out.print(arrayMain[i][j] + ' '); // even & odd counter updated as // eligible number is found if (arrayMain[i][j] % 2 == 0) { nEvenNumbers++; } else { nOddNumbers++; } } System.out.println(); // Prints total numbers of // even & odd System.out.println( 'Total Even numbers: ' + nEvenNumbers + ', Total Odd numbers: ' + nOddNumbers); } } } // This code is contributed by Udayan Kamble.> |
>
>
Lähtö:
Input: 2 2 1 2 3 1 2 3 Output: TestCase 0 with 2 values: 1 2 Total Even numbers: 1, Total Odd numbers: 1 TestCase 1 with 3 values: 1 2 3 Total Even numbers: 1, Total Odd numbers: 2 Input: 3 8 1 2 3 4 5 11 55 66 5 100 101 55 35 108 6 3 80 11 2 1 5 Output: TestCase 0 with 8 values: 1 2 3 4 5 11 55 66 Total Even numbers: 3, Total Odd numbers: 5 TestCase 1 with 5 values: 100 101 55 35 108 Total Even numbers: 2, Total Odd numbers: 3 TestCase 2 with 6 values: 3 80 11 2 1 5 Total Even numbers: 2, Total Odd numbers: 4>