Przykłady na tablice

src/p11_tablice/A_Wprowadzenie.java

+package p11_tablice;
+
+import java.util.Arrays;
+
+public class A_Wprowadzenie {
+
+	public static void main(String[] args) {
+		// Gdy potrzebujemy zapamiętać wiele wartości tego samego typu to niby możemy utworzyć wiele zmiennych:
+		String miasto1, miasto2, miasto3;
+		miasto1 = "Warszawa";
+		miasto2 = "Kraków";
+		miasto3 = "Poznań";
+		
+		System.out.println("Miasto nr 1: " + miasto1);
+		System.out.println("Miasto nr 2: " + miasto2);
+		System.out.println("Miasto nr 3: " + miasto3);
+		System.out.println();
+		
+		// Takie podejście ma jednak co najmniej 2 wady:
+		// 1) nie skaluje się - to jest dobre dla kilku wartości, ale nie tysięcy lub więcej
+		// 2) do każdej zmiennej trzeba odwoływać się niezależnie i nie ma jak napisać operacji "dla wszystkich elementów na raz"
+
+		// W takich sytuacjach używa się tablic lub kolekcji.
+		// Tablice są rozwiązaniem bardziej podstawowym, są elementem języka;
+		// kolekcje (np. listy) to są klasy, których się używa pisząc odp. operacje
+
+		// Deklarujemy zmienną typu "tablica Stringów" i wpisujemy do niej tablicę rozmiaru 10.
+		String[] miasta = new String[10];
+		
+		// Do pojedynczych elementów tablicy można odwoływać się za pomocą tablica[numer] i korzystać podobnie jak ze zwykłych zmiennych:
+		miasta[1] = "Warszawa";
+		miasta[2] = "Kraków";
+		miasta[3] = "Poznań";
+		
+		System.out.println("Drugim miastem jest " + miasta[2]);
+		
+		// Numer pozycji można przekazać w zmiennej:
+		int pozycja = 3;
+		System.out.println("Miasto nr " + pozycja + " to " + miasta[pozycja]);
+		System.out.println();
+		
+		// Ale dla tablic możliwe jest też wykonywanie operacji "dla wszystkich elementów"
+		// albo za pomocą pętli, albo dedykowanych metod.
+		
+		// Jak wypisać cała tablicę?
+		// Próba użycia zwykłego print:
+		System.out.println(miasta);
+		
+		// Ale można użyć operacji Arrays.toString
+		System.out.println(Arrays.toString(miasta));
+		System.out.println();
+		
+		// Przy okazji widzimy, że:
+		// * pozycje w tablicy są numerowane od 0 do rozmiar-1
+		// * w miejscach, gdzie nie wpisaliśmy żadnej wartości, mamy null
+		
+		// Próba dostępu do elementu poza zakresem (czyli tu poza zakresem od 0 do 9) kończy się wyjątkiem:
+		//EXN System.out.println(miasta[20]);
+		//EXN miasta[10] = "Żyrardów";
+	}
+
+}

src/p11_tablice/B_Tworzenie.java

+package p11_tablice;
+
+import java.util.Arrays;
+
+public class B_Tworzenie {
+	
+	public static void main(String[] args) {
+		int[] a;
+		// tylko deklaracja zmiennej, zmienna jest niezainicjowana
+
+// Poniższe linie się nie kompilują:
+//		System.out.println(a);
+//		System.out.println(a[1]);		
+//		a[1] = 10;  // to jest tak naprawdę ODCZYT zmiennej a (bo a jest referencją)
+//		System.out.println(a[1]);
+		
+		a = null;
+		System.out.println(a);
+		
+		int rozmiar = 10;
+		// utworzenie tablicy i wpisanie do zmiennej a
+		// Tak tworzona tablica ma określony rozmiar i jest inicjalizaowana wartościami null, 0 lub false
+		a = new int[rozmiar];
+		
+		a[1] = 133;
+		a[3] = 150;
+		System.out.println(Arrays.toString(a));
+		
+		// Istniejącej tablicy nie da się rozszerzać, można najwyżej utworzyć nową tablicę i wpisać na dotychczasową zmienną - ale to będzie utrata danych.
+		// do zmiennej a można wpisać inną (np. nową) tablicę - dotychczasowa jest zapominana
+		a = new int[2*rozmiar];
+		System.out.println(Arrays.toString(a));
+		System.out.println();
+
+		// można deklaracje i inicjalizacje zapisać w jednej linii:
+		double[] wspolrzedne = new double[3];
+		System.out.println(Arrays.toString(wspolrzedne));
+		
+		// takiej składni nie ma w Javie
+		//NK int[20] c;
+		//NK int c[20];
+		
+		// to jest poprawna składnia:
+		int d[] = new int[13];
+		
+		int d1[], d2[], d3;
+		d1 = new int[1];
+		d3 = 15;
+		
+		
+		// Tablic, ani innych obiektów, się w Javie nie usuwa z pamięci - Java robi to automatycznie.
+		// long[] duza = new long[1000000000]; // OutOfMemory
+
+		// Można też tworzyć tablice od razu podając ich zawartość:
+		int piecdziesiat = 50;
+		
+		// deklaracje nowych zmiennych:
+		// mogę użyć najkrótszej składni: nawiasy klamrowe i wartości w środku,
+		int[] e = {10, 20, 30, 40, piecdziesiat};
+		int[] f = {10, 20, 30, 40, piecdziesiat, 60, };
+		
+		// mogę też użyć składni new int[] {elementy}
+		int[] g = new int[] {10, 20, 30, 40, 50};
+		
+		
+		// Jeśli to już nie jest deklaracja nowej zmiennej, tylko przypisanie do starej zmiennej lub inne sytuacje
+		// to nie mogę już używać najkrótszej składni
+		// f = {44, 55, 66, 77, 88};
+		
+		// tylko muszę pisać new
+		f = new int[] {44, 55, 66, 77};
+		
+		int wynik = suma(e);
+		System.out.println(wynik);
+		
+		// tej składni można też użyć, gdy tablica jest parametrem funkcji
+		wynik = suma(new int[] {1,3,5,7});
+		System.out.println(wynik);
+		
+		// wynik = suma({1,3,5,7});
+		// System.out.println(wynik);
+		
+		// Tablice utworzone za pomocą {} też można modyfikować.
+		// Zarówno zawartość, jak i same zmienne
+		System.out.println(e); // [I@6d06d69c
+		System.out.println(Arrays.toString(e)); // zawartość
+		e[1] = 24;
+		e[2]++;
+		System.out.println(Arrays.toString(e));
+		
+		e = new int[5];  // zmienna e wskazuje na inną tablicę
+		System.out.println(Arrays.toString(e));
+		
+		// Tablic się nie usuwa - zajmuje się tym tzw. "garbage collector" (GC), który działa automatycznie w maszynie wirtualnej Javy (JVM)
+	}
+
+	static int suma(int[] a) {
+		int suma =0;
+		for (int x : a) {
+			suma += x;
+		}
+		return suma;
+	}
+}

src/p11_tablice/C_Petle.java

+package p11_tablice;
+
+import java.util.Arrays;
+
+public class C_Petle {
+
+	public static void main(String[] args) {
+		String[] miasta = {"Warszawa", "Kraków", "Łódź", "Wrocław", "Poznań"};
+		int[] liczby = {0, 10, 20, 30, 40, 50, 60, 70, 80, 90};
+		
+		System.out.println(Arrays.toString(miasta));
+		System.out.println(Arrays.toString(liczby));
+		System.out.println();
+		
+		// Są dwa sposoby wykonywania czynności dla wszystkich elementów tablicy:
+		// 1) Tradycyjna pętla for / for z licznikiem
+		for(int i = 0; i < miasta.length; i++) {
+			System.out.println("! " + miasta[i]);
+		}
+		System.out.println();
+		
+		for(int i = 0; i < liczby.length; i++) {
+			System.out.print(liczby[i] + "; ");
+		}
+		System.out.println();
+		System.out.println();
+		
+		// 2) Pętla "for-each" / "enhanced for loop"
+		// Bezpośrednio przeglądamy elementy tablicy/kolekcji. Są one po kolei wpisywane na nową zmienną.
+		for(String miasto : miasta) {
+			System.out.println("* " + miasto);
+		}
+		System.out.println();
+		
+		// zwróćmy uwagę, że to są elementy tablicy, a nie indeksy (pozycje)
+		for(int liczba : liczby) {
+			System.out.print(liczba + ", ");
+		}
+		System.out.println();
+		System.out.println();
+		System.out.println();
+		
+
+		// Pętla for-each nie nadaje się do modyfikowania zawartości tablicy.
+		System.out.println(Arrays.toString(liczby));
+		System.out.println();
+		System.out.println("w pętli for-each próbuję zmieniać wartości...");
+		for (int x : liczby) {
+			x++;
+			// modyfikowanie zmiennej w for-each nie wpływa na zawartość tablicy
+			// w x mamy kopię wartości, a nie "referencję do miejsca w tablicy"
+		}
+		System.out.println();
+		System.out.println(Arrays.toString(liczby)); // liczby się nie zmieniły
+		System.out.println();
+		
+		// Jeśli chcemy modyfikować elementy tablicy, to w praktyce uzywamy tradycyjnej pętli for
+		System.out.println("w zwykłym for zmieniam wartości");
+		for (int i = 0; i < liczby.length; i++) {
+			System.out.println(liczby[i] + " -> " + (liczby[i]+1));
+			liczby[i]++;
+		}
+		System.out.println(Arrays.toString(liczby));
+
+		// Zwykłe pętli for używamy też wtedy, gdy algorytm wymaga jednoczesnego dostępu do różnych elementów.
+	}
+
+}

src/p11_tablice/D_Dwuwymiarowe.java

+package p11_tablice;
+
+import java.util.Arrays;
+
+public class D_Dwuwymiarowe {
+
+	public static void main(String[] args) {
+		// Tablice wielowymiarowe... To tak naprawdę tablice tablic.
+		// Tutaj powstanie 3-elementowa tablica, której elementami są tablice typu int[]
+		// z których każda ma 5 elementów int.
+		int[][] a = new int[3][5];
+		//NK int[][] a2 = new int[3,5];
+		
+		System.out.println(a.length); // 3
+		System.out.println(a[0].length); // 5
+		System.out.println();
+		
+		// regularna macierz
+		a[0][4] = 44;
+		a[1][2] = 22;
+		
+		System.out.println(a[0][4]);
+		System.out.println("a: " + a + " , zawartość: " + Arrays.toString(a));
+		System.out.println("a[0]: " + a[0]+ " , zawartość: " + Arrays.toString(a[0]));
+		System.out.println();
+		
+		System.out.println(Arrays.toString(a));
+		System.out.println(Arrays.deepToString(a));
+		System.out.println();
+		
+		
+		// Można nie wypełniać od razu wierszy jednakowymi tablicami,
+		// ale początkowo zostawić null-e i dopiero potem wpisać poszczególne wiersz.
+		// Wtedy mogą być one nawet różnej długości.
+		
+		int[][] b = new int[4][];
+		System.out.println(Arrays.toString(b));
+		
+		// inicjujemy poszczególne wiersze
+		b[0] = new int[7];
+		Arrays.fill(b[0], 9);
+		b[1] = new int[] {3, 4, 5};
+		b[2] = null;
+		b[3] = new int[0]; // pusta tablica i null to są różne rzeczy
+		System.out.println(Arrays.deepToString(b));
+		
+		// Można użyć notacji {} także do wypełniania tablic wielowymiarowych.
+		String[][] c = {
+				{"Ala", "Ola", "Ela"},
+				{"Jacek", "Placek"},
+				null,
+				{},
+		};
+		
+		System.out.println(Arrays.deepToString(c));
+	}
+
+}