Podstawy tablic 2D i zagnieżdżona iteracja
Poznają Państwo tablice 2D (dopuszczalne są tablice postrzępione), różnice między wierszami i kolumnami, m.length i m[0].length oraz iterację za pomocą zagnieżdżonych pętli for.
Podstawy tablic 2D i zagnieżdżona iteracja to bezpłatna lekcja Java Academy na CoddyKit. To lekcja 1 z 6. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Java Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Java Academy zawiera 6 lekcji w sumie.
Czym jest tablica 2D?
Tablica 2D to tablica tablic. Może być prostokątna lub nieregularna (wiersze mogą mieć różne długości).
Deklarowanie i tworzenie
Deklarowanie i tworzenie:
public class Main {
public static void main(String[] args) {
// Way 1: Create a 2D array with fixed size
int[][] a = new int[2][3];
// 2 rows, 3 columns → default values = 0
// [
// [0, 0, 0],
// [0, 0, 0]
// ]
// Way 2: Create and initialize directly
int[][] b = {
{1, 2, 3},
{4, 5, 6}
};
// [
// [1, 2, 3],
// [4, 5, 6]
// ]
// Print array a
System.out.println("Array a:");
for (int i = 0; i < a.length; i++) {
for (int j = 0; j < a[i].length; j++) {
System.out.print(a[i][j] + " ");
}
System.out.println();
}
// Print array b
System.out.println("Array b:");
for (int i = 0; i < b.length; i++) {
for (int j = 0; j < b[i].length; j++) {
System.out.print(b[i][j] + " ");
}
System.out.println();
}
}
}
Wiersze a kolumny
Wiersze: m.length. Kolumny (pierwszy wiersz): m[0].length. Należy uważać na nieregularne wiersze i sprawdzać długość każdego z nich.
Iteracja zagnieżdżona
Użyj zagnieżdżonych pętli, aby odwiedzić wszystkie elementy:
public class Main {
public static void main(String[] args) {
// Example 2D array (matrix)
int[][] m = {
{1, 2, 3},
{4, 5, 6}
};
// Loop over rows
for (int r = 0; r < m.length; r = r + 1) {
// Loop over columns in the current row
for (int c = 0; c < m[r].length; c = c + 1) {
int value = m[r][c]; // get element at row r, column c
System.out.print(value + " "); // work: here we print
}
System.out.println(); // move to next row
}
}
}
Sumy wierszy i kolumn
Oblicz sumy:
public class Main {
public static void main(String[] args) {
// Example 2D array (matrix)
int[][] m = {
{1, 2, 3},
{4, 5, 6},
{7, 8, 9}
};
// Sum of row 1 (second row, index = 1)
int rowSum = 0;
for (int c = 0; c < m[1].length; c = c + 1) {
rowSum = rowSum + m[1][c];
}
System.out.println("Sum of row 1 = " + rowSum);
// Sum of column 2 (third column, index = 2)
int colSum = 0;
for (int r = 0; r < m.length; r = r + 1) {
colSum = colSum + m[r][2];
}
System.out.println("Sum of column 2 = " + colSum);
}
}
Demonstracja tablicy 2D
Uruchom program: Zobacz wypisane sumy całkowite i sumy poszczególnych wierszy.
public class Main {
static int total(int[][] m) {
int s = 0;
for (int r = 0; r < m.length; r = r + 1) {
for (int c = 0; c < m[r].length; c = c + 1) {
s = s + m[r][c];
}
}
return s;
}
static int[] rowSums(int[][] m) {
int[] sums = new int[m.length];
for (int r = 0; r < m.length; r = r + 1) {
int s = 0;
for (int c = 0; c < m[r].length; c = c + 1) s = s + m[r][c];
sums[r] = s;
}
return sums;
}
static String join(int[] a) {
String s = "";
for (int i = 0; i < a.length; i = i + 1) {
s = s + a[i] + (i + 1 < a.length ? " " : "");
}
return s;
}
public static void main(String[] args) {
int[][] m = {
{1, 2, 3},
{4, 5, 6}
};
System.out.println("rows = " + m.length);
System.out.println("cols of row 0 = " + m[0].length);
System.out.println("total = " + total(m));
int[] rs = rowSums(m);
System.out.println("row sums = " + join(rs));
}
}
Liczba kolumn
Szybkie sprawdzenie: Dla int[][] m = {{1,2,3},{4,5,6}} ile kolumn znajduje się w pierwszym wierszu?
Podsumowanie i następny krok
Podsumowanie: Zadeklarowali Państwo tablice 2D, iterowali za pomocą zagnieżdżonych pętli i obliczali sumy całkowite.
Następny krok: Przećwiczmy tablice nieregularne i formatowanie tabel.
Często zadawane pytania
Czy lekcja „Podstawy tablic 2D i zagnieżdżona iteracja” jest bezpłatna?
Tak — pełny tekst „Podstawy tablic 2D i zagnieżdżona iteracja” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Java Academy, przejdź na CoddyKit PRO. Kurs Java Academy zawiera 6 lekcji w sumie.
Co nauczysz się w „Podstawy tablic 2D i zagnieżdżona iteracja”?
Poznają Państwo tablice 2D (dopuszczalne są tablice postrzępione), różnice między wierszami i kolumnami, m.length i m[0].length oraz iterację za pomocą zagnieżdżonych pętli for. Ćwiczysz Java Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.
Czy potrzebuję doświadczenia, aby zacząć Java Academy?
Nie wymagamy żadnego doświadczenia. Java Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 1 z 6.
Ile czasu zajmuje lekcja „Podstawy tablic 2D i zagnieżdżona iteracja”?
Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.
Czy mogę pisać i uruchamiać kod w tej lekcji Java Academy?
Tak. Każda lekcja Java Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.
Wszystkie lekcje w tym kursie
- Podstawy tablic 2D i zagnieżdżona iteracja
- Tablice postrzępione i formatowanie tabel
- Maksima wierszy i kolumn, transpozycja i formatowanie
- Projekt 2D: dziennik ocen
- Narzędzia 2D jako klasa pomocnicza (refaktoryzacja)
- Czyszczenie i walidacja danych 2D