Array-basisprincipes in Java Multidimensionale arrays kan in eenvoudige woorden worden gedefinieerd als een array van arrays. Gegevens in multidimensionale arrays worden in tabelvorm opgeslagen (in de hoofdvolgorde van de rij).
Syntaxis:
data type [1e dimensie][2e dimensie][]..[N-de dimensie] array_naam = nieuw gegevenstype [maat1][maat2]….[maatN];
waar:
- data type : Type gegevens dat in de array moet worden opgeslagen. Bijvoorbeeld: int, char, enz.
- dimensie : De dimensie van de gemaakte array. Bijvoorbeeld: 1D, 2D, enz.
- array_naam : Naam van de array
- maat1, maat2, …, maatN : Maten van de afmetingen respectievelijk.
Voorbeelden:
Two dimensional array: int[][] twoD_arr = new int[10][20]; Three dimensional array: int[][][] threeD_arr = new int[10][20][30];>
Grootte van multidimensionale arrays : Het totale aantal elementen dat in een multidimensionale array kan worden opgeslagen, kan worden berekend door de grootte van alle dimensies te vermenigvuldigen.
Bijvoorbeeld: De array int[][] x = nieuwe int[10][20] kan in totaal (10*20) = 200 elementen opslaan. Op dezelfde manier, array int[][][] x = nieuwe int[5][10][20] kan in totaal (5*10*20) = 1000 elementen opslaan.
Toepassing van multidimensionale array
● Er worden multidimensionale arrays gebruikt om de gegevens in tabelvorm op te slaan. Het opslaan van het rolnummer en de cijfers van een leerling kan bijvoorbeeld eenvoudig worden gedaan met behulp van multidimensionale arrays. Een ander veelgebruikt gebruik is om de afbeeldingen op te slaan in 3D-arrays.
● Bij dynamische programmeervragen worden multidimensionale arrays gebruikt die worden gebruikt om de status van het probleem weer te geven.
● Afgezien hiervan hebben ze ook toepassingen in veel standaard algoritmische problemen, zoals: matrixvermenigvuldiging, weergave van aangrenzende matrixen in grafieken, problemen met zoeken in rasters
Tweedimensionale array (2D-array)
Tweedimensionale array is de eenvoudigste vorm van een multidimensionale array. Een tweedimensionale array kan worden gezien als een array van eendimensionale array voor een beter begrip.
hoeveel weken heeft een maand
Indirecte wijze van aangifte:
- Verklaring – Syntaxis:
data_type[][] array_name = new data_type[x][y]; For example: int[][] arr = new int[10][20];>
- Initialisatie – Syntaxis:
array_name[row_index][column_index] = value; For example: arr[0][0] = 1;>
Voorbeeld: 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>]);> >}> }> |
>
>Uitvoer
arr[0][0] = 1>
Voorbeeld: Implementatie van een 2D-array met standaardwaarden met een 4*4-matrix
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(); } } }> |
>
>Uitvoer
The 2D array is: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16>
Uitleg:
- Het aantal rijen en kolommen wordt gespecificeerd met behulp van de variabelen rijen en kolommen. De 2D-array wordt gemaakt met behulp van de nieuwe operator, die geheugen voor de array toewijst. De grootte van de array wordt gespecificeerd door rijen en kolommen.
Directe wijze van aangifte: Syntaxis:
data_type[][] array_name = { {valueR1C1, valueR1C2, ....}, {valueR2C1, valueR2C2, ....} }; For example: int[][] arr = {{1, 2}, {3, 4}};> Voorbeeld:
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]);> >}> }> |
>
>Uitvoer
arr[0][0] = 1 arr[0][1] = 2 arr[1][0] = 3 arr[1][1] = 4>
Toegang tot elementen van tweedimensionale arrays
Elementen in tweedimensionale arrays worden gewoonlijk aangeduid met x[i][j] waarbij ‘i’ het rijnummer is en ‘j’ het kolomnummer.
Syntaxis:
x[row_index][column_index]>
Bijvoorbeeld:
int[][] arr = new int[10][20]; arr[0][0] = 1;>
Het bovenstaande voorbeeld vertegenwoordigt het element dat aanwezig is in de eerste rij en eerste kolom. Opmerking : In arrays als de grootte van de array N is. De index zal van 0 tot N-1 zijn. Daarom is voor rij_index 2 het werkelijke rijnummer 2+1 = 3. Voorbeeld:
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>]);> >}> }> |
>
>Uitvoer
.net-tutorial
arr[0][0] = 1>
Weergave van 2D-array in tabelvorm:
Een tweedimensionale array kan worden gezien als een tabel met ‘x’ rijen en ‘y’ kolommen, waarbij het rijnummer varieert van 0 tot (x-1) en het kolomnummer varieert van 0 tot (y-1). Hieronder wordt een tweedimensionale array ‘x’ met 3 rijen en 3 kolommen weergegeven:
Print 2D-array in tabelvorm:
Om alle elementen van een tweedimensionale array uit te voeren, gebruikt u geneste for-lussen. Hiervoor zijn twee for-lussen nodig: één om de rijen te doorkruisen en één om de kolommen te doorkruisen.
Voorbeeld:
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();> >}> >}> }> |
>
>Uitvoer
1 2 3 4>
Voorbeeld: Implementatie van 2D-array met gebruikersinvoer
Java
jdbc jdbc
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(); } }> |
>
>
Uitvoer
Enter number of rows: 3 Enter number of columns: 3 1 2 3 2 4 6 3 6 9>
- Deze code vraagt de gebruiker om het aantal rijen en kolommen voor de tweedimensionale array in te voeren. De klasse Scanner wordt gebruikt om de gebruikersinvoer te lezen. Vervolgens wordt er een tweedimensionale array van gehele getallen gemaakt met het opgegeven aantal rijen en kolommen, en wordt aan elk element van de array een i*j toegewezen.
- Als u een multidimensionale array met meer dan twee dimensies wilt maken, kunt u dezelfde aanpak gebruiken voor het maken van een array met arrays. Als u bijvoorbeeld een driedimensionale array wilt maken, kunt u een array van tweedimensionale arrays maken.
Driedimensionale array (3D-array)
Driedimensionale array is een complexe vorm van een multidimensionale array. Voor een beter begrip kan een driedimensionale array worden gezien als een array van tweedimensionale arrays.
Indirecte wijze van aangifte:
- Verklaring – Syntaxis:
data_type[][][] array_name = new data_type[x][y][z]; For example: int[][][] arr = new int[10][20][30];>
- Initialisatie – Syntaxis:
array_name[array_index][row_index][column_index] = value; For example: arr[0][0][0] = 1;>
Voorbeeld:
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>]);> >}> }> |
>
>Uitvoer
arr[0][0][0] = 1>
Directe wijze van aangifte: Syntaxis:
data_type[][][] array_name = { { {valueA1R1C1, valueA1R1C2, ....}, {valueA1R2C1, valueA1R2C2, ....} }, { {valueA2R1C1, valueA2R1C2, ....}, {valueA2R2C1, valueA2R2C2, ....} } }; For example: int[][][] arr = { {{1, 2}, {3, 4}}, {{5, 6}, {7, 8}} };> Voorbeeld:
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]);> >}> }> |
>
>
b+ bomenUitvoer
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>
Toegang tot elementen van driedimensionale arrays
Elementen in driedimensionale arrays worden gewoonlijk aangeduid met x[i][j][k] waarbij ‘i’ het arraynummer is, ‘j’ het rijnummer en ‘k’ het kolomnummer is.
Syntaxis:
x[array_index][row_index][column_index]>
Bijvoorbeeld:
int[][][] arr = new int[10][20][30]; arr[0][0][0] = 1;>
Het bovenstaande voorbeeld vertegenwoordigt het element dat aanwezig is in de eerste rij en eerste kolom van de eerste array in de gedeclareerde 3D-array.
Opmerking : In arrays als de grootte van de array N is. De index zal van 0 tot N-1 zijn. Voor rij_index 2 is het werkelijke rijnummer daarom 2+1 = 3.
Voorbeeld:
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>]);> >}> }> |
>
>Uitvoer
arr[0][0][0] = 1>
Weergave van 3D-array in tabelvorm:
Een driedimensionale array kan worden gezien als een tabel met arrays met ‘x’ rijen en ‘y’ kolommen, waarbij het rijnummer varieert van 0 tot (x-1) en het kolomnummer varieert van 0 tot (y-1). Hieronder wordt een driedimensionale array met 3 arrays met 3 rijen en 3 kolommen weergegeven:
Print 3D-array in tabelvorm:
Om alle elementen van een driedimensionale array uit te voeren, gebruikt u geneste for-lussen. Hiervoor zijn drie for-lussen nodig: één om de arrays te doorkruisen, de tweede om de rijen te doorkruisen en een andere om de kolommen te doorkruisen.
Voorbeeld:
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();> >}> >}> }> |
>
>Uitvoer
1 2 3 4 5 6 7 8>
Een multidimensionale array invoegen tijdens runtime:
Dit onderwerp is geforceerd om door de gebruiker gedefinieerde invoer tijdens runtime in een multidimensionale array op te nemen. Het is erop gericht dat de gebruiker eerst alle invoer aan het programma geeft tijdens de runtime en dat het programma na alle ingevoerde invoer dienovereenkomstig uitvoer zal geven met betrekking tot elke invoer. Het is handig wanneer de gebruiker eerst invoer wil maken voor meerdere testgevallen met meerdere verschillende waarden en nadat al deze dingen zijn gedaan, het programma output zal gaan leveren. Laten we als voorbeeld het totale aantal even en oneven getallen in een invoerarray vinden. Hier zullen we het concept van een tweedimensionale array gebruiken.
Hier zijn een paar punten die het gebruik van de verschillende elementen in de komende code verklaren:
- Het gehele getal van de rij wordt beschouwd als het aantal testgevallen en de kolomwaarden worden beschouwd als waarden in elke testgeval.
- Eén for()-lus wordt gebruikt voor het bijwerken van het Test-Case-nummer en een andere for()-lus wordt gebruikt voor het nemen van respectieve arraywaarden.
- Nadat alle invoer is voltooid, worden opnieuw twee for()-lussen op dezelfde manier gebruikt om het programma uit te voeren volgens de opgegeven voorwaarde.
- De eerste invoerregel is het totale aantal TestCases.
- De tweede regel toont het totale aantal eerste arraywaarden.
- De derde regel geeft arraywaarden enzovoort.
Implementatie:
js onload
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.> |
>
>
Uitgang:
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>