Podstawy tablic w Javie Tablice wielowymiarowe można zdefiniować prostymi słowami jako tablicę tablic. Dane w tablicach wielowymiarowych przechowywane są w formie tabelarycznej (w kolejności głównych wierszy).
Składnia:
typ danych [1. wymiar] [2. wymiar] []..[N-ty wymiar] nazwa_tablicy = nowy typ_danych [rozmiar1] [rozmiar2]….[rozmiarN];
Gdzie:
- typ danych : Typ danych, które mają być przechowywane w tablicy. Na przykład: int, char itp.
- wymiar : Wymiar utworzonej tablicy. Na przykład: 1D, 2D itp.
- nazwa_tablicy : Nazwa tablicy
- rozmiar1, rozmiar2, …, rozmiarN : Rozmiary wymiarów odpowiednio.
Przykłady:
Two dimensional array: int[][] twoD_arr = new int[10][20]; Three dimensional array: int[][][] threeD_arr = new int[10][20][30];>
Rozmiar tablic wielowymiarowych : Całkowitą liczbę elementów, które można przechowywać w tablicy wielowymiarowej, można obliczyć, mnożąc rozmiar wszystkich wymiarów.
Na przykład: Tablica int[][] x = nowa int[10][20] może przechowywać łącznie (10*20) = 200 elementów. Podobnie tablica int[][][] x = nowa int[5] [10] [20] może przechowywać łącznie (5*10*20) = 1000 elementów.
Zastosowanie tablicy wielowymiarowej
● Tablice wielowymiarowe służą do przechowywania danych w formie tabelarycznej. Na przykład przechowywanie numeru rolki i ocen ucznia można łatwo wykonać za pomocą tablic wielowymiarowych. Innym powszechnym zastosowaniem jest przechowywanie obrazów w tablicach 3D.
● W pytaniach związanych z programowaniem dynamicznym używane są tablice wielowymiarowe, które służą do reprezentowania stanów problemu.
● Oprócz tego mają one również zastosowanie w wielu standardowych problemach algorytmicznych, takich jak: mnożenie macierzy, reprezentacja macierzy sąsiedztwa na wykresach, problemy wyszukiwania w siatce
Dwuwymiarowa tablica (2D-Array)
Tablica dwuwymiarowa jest najprostszą formą tablicy wielowymiarowej. Tablicę dwuwymiarową można postrzegać jako tablicę tablicy jednowymiarowej, dla łatwiejszego zrozumienia.
Pośrednia metoda deklaracji:
- Deklaracja – Składnia:
data_type[][] array_name = new data_type[x][y]; For example: int[][] arr = new int[10][20];>
- Inicjalizacja – Składnia:
array_name[row_index][column_index] = value; For example: arr[0][0] = 1;>
Przykład: 1
Jawa
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>]);> >}> }> |
>
>Wyjście
arr[0][0] = 1>
Przykład: Implementacja tablicy 2D z domyślnymi wartościami w macierzy 4*4
Jawa
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(); } } }> |
>
>Wyjście
The 2D array is: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16>
Wyjaśnienie:
- Liczbę wierszy i kolumn określa się za pomocą zmiennych wierszy i kolumn. Tablica 2D jest tworzona za pomocą operatora new, który przydziela pamięć dla tablicy. Rozmiar tablicy jest określony przez wiersze i kolumny.
Bezpośrednia metoda deklaracji: Składnia:
data_type[][] array_name = { {valueR1C1, valueR1C2, ....}, {valueR2C1, valueR2C2, ....} }; For example: int[][] arr = {{1, 2}, {3, 4}};> Przykład:
Jawa
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]);> >}> }> |
>
>Wyjście
arr[0][0] = 1 arr[0][1] = 2 arr[1][0] = 3 arr[1][1] = 4>
Dostęp do elementów tablic dwuwymiarowych
Elementy w tablicach dwuwymiarowych są powszechnie określane przez x[i]j] gdzie „i” to numer wiersza, a „j” to numer kolumny.
Składnia:
x[row_index][column_index]>
Na przykład:
int[][] arr = new int[10][20]; arr[0][0] = 1;>
Powyższy przykład przedstawia element występujący w pierwszym wierszu i pierwszej kolumnie. Notatka : W tablicach, jeśli rozmiar tablicy wynosi N. Jej indeks będzie wynosić od 0 do N-1. Dlatego dla indeksu_wiersza 2 rzeczywisty numer wiersza to 2+1 = 3. Przykład:
Jawa
ciąg porównaj 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>]);> >}> }> |
>
>Wyjście
arr[0][0] = 1>
Reprezentacja tablicy 2D w formacie tabelarycznym:
Tablicę dwuwymiarową można postrzegać jako tabelę zawierającą wiersze „x” i kolumny „y”, gdzie numer wiersza mieści się w zakresie od 0 do (x-1), a numer kolumny mieści się w zakresie od 0 do (y-1). Poniżej pokazano dwuwymiarową tablicę „x” z 3 wierszami i 3 kolumnami:
Wydrukuj tablicę 2D w formacie tabelarycznym:
Aby wyprowadzić wszystkie elementy tablicy dwuwymiarowej, użyj zagnieżdżonych pętli for. W tym celu wymagane są dwie pętle for, jedna do przechodzenia przez wiersze, a druga do przechodzenia przez kolumny.
Przykład:
Jawa
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();> >}> >}> }> |
>
>Wyjście
1 2 3 4>
Przykład: Implementacja tablicy 2D z danymi wprowadzonymi przez użytkownika
Jawa
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(); } }> |
>
>
Wyjście
Enter number of rows: 3 Enter number of columns: 3 1 2 3 2 4 6 3 6 9>
- Ten kod monituje użytkownika o wprowadzenie liczby wierszy i kolumn tablicy dwuwymiarowej. Klasa Scanner służy do odczytywania danych wejściowych użytkownika. Następnie tworzy dwuwymiarową tablicę liczb całkowitych z określoną liczbą wierszy i kolumn i przypisuje każdemu elementowi tablicy znak i*j.
- Jeśli chcesz utworzyć tablicę wielowymiarową zawierającą więcej niż dwa wymiary, możesz zastosować to samo podejście do tworzenia tablicy tablic. Na przykład, aby utworzyć tablicę trójwymiarową, można utworzyć tablicę tablic dwuwymiarowych.
Trójwymiarowa tablica (3D-Array)
Tablica trójwymiarowa jest złożoną formą tablicy wielowymiarowej. Tablicę trójwymiarową można postrzegać jako tablicę tablicy dwuwymiarowej, co ułatwia zrozumienie.
Pośrednia metoda deklaracji:
- Deklaracja – Składnia:
data_type[][][] array_name = new data_type[x][y][z]; For example: int[][][] arr = new int[10][20][30];>
- Inicjalizacja – składnia:
array_name[array_index][row_index][column_index] = value; For example: arr[0][0][0] = 1;>
Przykład:
Jawa
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>]);> >}> }> |
>
>Wyjście
arr[0][0][0] = 1>
Bezpośrednia metoda deklaracji: Składnia:
data_type[][][] array_name = { { {valueA1R1C1, valueA1R1C2, ....}, {valueA1R2C1, valueA1R2C2, ....} }, { {valueA2R1C1, valueA2R1C2, ....}, {valueA2R2C1, valueA2R2C2, ....} } }; For example: int[][][] arr = { {{1, 2}, {3, 4}}, {{5, 6}, {7, 8}} };> Przykład:
Jawa
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]);> >}> }> |
>
>Wyjście
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>
Dostęp do elementów tablic trójwymiarowych
Elementy w tablicach trójwymiarowych są powszechnie określane przez x[i] [j] [k] gdzie „i” to numer tablicy, „j” to numer wiersza, a „k” to numer kolumny.
Składnia:
x[array_index][row_index][column_index]>
Na przykład:
int[][][] arr = new int[10][20][30]; arr[0][0][0] = 1;>
Powyższy przykład reprezentuje element obecny w pierwszym wierszu i pierwszej kolumnie pierwszej tablicy w zadeklarowanej tablicy 3D.
Notatka : W tablicach, jeśli rozmiar tablicy wynosi N. Jej indeks będzie wynosić od 0 do N-1. Dlatego dla indeksu_wiersza 2 rzeczywisty numer wiersza to 2+1 = 3.
Przykład:
Jawa
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>]);> >}> }> |
>
>Wyjście
arr[0][0][0] = 1>
Reprezentacja tablicy 3D w formacie tabelarycznym:
ile klawiszy ma klawiatura
Tablicę trójwymiarową można postrzegać jako tabelę tablic zawierającą wiersze „x” i kolumny „y”, gdzie numer wiersza mieści się w zakresie od 0 do (x-1), a numer kolumny mieści się w zakresie od 0 do (y-1). Poniżej pokazano trójwymiarową tablicę zawierającą 3 tablice zawierające 3 wiersze i 3 kolumny:
Wydrukuj tablicę 3D w formacie tabelarycznym:
Aby wyprowadzić wszystkie elementy tablicy trójwymiarowej, użyj zagnieżdżonych pętli for. W tym celu wymagane są trzy pętle for: jedna do przechodzenia przez tablice, druga do przechodzenia przez wiersze i druga do przechodzenia przez kolumny.
Przykład:
Jawa
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();> >}> >}> }> |
>
>Wyjście
1 2 3 4 5 6 7 8>
Wstawianie tablicy wielowymiarowej w czasie wykonywania:
W tym temacie wymuszone jest pobieranie danych wejściowych zdefiniowanych przez użytkownika do tablicy wielowymiarowej w czasie wykonywania. Koncentruje się na tym, że użytkownik najpierw podaje wszystkie dane wejściowe do programu w czasie wykonywania, a po wprowadzeniu wszystkich danych wejściowych program odpowiednio podaje dane wyjściowe w odniesieniu do każdego wejścia. Jest to przydatne, gdy użytkownik chce najpierw wprowadzić dane wejściowe dla wielu przypadków testowych z wieloma różnymi wartościami, a po wykonaniu wszystkich tych czynności program zacznie dostarczać dane wyjściowe. Na przykład znajdźmy całkowitą liczbę liczb parzystych i nieparzystych w tablicy wejściowej. W tym przypadku użyjemy pojęcia tablicy dwuwymiarowej.
Oto kilka punktów wyjaśniających użycie różnych elementów w nadchodzącym kodzie:
- Liczba całkowita wiersza jest uważana za liczbę przypadków testowych, a wartości kolumn są uważane za wartości w każdym przypadku testowym.
- Jedna pętla for() służy do aktualizowania numeru przypadku testowego, a druga pętla for() służy do pobierania odpowiednich wartości tablicy.
- Po zakończeniu wszystkich wpisów wejściowych ponownie używane są dwie pętle for() w ten sam sposób, aby wykonać program zgodnie z określonym warunkiem.
- Pierwsza linia danych wejściowych to całkowita liczba przypadków testowych.
- Druga linia pokazuje całkowitą liczbę pierwszych wartości tablicy.
- Trzecia linia podaje wartości tablicy i tak dalej.
Realizacja:
Jawa
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.> |
>
>
Wyjście:
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>