Masīva pamati Java Daudzdimensiju masīvi var definēt vienkāršos vārdos kā masīvu masīvu. Dati daudzdimensiju masīvos tiek glabāti tabulas veidā (rindas galvenajā secībā).
Sintakse:
datu tips [1. dimensija][2. dimensija][]..[Nth dimensija] masīva_nosaukums = jauns datu_veids [izmērs1][izmērs2]…[izmērsN];
kur:
- datu tips : masīvā saglabājamo datu veids. Piemēram: int, char utt.
- dimensiju : izveidotā masīva dimensija. Piemēram: 1D, 2D utt.
- masīva_nosaukums : masīva nosaukums
- izmērs1, izmērs2, …, izmērsN : attiecīgi izmēru izmēri.
Piemēri:
Two dimensional array: int[][] twoD_arr = new int[10][20]; Three dimensional array: int[][][] threeD_arr = new int[10][20][30];>
Daudzdimensiju masīvu lielums : kopējo elementu skaitu, ko var saglabāt daudzdimensiju masīvā, var aprēķināt, reizinot visu izmēru lielumu.
Piemēram: Masīvs int[][] x = jauns int[10][20] kopā var uzglabāt (10*20) = 200 elementus. Tāpat masīvs int[][][] x = jauns int[5][10][20] var uzglabāt kopā (5*10*20) = 1000 elementu.
Daudzdimensiju masīva pielietojums
● Datu glabāšanai tabulas veidā tiek izmantoti daudzdimensiju masīvi. Piemēram, studenta ruļļa numura un atzīmju saglabāšanu var viegli veikt, izmantojot daudzdimensiju masīvus. Vēl viens izplatīts lietojums ir attēlu glabāšana 3D masīvos.
● Dinamiskās programmēšanas jautājumos tiek izmantoti daudzdimensiju masīvi, kas tiek izmantoti, lai attēlotu problēmas stāvokļus.
● Papildus šiem tiem ir arī pielietojumi daudzās standarta algoritmiskās problēmās, piemēram: matricas reizināšana, blakus matricas attēlošana grafikos, režģa meklēšanas problēmas.
Divdimensiju masīvs (2D masīvs)
Divdimensiju masīvs ir vienkāršākā daudzdimensiju masīva forma. Divdimensiju masīvu var uzskatīt par viendimensiju masīvu vieglākai izpratnei.
Netiešā deklarēšanas metode:
- Deklarācija — sintakse:
data_type[][] array_name = new data_type[x][y]; For example: int[][] arr = new int[10][20];>
- Inicializācija — sintakse:
array_name[row_index][column_index] = value; For example: arr[0][0] = 1;>
Piemērs: 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>]);> >}> }> |
>
>Izvade
izņēmumu apstrāde java
arr[0][0] = 1>
Piemērs: 2D masīva ieviešana ar noklusējuma vērtībām ar 4*4 matricu
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(); } } }> |
>
>Izvade
The 2D array is: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16>
Paskaidrojums:
- Rindu un kolonnu skaits tiek norādīts, izmantojot mainīgos rindas un kolonnas. 2D masīvs tiek izveidots, izmantojot jauno operatoru, kas piešķir masīvam atmiņu. Masīva lielumu nosaka rindas un kolonnas.
Tiešā deklarēšanas metode: Sintakse:
data_type[][] array_name = { {valueR1C1, valueR1C2, ....}, {valueR2C1, valueR2C2, ....} }; For example: int[][] arr = {{1, 2}, {3, 4}};> Piemērs:
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]);> >}> }> |
>
>Izvade
arr[0][0] = 1 arr[0][1] = 2 arr[1][0] = 3 arr[1][1] = 4>
Piekļuve divdimensiju masīvu elementiem
Elementus divdimensiju masīvos parasti apzīmē ar x[i][j] kur “i” ir rindas numurs un “j” ir kolonnas numurs.
Sintakse:
x[row_index][column_index]>
Piemēram:
int[][] arr = new int[10][20]; arr[0][0] = 1;>
Iepriekš minētais piemērs attēlo elementu, kas atrodas pirmajā rindā un pirmajā kolonnā. Piezīme : masīvos, ja masīva lielums ir N. Tā indekss būs no 0 līdz N-1. Tāpēc rindas_indeksam 2 faktiskais rindas numurs ir 2+1 = 3. Piemērs:
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>]);> >}> }> |
>
>Izvade
arr[0][0] = 1>
2D masīva attēlojums tabulas formātā:
Divdimensiju masīvu var uzskatīt par tabulu ar “x” rindām un “y” kolonnām, kur rindas numurs ir no 0 līdz (x-1) un kolonnas numurs ir no 0 līdz (y-1). Tālāk ir parādīts divdimensiju masīvs “x” ar 3 rindām un 3 kolonnām:
Drukāt 2D masīvu tabulas formātā:
Lai izvadītu visus divdimensiju masīva elementus, izmantojiet ligzdotas cilpas. Šim nolūkam ir nepieciešamas divas cilpas, viena, lai šķērsotu rindas, un otra, lai šķērsotu kolonnas.
Piemērs:
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();> >}> >}> }> |
>
>Izvade
1 2 3 4>
Piemērs: 2D masīva ieviešana ar lietotāja ievadi
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(); } }> |
>
>
Izvade
Enter number of rows: 3 Enter number of columns: 3 1 2 3 2 4 6 3 6 9>
- Šis kods liek lietotājam ievadīt rindu un kolonnu skaitu 2-dimensiju masīvam. Skenera klase tiek izmantota, lai lasītu lietotāja ievadīto informāciju. Pēc tam tiek izveidots 2-dimensiju veselu skaitļu masīvs ar norādīto rindu un kolonnu skaitu un katram masīva elementam tiek piešķirts i*j.
- Ja vēlaties izveidot daudzdimensiju masīvu ar vairāk nekā divām dimensijām, varat izmantot to pašu pieeju, lai izveidotu masīvu masīvu. Piemēram, lai izveidotu 3 dimensiju masīvu, varat izveidot 2 dimensiju masīvu masīvu.
Trīsdimensiju masīvs (3D masīvs)
Trīsdimensiju masīvs ir daudzdimensiju masīva sarežģīta forma. Trīsdimensiju masīvu var uzskatīt par divdimensiju masīvu vieglākai izpratnei.
Netiešā deklarēšanas metode:
- Deklarācija — sintakse:
data_type[][][] array_name = new data_type[x][y][z]; For example: int[][][] arr = new int[10][20][30];>
- Inicializācija — sintakse:
array_name[array_index][row_index][column_index] = value; For example: arr[0][0][0] = 1;>
Piemērs:
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>]);> >}> }> |
>
>Izvade
arr[0][0][0] = 1>
Tiešā deklarēšanas metode: Sintakse:
data_type[][][] array_name = { { {valueA1R1C1, valueA1R1C2, ....}, {valueA1R2C1, valueA1R2C2, ....} }, { {valueA2R1C1, valueA2R1C2, ....}, {valueA2R2C1, valueA2R2C2, ....} } }; For example: int[][][] arr = { {{1, 2}, {3, 4}}, {{5, 6}, {7, 8}} };> Piemērs:
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]);> >}> }> |
>
>Izvade
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>
Piekļuve trīsdimensiju masīvu elementiem
Elementus trīsdimensiju masīvos parasti apzīmē ar x[i][j][k] kur “i” ir masīva numurs, “j” ir rindas numurs un “k” ir kolonnas numurs.
Sintakse:
x[array_index][row_index][column_index]>
Piemēram:
int[][][] arr = new int[10][20][30]; arr[0][0][0] = 1;>
Iepriekš minētais piemērs attēlo elementu, kas atrodas deklarētā 3D masīva pirmā masīva pirmajā rindā un pirmajā kolonnā.
Piezīme : masīvos, ja masīva lielums ir N. Tā indekss būs no 0 līdz N-1. Tāpēc rindas_indeksam 2 faktiskais rindas numurs ir 2+1 = 3.
Piemērs:
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>]);> >}> }> |
>
>Izvade
arr[0][0][0] = 1>
3D masīva attēlojums tabulas formātā:
Trīsdimensiju masīvu var uzskatīt par masīvu tabulu ar “x” rindām un “y” kolonnām, kur rindas numurs ir no 0 līdz (x-1) un kolonnas numurs ir no 0 līdz (y-1). Tālāk ir parādīts trīsdimensiju masīvs ar 3 masīviem, kas satur 3 rindas un 3 kolonnas:
Drukāt 3D masīvu tabulas formātā:
Lai izvadītu visus trīsdimensiju masīva elementus, izmantojiet ligzdotas cilpas. Šim nolūkam ir nepieciešamas trīs cilpas, viena, lai šķērsotu masīvus, otra, lai šķērsotu rindas un vēl viena, lai šķērsotu kolonnas.
Piemērs:
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();> >}> >}> }> |
>
>Izvade
1 2 3 4 5 6 7 8>
Daudzdimensiju masīva ievietošana izpildlaikā:
Šī tēma izpildlaikā ir spiesta izmantot lietotāja definētu ievadi daudzdimensiju masīvā. Tas ir vērsts uz to, lai lietotājs izpildlaika laikā vispirms sniegtu visu programmas ievadi, un pēc visas ievadītās ievades programma attiecīgi dos izvadi attiecībā uz katru ievadi. Tas ir noderīgi, ja lietotājs vispirms vēlas ievadīt vairākus testa gadījumus ar vairākām atšķirīgām vērtībām, un pēc visu šo darbību veikšanas programma sāks nodrošināt izvadi. Piemēram, atradīsim kopējo pāra un nepāra skaitļu skaitu ievades masīvā. Šeit mēs izmantosim 2-dimensiju masīva jēdzienu.
Šeit ir daži punkti, kas izskaidro dažādu elementu izmantošanu gaidāmajā kodā:
- Rindas vesels skaitlis tiek uzskatīts par pārbaudes gadījumu skaitu, un kolonnas vērtības tiek uzskatītas par vērtībām katrā testa gadījumā.
- Viena for() cilpa tiek izmantota testa gadījuma numura atjaunināšanai, bet cita for() cilpa tiek izmantota attiecīgo masīva vērtību iegūšanai.
- Kad viss ievades ieraksts ir izdarīts, atkal divas for() cilpas tiek izmantotas tādā pašā veidā, lai izpildītu programmu atbilstoši norādītajam nosacījumam.
- Pirmā ievades rinda ir kopējais TestCases skaits.
- Otrajā rindā ir parādīts kopējais pirmā masīva vērtību skaits.
- Trešā rinda sniedz masīva vērtības un tā tālāk.
Īstenošana:
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.> |
>
>
Izvade:
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>