teoria tablic - gotowe przykłady

src/main/java/p07_tablice/A_Wprowadzenie.java

+package p07_tablice;
+
+import java.util.Arrays;
+
+public class A_Wprowadzenie {
+
+	public static void main(String[] args) {
+		// Zamiast tworzyć wiele podobnych zmiennych tego samego typu...:
+		String miasto0 = "Warszawa";
+		String miasto1 = "Kraków";
+		String miasto2 = "Wrocław";
+		String miasto3 = "Poznań";
+		String miasto4 = "Łódź";
+		
+		System.out.println("miasto0 = " + miasto0);
+		
+		// Mając takie zwykłe zmienne, nie ma jak wykonać operacji "dla wszystkich elementów na raz".
+		// Takie podejście "nie skaluje się".
+		
+		// ...Można stworzyć "tablicę":
+		String[] miasta = new String[5];
+		// Początkowo w tak utworzonej tablicy są same nulle albo zera (w zależności od typu)
+		System.out.println("miasta[0] = " + miasta[0]);
+		
+		// Z elementów tablicy można korzystać, jak ze zwykłych zmiennych:
+		miasta[0] = "Warszawa";
+		miasta[1] = "Kraków";
+		miasta[2] = "Wrocław";
+		miasta[3] = "Poznań";
+		miasta[4] = "Łódź";
+
+		System.out.println("miasta[0] = " + miasta[0]);
+		System.out.println();
+		
+		// Ale mając tablicę wartości, można już wykonywać operacje na całej tablicy; na wszystkich elementach
+		// Spróbujmy wypisać tablicę:
+		System.out.println(miasta);
+		// Aby zobaczyć elementy tablicy, najlepiej użyć Arrays.toString(t)
+		System.out.println(Arrays.toString(miasta));
+		
+		miasta[2] = "Bydgoszcz";
+		System.out.println(Arrays.toString(miasta));
+
+		// Tablice w Javie "znają" swoją długość i przechowują ją w polu ".length"
+		System.out.println(miasta.length);
+		// Poprawne indeksy w tablicy to od 0 do length-1
+		// Próba wyjścia poza zakres tablicy kończy się wyjątkiem
+		try {
+			System.out.println(miasta[5]);
+			System.out.println(miasta[-1]);
+		} catch (Exception e) {
+			System.err.println(e);
+		}
+		System.out.println("Ostatni element: " + miasta[miasta.length-1]);
+		System.out.println();
+		
+		// Tablic z pamięci się nie usuwa - zajmuje się tym JVM, a dokładnie "garbage collector" (gc)
+	}
+
+}

src/main/java/p07_tablice/B_Tworzenie.java

+package p07_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);
+		// Teraz próba dostępu do elementu kończy się błędem NPE
+		// System.out.println(a[0]);
+		// System.out.println(a.length);
+		// a[0] = 123;
+		
+		int rozmiar = 10;
+		// utworzenie tablicy i wpisanie do zmiennej a
+		// Tak tworzona tablica ma określony rozmiar i jest inicjalizowana 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/main/java/p07_tablice/C_Petle.java

+package p07_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/main/java/p07_tablice/D_Dwuwymiarowe.java

+package p07_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));
+	}
+
+}