Dodatkowe przykłady z tablicami

src/p08_tablice/B_Tworzenie.java

+package p08_tablice;
+
+import java.math.BigDecimal;
+import java.util.Arrays;
+
+public class B_Tworzenie {
+	
+	public static void main(String[] args) {
+		// Gdy tworzymy tablicę podając jej rozmiar,
+		// to jest ona automatycznie wypełniania wartościami:
+		// - 0 dla prostych typów liczbowych (int, long, double)
+		int[] liczby = new int[10];
+		System.out.println(Arrays.toString(liczby));
+		
+		// łatwo wypełnić tablicę jednakowymi elementami
+		Arrays.fill(liczby, 13);
+		System.out.println(Arrays.toString(liczby));
+		
+		// - false dla typu boolean
+		
+		// - null dla wszystkich typów obiektowych, w tym String, Integer, BigDecimal, List ...
+		String[] napisy = new String[5];
+		BigDecimal[] ceny = new BigDecimal[3];
+		
+		System.out.println(napisy);
+		System.out.println(ceny);
+		System.out.println();
+
+		double x = 55.55;
+		// Można też od razu podać listę wartości w nawiasach klamrowych (podczas deklaracji zmiennej tablicowej)
+		// Kompilator Javy sam policzy jaki ma być rozmiar tablicy
+		double[] d = {1.0, 3.14, Math.sqrt(2), liczby[2], x};
+		System.out.println("Tablica d ma rozmiar " + d.length);
+		System.out.println(Arrays.toString(d));
+	}
+
+}

src/p08_tablice/C_Petle.java

+package p08_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/p08_tablice/D_Dwuwymiarowe.java

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

src/p08_tablice/Srednia.java

+package p08_tablice;
+
+import java.util.Arrays;
+import java.util.stream.IntStream;
+
+public class Srednia {
+
+	public static void main(String[] args) {
+		// Mamy przykładową tablicę, np ocen
+		int[] oceny = {5, 4, 4, 3, 4, 3};
+		// Oblicz średnią z liczb, które są w tablicy:
+		
+		// wersja "nieskalowalna", dobra tylko dla kilku elementów
+		double srednia1 = (oceny[0] + oceny[1] + oceny[2] + oceny[3] + oceny[4] + oceny[5]) / 6.0;
+		System.out.println(srednia1);
+		
+		// zamiast wypisywać oceny[0], oceny[1] itd, musimy te składniki dodawać w pętli
+		// Aby mieć miejsce, do którego można dodawać składniki, tworzymy zmienną typu "skarbonka".
+		// W tej wersji stosuję pętlę "for z licznikiem"
+		int suma = 0;
+		for(int i = 0; i < oceny.length; i++) {
+			suma = suma + oceny[i];
+		}
+		// Zarówno suma, jak i length to są inty. Aby wynik obejmował część ułamkową, trzeba sumę zrzutować na double
+		// double srednia2 = (double)suma / oceny.length;
+		// Można też pomnożyć przez 1.0
+		double srednia2 = 1. * suma / oceny.length;
+		System.out.println(srednia2);
+		
+		// ostatnia wersja: zmienna suma od razu będzie typu double,
+		// użyjemy pętli for-each
+		double suma3 = 0;
+		for(int ocena : oceny) {
+			suma3 += ocena;
+		}
+		double srednia3 = suma3 / oceny.length;
+		System.out.println(srednia3);
+		
+		// Istnieją też gotowe rozwiązania, które w Javie oparte są o tzw. "strumienie"
+		double srednia4 = IntStream.of(oceny).average().getAsDouble();
+		System.out.println(srednia4);
+
+		double srednia5 = Arrays.stream(oceny).average().orElse(0);
+		System.out.println(srednia5);
+	}
+
+}