dodatkowe przykłady String i kolekcji

src/main/java/gotowe/p20_string/Mutowalnosc.java

+package gotowe.p20_string;
+
+public class Mutowalnosc {
+
+	public static void main(String[] args) {
+		String a = "Ala";
+		String b = a;
+				
+		a += " ma kota";
+		// tutaj został utworzony nowy obiekt; to działa tak:
+		// a = new String(a + " ma kota");
+		// a zmienna b wskazuje wciąż na stary obiekt "Ala"
+		
+		// Gdy przekazujemy obiekt String jako parametr do metody,
+		// to ta metoda na pewno nie zmodyfikuje tego napisu "w środku"
+		piesek(a);
+
+		System.out.println("a: " + a); // Ala ma kota
+		System.out.println("b: " + b); // Ala
+	}
+	
+	static void piesek(String c) {
+		// tutaj powstaje nowy obiekt, a nie jest modyfikowany ten przekazany w parametrze
+		c += ", ma też psa";
+		System.out.println("c: " + c); // Ala ma kota, ma też psa
+	}
+	
+	// Klasa String jest "niemutowalna" / "immutable"
+	// Obiekty String nigdy nie zmieniają swojego stanu.
+
+}

src/main/java/gotowe/p20_string/Porownywanie.java

+package gotowe.p20_string;
+
+import java.util.Objects;
+
+public class Porownywanie {
+
+	public static void main(String[] args) {
+		String ala = "Ala";
+		final String final_ala = "Ala";
+		
+		String a = "Ala ma kota";
+		String b = "Ala ma kota";
+		String c = "Ala" + " ma kota";
+		String d = final_ala + " ma kota";
+		//String e = InnaKlasa.dajStringaZKodu();
+		// ↑ Do tych zmiennych wpisywany jest adres tego samego obiektu String.
+		// Jest to optymalizacja wykonywana przez kompilator Javy (i JVM - tzw. "pula stałych") 
+		
+		String f = new String(a);
+		String g = ala + " ma kota";
+		// Do f i g wpisywane są nowe obiekty, które są pod innym adresem w pamięci, niż a
+		// tak samo jest dla danych wczytywanych z zewnętrznych źródeł: konsola, plik, baza danych
+		
+		// wszystkie zmienne od a do g zawierają ten sam tekst
+		System.out.println(a);
+		System.out.println(b);
+		System.out.println(c);
+		System.out.println(d);
+		System.out.println(f);
+		System.out.println(g);
+		System.out.println();
+		
+		// Mimo tego, porównanie == czasami daje wynik true, ale czasami false
+		System.out.println("==");
+		System.out.println(a == "Ala ma kota");
+		System.out.println(a == a);
+		System.out.println(a == b);
+		System.out.println(a == c);
+		System.out.println(a == d);
+		System.out.println(a == f);
+		System.out.println(a == g);
+		System.out.println();
+		
+		System.out.println("intern");
+		// intern zwraca referencję do stringa o takiej samej treści, ale pochodzącego z puli stringów
+		// jeśli w puli jeszcze go nie było, to dodawany
+		System.out.println(a.intern() == f.intern());
+		System.out.println();
+		
+		// Najwłaściwszym sposobem porównywania tekstów w Javie jest metoda equals
+		// Ona sprawdza czy napisy mają tę samą treść.
+		// Mamy też equalsIgnoreCase , który ignoruje wielkość liter
+		System.out.println("equals");
+		System.out.println(a.equals(a));
+		System.out.println(a.equals(b));
+		System.out.println(a.equals(c));
+		System.out.println(a.equals(d));
+		System.out.println(a.equals(f));
+		System.out.println(a.equals(g));
+		System.out.println("Ala ma kota".equals(g));
+		System.out.println(Objects.equals(a, g));
+		System.out.println();
+		
+		System.out.println("hash:");
+		System.out.println(a.hashCode());
+		System.out.println(b.hashCode());
+		System.out.println(c.hashCode());
+		System.out.println(d.hashCode());
+		System.out.println(f.hashCode());
+		System.out.println(g.hashCode());
+	}
+
+}

src/main/java/gotowe/p20_string/TworzenieStringa.java

+package gotowe.p20_string;
+
+import java.util.Scanner;
+
+public class TworzenieStringa {
+	
+	// Wynikiem funkcji ma być napis składający się z liczb od 1 do n rozdzielonych spacjami
+	// Np. dla 5 wynikiem ma być "1 2 3 4 5 "
+	static String ciag(int n) {
+	    // uwaga, ta wersja działa wolno, to nie jest zalecane podejście
+		String s = "";
+		for(int i = 1; i <= n; i++) {
+			s += i + " ";
+		}
+		return s;
+	}
+	
+	static String ciagBuilder(int n) {
+		StringBuilder s = new StringBuilder();
+		for(int i = 1; i <= n; i++) {
+			s.append(i).append(' ');
+		}
+		return s.toString();
+	}
+
+	public static void main(String[] args) {
+		Scanner scanner = new Scanner(System.in);
+		while(true) {
+			System.out.print("Podaj liczbę: ");
+			int n = scanner.nextInt();
+			if(n < 0) break;
+			
+			long p = System.nanoTime();
+			String txt = ciagBuilder(n);			
+			long k = System.nanoTime();
+			System.out.printf("napis ma długość %d , czas: %.6f s%n", txt.length(), (k-p)*1e-9);
+			if(txt.length() <= 1000) {
+				System.out.println(txt);
+			}
+		}
+
+	}
+
+}

src/main/java/gotowe/p22_kolekcje/A_Wprowadzenie.java

+package gotowe.p22_kolekcje;
+
+import java.util.ArrayList;
+import java.util.LinkedList;
+import java.util.List;
+
+public class A_Wprowadzenie {
+
+	public static void main(String[] args) {
+		List<String> lista = new ArrayList<>();
+		lista.add("Ala");
+		lista.add("Ola");
+		lista.add("Ala");
+		System.out.println(lista);
+		
+		// dostęp do jednego elementu:
+		// numeracja od 0, jak dla tablic
+		System.out.println(lista.get(1));
+		// podmiana wartości elementu
+		lista.set(2, "Alicja");
+		System.out.println(lista);
+		
+		for(String element : lista) {
+			System.out.println(" * " + element);
+		}
+		System.out.println();
+		
+		List<Integer> liczby = new LinkedList<>();
+		for(int i = 0; i < 10; i++) {
+			liczby.add(i*i);
+		}
+		liczby.add(5432);
+		System.out.println(liczby);
+		
+		int wynik = liczby.get(4) - liczby.get(2);
+		System.out.println(wynik);
+
+	}
+
+}

src/main/java/gotowe/p22_kolekcje/Listy.java

+package gotowe.p22_kolekcje;
+
+import java.util.List;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+
+public class Listy {
+
+	public static void main(String[] args) {
+		List<String> lista = new ArrayList<>();
+		System.out.println(lista);
+
+		// dodaje na koniec
+		lista.add("ola");
+		lista.add("ala");
+
+		boolean coSieStalo = lista.add("ela");
+		System.out.println(coSieStalo);
+		if(lista.add("iza")) {
+			System.out.println("Iza też");
+		}
+		
+		System.out.println(lista);
+		
+		System.out.println();
+		// odczyt z określonej pozycji, numeracja od 0 jak w tablicach
+		String x = lista.get(0);  // lista[0] - tak się nie da
+		System.out.println(x);
+		x = lista.get(2);
+		System.out.println(x);
+		//EXN x = lista.get(lista.size());
+		// System.out.println(x);
+		
+		// dodaje na okreslona pozycje, przesuwa dotychczasowe elementy w prawo
+		// tu może być od 0 do 4, ale już nie 5 (IOOBExn)
+		lista.add(2, "ewa");
+		lista.add(lista.size(), "ostatnia"); // OK
+		System.out.println(lista);
+		
+		// nadpisuje element na podanej pozycji nowym elementem
+		lista.set(2, "ula");
+		System.out.println(lista);
+		System.out.println();
+		
+		lista.add(0, "ala");
+		System.out.println(lista);
+
+		// usuwa z określonej pozycji, zwraca obiekt
+		String wynik = lista.remove(3);
+		System.out.println("usunąłem element : " + wynik);
+		System.out.println(lista);
+		
+		// to by usunęło od razu wszystkie wystąpienia elementu "ala"
+		// boolean b = lista.removeAll(Collections.singleton("ala"));
+		
+		// to usuwa pierwsze wystąpienie, elementy są porównywane za pomocą equals, wynik boolean mówi czy element został usunięty
+		boolean b = lista.remove("ala");
+		System.out.println("bool : " + b);
+		System.out.println(lista);
+
+		b = lista.remove("ala");
+		System.out.println("bool : " + b);
+		System.out.println(lista);
+
+		b = lista.remove("ala");
+		System.out.println("bool : " + b);
+		System.out.println(lista);
+		
+		System.out.println();
+		lista.addAll(Arrays.asList("ola", "ela", "ewa", "kasia", "marysia", "aga"));
+		System.out.println(lista);
+		
+		System.out.println("indexOf: " + lista.indexOf("ewa"));
+		System.out.println("contains: " + lista.contains("ewa"));
+		System.out.println();
+		System.out.println("indexOf: " + lista.indexOf("Ewa")); // -1
+		System.out.println("contains: " + lista.contains("Ewa")); // false
+		System.out.println();
+		
+		Collections.sort(lista);
+		System.out.println(lista);
+		
+		for(String s : lista) {
+			System.out.println("Kolejny element: " + s);
+		}
+	}
+}

src/main/java/gotowe/p22_kolekcje/ListyIZbiory.java

+package gotowe.p22_kolekcje;
+
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.LinkedHashSet;
+import java.util.LinkedList;
+import java.util.TreeSet;
+
+public class ListyIZbiory {
+
+	public static void main(String[] args) {
+		ArrayList<String> al = new ArrayList<>();
+		LinkedList<String> lista = new LinkedList<>();
+		HashSet<String> hasz = new HashSet<>();
+		LinkedHashSet<String> linkedHasz = new LinkedHashSet<>();
+		TreeSet<String> drzewo = new TreeSet<>();
+		
+		al.add("ala"); lista.add("ala"); drzewo.add("ala"); hasz.add("ala"); linkedHasz.add("ala");
+		al.add("ola"); lista.add("ola"); drzewo.add("ola"); hasz.add("ola"); linkedHasz.add("ola");
+		al.add("ela"); lista.add("ela"); drzewo.add("ela"); hasz.add("ela"); linkedHasz.add("ela");
+		al.add("ula"); lista.add("ula"); drzewo.add("ula"); hasz.add("ula"); linkedHasz.add("ula");
+		al.add("ola"); lista.add("ola"); drzewo.add("ola"); hasz.add("ola"); linkedHasz.add("ola");
+
+		System.out.println("ArrayList:     "+al);
+		System.out.println("LinkedList:    "+lista);
+		System.out.println("TreeSet:       "+drzewo);
+		System.out.println("HashSet:       "+hasz);
+		System.out.println("LinkedHashSet: "+linkedHasz);
+		System.out.println();
+		
+		// dla wszystkich list wolno działa operacja contains / indexOf
+		System.out.println(al.contains("ela"));
+
+		// dla wszystkich zbiorów szybko działa operacja contains
+		System.out.println(hasz.contains("ela"));
+
+	}
+}

src/main/java/gotowe/p22_kolekcje/NoweOperacjeList.java

+package gotowe.p22_kolekcje;
+
+import java.text.Collator;
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.List;
+import java.util.Locale;
+
+public class NoweOperacjeList {
+
+	public static void main(String[] args) {
+		ArrayList<String> lista = new ArrayList<>();
+		lista.add("Ala");
+		lista.add("Ola");
+		lista.add("Kasia");
+		lista.add("Ela");
+		lista.add("Łucja");
+		lista.add("Ula");
+		lista.add("Asia");
+		lista.add("Zosia");
+		
+		System.out.println(lista);
+		System.out.println();
+		
+		lista.sort(null);
+//		lista.sort(Comparator.reverseOrder());
+		lista.sort(Collator.getInstance());
+//		lista.sort(Collator.getInstance(Locale.CHINA));
+//		lista.sort(Collator.getInstance().reversed());
+
+		System.out.println(lista);
+		System.out.println();
+				
+		lista.forEach(s -> System.out.print(s + ", "));
+		System.out.println();
+		System.out.println();
+		
+		List<String> lista1 = (List<String>)lista.clone();
+		System.out.println(lista1);
+		// predykat; operacja usuwa z listy wszystkie spełaniające warunek
+		lista1.removeIf(s -> s.length() <= 3);
+		System.out.println(lista1);
+		System.out.println();
+		
+		List<String> lista2 = (List<String>)lista.clone();
+		System.out.println(lista2);
+		lista2.replaceAll(s -> s.toUpperCase()); // lambda expression
+		// lista2.replaceAll(String::toUpperCase);  // method reference - w tym przypadku równoważnie
+		System.out.println(lista2);
+		System.out.println();
+	}
+
+}

src/main/java/gotowe/p22_kolekcje/NoweOperacjeMap.java

+package gotowe.p22_kolekcje;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.TreeMap;
+
+public class NoweOperacjeMap {
+
+	public static void main(String[] args) {
+		TreeMap<String, Integer> map = new TreeMap<>();
+		map.put("Ala", 20);
+		map.put("Ola", 30);
+		System.out.println(map);
+		
+		map.putIfAbsent("Ala", 25); // nie wpisuje
+		map.putIfAbsent("Ela", 45); // wpisuje
+		System.out.println(map);
+		
+		map.replace("Ala", 28); // zamienia
+		map.replace("Ula", 48); // nic się nie dzieje
+		System.out.println(map);
+		
+		map.replace("Ala", 40, 41); // jeśli taka była poprzednia wartość - tutaj nic się nie stanie
+		System.out.println(map);
+		
+		map.replaceAll((k, v) -> v+1); // zwiększa wszystkie wartości o 1
+		System.out.println(map);
+
+		map.replaceAll((k, v) -> k.startsWith("A") ? v+1 : v); // zwiększa o 1 tylko słowa na literę A
+		System.out.println(map);
+		
+		// dodaje nowy wpis z wartością 10, albo dodaje 10 do istniejącej wartości
+		map.merge("Ola", 10, Math::addExact); // (x,y) -> x+y
+		map.merge("Ewa", 10, Math::addExact);
+		System.out.println(map);
+		System.out.println();
+
+		// Zamiast pętli, możena elementy przeglądać w ten sposób:
+		map.forEach((k, v) -> {
+			System.out.println("Klucz " + k + " ma wartość " + v);
+		});
+	}
+
+}

src/main/java/gotowe/p22_kolekcje/Slowniki.java

+package gotowe.p22_kolekcje;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.TreeMap;
+
+public class Slowniki {
+
+	public static void main(String[] args) {
+		Map<String, Integer> hasz = new HashMap<>();
+		Map<String, Integer> linkedHasz = new LinkedHashMap<>();
+		Map<String, Integer> drzewo = new TreeMap<>();
+		
+		hasz.put("ala", 20); drzewo.put("ala", 20); linkedHasz.put("ala", 20);
+		hasz.put("ola", 30); drzewo.put("ola", 20); linkedHasz.put("ola", 30);
+		hasz.put("ela", 20); drzewo.put("ela", 20); linkedHasz.put("ela", 20);
+		hasz.put("ula", 55); drzewo.put("ula", 55); linkedHasz.put("ula", 55);
+		
+		
+		System.out.println(hasz.get("ela")); //20
+		System.out.println(hasz.get("ewa")); //null
+		
+		System.out.println(hasz.containsKey("ela")); // szybkie
+		System.out.println(hasz.containsValue(55)); // wolne
+		
+		System.out.println("\nTreeMap:       "+drzewo);
+		System.out.println("HashMap:       "+hasz);
+		System.out.println("LinkedHashMap: "+linkedHasz);
+		System.out.println("====================================\n");
+
+		hasz.put("ola", 31); drzewo.put("ola", 31); linkedHasz.put("ola", 31);
+
+		System.out.println("TreeMap:       "+drzewo);
+		System.out.println("HashMap:       "+hasz);
+		System.out.println("LinkedHashMap: "+linkedHasz);
+		
+		System.out.println("\nWszystkie wpisy:");
+		for(Map.Entry<String, Integer> entry : drzewo.entrySet()) {
+			System.out.println(entry.getKey() + " -> " + entry.getValue());
+		}
+		
+		System.out.println("\nWszystkie klucze:");
+		for(String s : drzewo.keySet()) {
+			System.out.println(s);
+		}
+
+		System.out.println("\nWszystkie wartości:");
+		for(Integer i : drzewo.values()) {
+			System.out.println(i);
+		}
+		
+		// Można też przypisać na zmienne:
+		Set<Map.Entry<String, Integer>> zbiorWpisow = hasz.entrySet();
+		Set<String> klucze = hasz.keySet();
+		Collection<Integer> wartosci = hasz.values();
+		
+		// Jak zrobić listę kluczy?
+		List<String> kluczel = new ArrayList<>(hasz.keySet());
+	}
+}

src/main/java/gotowe/p22_kolekcje/ZbieranieDanych1_Tablica.java

+package gotowe.p22_kolekcje;
+
+import java.util.Arrays;
+import java.util.Scanner;
+
+public class ZbieranieDanych1_Tablica {
+
+	public static void main(String[] args) {
+		Scanner scanner = new Scanner(System.in);
+		System.out.print("Ile imion podasz? ");
+		int rozmiar = scanner.nextInt();
+		scanner.nextLine(); // tylko po to, aby dojść do końca linii
+		String[] tablica = new String[rozmiar];
+		
+		for(int i = 0; i < tablica.length; i++) {
+			System.out.print("Podaj imię nr " + i + ": ");
+			tablica[i] = scanner.nextLine();
+		}
+		System.out.println(Arrays.toString(tablica));
+		System.out.println();
+		
+		System.out.println("Podawaj numery pozycji, aby je odczytać, a -1 aby zakończyć program.");
+		while(true) {
+			System.out.print("Podaj numer: ");
+			int nr = scanner.nextInt();
+			if(nr < 0) break;
+			if(nr >= tablica.length) {
+				System.out.println("Numer poza tablicą");
+				continue;
+			}
+			System.out.println("Osoba nr " + nr + " ma na imię " + tablica[nr]);
+			// Najbardziej oczywistą operacją odczytu z tablicy, jest odczyt z określonej pozycji.
+		}
+	}
+
+}

src/main/java/gotowe/p22_kolekcje/ZbieranieDanych2_Lista.java

+package gotowe.p22_kolekcje;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Scanner;
+
+public class ZbieranieDanych2_Lista {
+    // Listy:
+    // - mogą zawierać duplikaty (tę wartość kilka razy),
+    // - przechowują elementy na określonych pozycjach od 0 do size-1,
+    //   za pomocą get(i) można odczytać, a za pomocą set(i, nowaWartosc) zmienić konkretny element listy
+
+	public static void main(String[] args) {
+		Scanner scanner = new Scanner(System.in);
+		List<String> lista = new ArrayList<>();
+		
+		System.out.println("Podawaj imiona, a zakończ pustym napisem (ENTER)");
+		for(;;) {
+			System.out.print("Podaj kolejne imię: ");
+			String imie = scanner.nextLine();
+			if(imie.isEmpty()) break;
+			lista.add(imie);
+		}
+		System.out.println(lista);
+		System.out.println();
+		
+		System.out.println("Podawaj numery pozycji, aby je odczytać, a -1 aby zakończyć program.");
+		for(;;) {
+			System.out.print("Podaj numer: ");
+			int nr = scanner.nextInt();
+			if(nr < 0) break;
+			if(nr >= lista.size()) {
+				System.out.println("Numer poza listą");
+				continue;
+			}
+			System.out.println("Osoba nr " + nr + " ma na imię " + lista.get(nr));
+			// Listy też pozwalają odczytać element z określonej pozycji.
+			// W przypadku implementacji ArrayList ta operacja jest wydajna.
+		}
+	}
+
+}

src/main/java/gotowe/p22_kolekcje/ZbieranieDanych3_Queue.java

+package gotowe.p22_kolekcje;
+
+import java.util.LinkedList;
+import java.util.Queue;
+import java.util.Scanner;
+
+public class ZbieranieDanych3_Queue {
+	// Kolejka to struktura danych zoptymalizowana pod kątem dostępu do "następnego elementu"
+	// (operacja poll() lub get()).
+	// * Kolejka prosta zachowuje kolejność elementów i następnym elementem do pobrania jest ten,
+	//   który został najdawniej w kolejce umieszczony.
+	//   Jak "sprawiedliwa" kolejna do kasy w sklepie.
+	//   Najczęściej jest to jednocześnie kolejka dwukońcowa (Dequeue) z możliwością dostepu do obu jej końców.
+
+	public static void main(String[] args) {
+		Scanner scanner = new Scanner(System.in);
+		
+		Queue<String> kolejka = new LinkedList<>(); // albo ArrayDequeue; - to są "kolejki proste"
+		System.out.println(kolejka);
+		System.out.println("Podawaj kolejne elementy, aby dodać do kolejki.\nWpisz '?', aby pobrać element z kolejki, a Enter aby zakończyć program");
+		
+		while(true) {
+			System.out.println("Kolejka: " + kolejka);
+			System.out.print("> ");
+			String napis = scanner.nextLine();
+			if(napis.isEmpty()) break;
+			if(napis.equals("?")) {
+				String pobrane = kolejka.poll();
+				System.out.println("Pobrany element: " + pobrane);
+			} else {
+				System.out.println("Dodany element: " + napis);
+				kolejka.add(napis);
+			}
+		}
+		
+		System.out.println("Końcowy rozmiar kolejki " + kolejka.size());
+		System.out.println(kolejka);
+		System.out.println("Koniec programu");
+	}
+
+}

src/main/java/gotowe/p22_kolekcje/ZbieranieDanych4_PriorityQueue.java

+package gotowe.p22_kolekcje;
+
+import java.util.PriorityQueue;
+import java.util.Queue;
+import java.util.Scanner;
+
+public class ZbieranieDanych4_PriorityQueue {
+	// * Kolejka priorytetowa może nie zachowywać kolejności (możliwe jest tzw. "zagłodzenie").
+	//   Następnym elementem do pobranie jest element o najwyższym priorytecie
+	//   - w Javie jest to element o najmniejszej wartości (np. napis najwcześniejszy alfabetycznie).
+
+	public static void main(String[] args) {
+		Scanner scanner = new Scanner(System.in);
+		
+		Queue<String> kolejka = new PriorityQueue<>();
+		System.out.println(kolejka);
+		System.out.println("Podawaj kolejne elementy, aby dodać do kolejki.\nWpisz '?', aby pobrać element z kolejki, a Enter aby zakończyć program");
+		
+		while(true) {
+			System.out.println("Kolejka: " + kolejka);
+			System.out.print("> ");
+			String napis = scanner.nextLine();
+			if(napis.isEmpty()) break;
+			if(napis.equals("?")) {
+				String pobrane = kolejka.poll();
+				System.out.println("Pobrany element: " + pobrane);
+			} else {
+				System.out.println("Dodany element: " + napis);
+				kolejka.add(napis);
+			}
+		}
+		
+		System.out.println("Końcowy rozmiar kolejki " + kolejka.size());
+		System.out.println(kolejka);
+		System.out.println("Koniec programu");
+	}
+
+}

src/main/java/gotowe/p22_kolekcje/ZbieranieDanych5_HashSet.java

+package gotowe.p22_kolekcje;
+
+import java.util.HashSet;
+import java.util.Scanner;
+import java.util.Set;
+
+public class ZbieranieDanych5_HashSet {
+    // Zbiory:
+    // - nie zawierają duplikatów (dodanie kolejny raz tej samej wartości nie zmienia już zbioru),
+    // - mają prawo zmienić kolejność elementów
+    //   → HashSet zmienia kolejność
+    //   → LinkedHashSet nie zmienia kolejności (zachowuje początkową kolejność, w jakiej elementy były dodawane)
+    //   → TreeSet samoczynnie sortuje elementy
+    // Podstawową (i wydajną) operacją dla zbioru jest sprawdzenie czy element należy do zbioru.
+
+	public static void main(String[] args) {
+		Scanner scanner = new Scanner(System.in);
+		Set<String> zbior = new HashSet<>();
+		
+		System.out.println("Podawaj imiona, a zakończ pustym napisem (ENTER)");
+		while(true) {
+			System.out.print("Podaj kolejne imię: ");
+			String imie = scanner.nextLine();
+			if(imie.isEmpty()) break;
+			zbior.add(imie);
+		}
+		System.out.println(zbior);
+		System.out.println();
+		
+		System.out.println("Podawaj imiona, aby sprawdzić, a zakończ pustym napisem.");
+		while(true) {
+            System.out.print("Podaj szukane imię: ");
+            String szukane = scanner.nextLine();
+            if(szukane.isEmpty()) break;
+            if(zbior.contains(szukane)) {
+            	System.out.println("Imię " + szukane + " należy do zbioru");
+            } else {
+            	System.out.println("Imię " + szukane + " nie należy do zbioru");
+            }
+		}
+	}
+
+}

src/main/java/gotowe/p22_kolekcje/ZbieranieDanych5_TreeSet.java

+package gotowe.p22_kolekcje;
+
+import java.util.Scanner;
+import java.util.Set;
+import java.util.TreeSet;
+
+public class ZbieranieDanych5_TreeSet {
+	
+	public static void main(String[] args) {
+		Scanner scanner = new Scanner(System.in);
+		Set<String> zbior = new TreeSet<>();
+		
+		System.out.println("Podawaj imiona, a zakończ pustym napisem (ENTER)");
+		while(true) {
+			System.out.print("Podaj kolejne imię: ");
+			String imie = scanner.nextLine();
+			if(imie.isEmpty()) break;
+			zbior.add(imie);
+		}
+		System.out.println(zbior);
+		System.out.println();
+		
+		System.out.println("Podawaj imiona, aby sprawdzić, a zakończ pustym napisem.");
+		while(true) {
+            System.out.print("Podaj szukane imię: ");
+            String szukane = scanner.nextLine();
+            if(szukane.isEmpty()) break;
+            if(zbior.contains(szukane)) {
+            	 System.out.println("Imię " + szukane + " należy do zbioru");
+            } else {
+                System.out.println("Imię " + szukane + " nie należy do zbioru");
+            }
+		}
+	}
+
+}

src/main/java/gotowe/p22_kolekcje/ZbieranieDanych6_HashMap.java

+package gotowe.p22_kolekcje;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Scanner;
+
+public class ZbieranieDanych6_HashMap {
+    // Słowniki (mapy):
+    // - zawierają pary klucz → wartość
+	// - klucze nie mogą się powtarzać, wartości mogą
+	// - wydajne są operacje dodawanie elementu i pobierania/wyszukiwania poprzez klucz
+	// - niewydaje jest wyszukiwanie poprzez wartość
+
+	public static void main(String[] args) {
+		Scanner scanner = new Scanner(System.in);
+		// Przykładowo tutaj dla imienia (string) pamiętamy wiek (Integer)
+		Map<String, Integer> slownik = new HashMap<>();
+		
+		while(true) {
+			System.out.print("Podaj kolejne imię: ");
+			String imie = scanner.nextLine();
+			if(imie.isEmpty()) break;
+			System.out.print("Ile lat ma ta osoba? ");
+			int wiek = scanner.nextInt();
+			scanner.nextLine();
+			slownik.put(imie, wiek);
+		}
+		System.out.println(slownik);
+		System.out.println();
+		
+		System.out.println("Podawaj imiona, aby sprawdzić, a zakończ pustym napisem.");
+		while(true) {
+            System.out.print("Podaj szukane imię: ");
+            String szukane = scanner.nextLine();
+            if(szukane.isEmpty()) break;
+            if(slownik.containsKey(szukane)) {
+            	int wiek = slownik.get(szukane);
+            	System.out.println("Osoba " + szukane + " ma " + wiek + " lat.");
+            } else {
+                System.out.println("Osoba " + szukane + " nie należy do słownika.");
+            }
+		}
+	}
+
+}