teoria kolekcji

src/p12_kolekcje/sortowanie/KomparatorDlugosciNapisow.java

+package p12_kolekcje.sortowanie;
+
+import java.util.Comparator;
+
+public class KomparatorDlugosciNapisow implements Comparator<String> {
+
+	@Override
+	public int compare(String s1, String s2) {
+		// Taka metoda ma za zadanie zwrócić:
+		// - wartość ujemną, jeśli lewy element jest mniejszy
+		// - wartość dodatnią, jeśli lewy element jest większy
+		// - zero, jeśli oba są równe
+		// W tej wersji bierzemy pod uwagę długości napisów.
+		return s1.length() - s2.length();
+	}
+
+}

src/p12_kolekcje/sortowanie/Sortowanie.java

+package p12_kolekcje.sortowanie;
+
+import java.text.Collator;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.Locale;
+import java.util.Set;
+import java.util.TreeSet;
+
+public class Sortowanie {
+
+	public static void main(String[] args) {
+		String[] tablica = {"Ola", "ala", "Ala", "Marek", "Łukasz", "Ącki", "Alamakota", "Ab", "Żaneta", "Lucek", "Ala", "23"};
+		List<String> lista = new ArrayList<>(List.of(tablica));
+		
+		System.out.println(lista);
+		
+		// sortowanie listy w sposób domyślny od Javy 8 zapisuje się tak:
+		lista.sort(null);
+		// w przypadku Stringów oznacza to sortowanie wg kodów Unicode		
+		System.out.println(lista);
+		
+		// Istnieje też taki sposób, dostępny też w starszych wersjach Javy:
+		Collections.sort(lista);
+		System.out.println(lista);
+		
+		// Wprowadzenie w temat Comparatorów.
+		// Comparator to jest taka maszynka, która (w metodzie compare) jak waga porównuje dwa obiekty
+		// Możemy sami stworzyć własny Comparator - tutaj jest to klasa KomparatorDlugosciNapisow
+		
+		KomparatorDlugosciNapisow komparator = new KomparatorDlugosciNapisow();
+		lista.sort(komparator);
+		System.out.println(lista);
+		
+		// Komparatory można też tworzyć jako klasy anonimowe oraz (od Java 8) wyrażenia lambda
+		lista.sort((s1, s2) -> s2.length() - s1.length());
+		System.out.println(lista);
+		System.out.println();
+		
+		// SORTOWANIE ZGODNE Z ALFABETEM
+		// Klasa Collator jest takim gotowym Comparatorem, który porównuje napisy zgodnie z alfabetem jakiegoś ludzkiego języka
+
+		// sortowanie zgodne z bieżącymi ustawieniami komputera:
+		lista.sort(Collator.getInstance());
+		System.out.println(lista);
+
+		// sortownaie zgodne z określonym językiem
+		lista.sort(Collator.getInstance(Locale.FRANCE));
+		System.out.println(lista);
+
+		lista.sort(Collator.getInstance(Locale.of("pl", "PL")));
+		System.out.println(lista);
+		System.out.println();
+
+		// Sortować można też tablice
+		// sposób domyślny:
+		Arrays.sort(tablica);
+		System.out.println(Arrays.toString(tablica));
+
+		// w oparciu o podany komparator:
+		Arrays.sort(tablica, Collator.getInstance());
+		System.out.println(Arrays.toString(tablica));
+		System.out.println();
+		
+		// Comparator / Collator może być też wykorzystany podczas tworzenia TreeSet i TreeMap
+		Set<String> zbior = new TreeSet<>(Collator.getInstance());
+		zbior.add("Łukasz");
+		zbior.add("Lucek");
+		zbior.add("Marek");
+		System.out.println(zbior);
+	}
+
+}

src/p12_kolekcje/teoria/DeklaracjeGeneryczne.java

+package p12_kolekcje.teoria;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class DeklaracjeGeneryczne {
+
+	public static void main(String[] args) {
+		List l1 = new ArrayList();
+		ArrayList l2 = new ArrayList();
+		List<String> l3 = new ArrayList<String>();
+		List<String> l4 = new ArrayList<>();   // diamond operator od Javy 7
+		List<String> l5 = new ArrayList();
+		List l6 = new ArrayList<>();  // lista Object-ów
+
+		//NK List<> l7 = new ArrayList<String>();
+		
+		List<List<Integer>> l8 = new ArrayList<>();
+		//NK List<List<Integer>> l9 = new ArrayList<<>>();
+		//NK List<List<Integer>> l10 = new ArrayList<List<>>();
+		List<List<Integer>> l11 = new ArrayList<List<Integer>>();
+		
+		//NK List<int> l12 = new ArrayList<>();
+		List<int[]> l13 = new ArrayList<>();
+		
+		// "lista nie wiadomo czego"
+		// w praktyce takiej listy mogę używać tylko do odczytu, nie mogę w niej niczego zapisać
+		List<?> l14 = new ArrayList<>();
+		List<?> l15 = new ArrayList<String>();
+		// l15.add("ala");
+		
+		// to nie to samo, co lista Objectów, bo np lista Stringów nie jest tym samym co lista Objectów, i nie można wpisać
+		//NK List<Object> l16 = new ArrayList<String>();
+
+	}
+
+}

src/p12_kolekcje/teoria/ListNoweOperacje.java

+package p12_kolekcje.teoria;
+
+import java.text.Collator;
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.List;
+import java.util.Locale;
+
+public class ListNoweOperacje {
+
+	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();
+		
+		// jeden sposób skopiownaia listy - wymaga tego, aby zmienna lista była typu ArrayList (a nie wystarczy List)
+		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();
+		
+		// drugi (lepszy) sposób kopiowania listy: konstruktor z parametrem "inna kolekcja / źródło danych"
+		List<String> lista2 = new ArrayList<>(lista);
+		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/p12_kolekcje/teoria/ListOperacje.java

+package p12_kolekcje.teoria;
+
+import java.util.List;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+
+public class ListOperacje {
+
+	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/p12_kolekcje/teoria/ListyIZbiory.java

+package p12_kolekcje.teoria;
+
+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/p12_kolekcje/teoria/PorownanieSzybkosciList.java

+package p12_kolekcje.teoria;
+
+import java.util.ArrayList;
+import java.util.LinkedList;
+import java.util.List;
+
+public class PorownanieSzybkosciList {	
+	public static void testujListe(List<Integer> lista) {
+		long start, koniec;
+		int suma;
+		
+		System.out.print("Wstawianie 250 tys. na koniec listy (add)... ");
+		start = System.currentTimeMillis();
+		for(int i=0; i<250000; i++) {
+			lista.add(i);
+		}
+		koniec = System.currentTimeMillis();
+		System.out.println(koniec - start + " ms");
+		
+		lista.clear(); // usuwa całą zawartość
+		
+		System.out.print("Wstawianie 500 tys. na koniec listy (add)... ");
+		start = System.currentTimeMillis();
+		for(int i=0; i<500000; i++) {
+			lista.add(i);
+		}
+		koniec = System.currentTimeMillis();
+		System.out.println(koniec - start + " ms");
+		
+		System.out.println("\nDodawanie na początek... ");
+		start = System.currentTimeMillis();
+		Integer nowyElement = 333;
+		for(int i=0; i < 10000; i++) {
+			lista.add(0, nowyElement);
+			// Szybko dla LinkedList, wolno dla ArrayList
+		}
+		koniec = System.currentTimeMillis();
+		System.out.println(koniec - start + " ms");
+		
+		System.out.println("\nWybieranie po indeksie... ");
+		start = System.currentTimeMillis();
+		suma = 0;
+		for(int i=0; i < 5000; i++) {
+			suma += lista.get(i * 100);
+			// Szybkie dla ArrayList, wolne dla LinkedList
+		}
+		koniec = System.currentTimeMillis();
+		System.out.println(koniec - start + " ms");
+		System.out.println("wynik="+suma);
+		
+		System.out.println("\nOdczytanie wszystkich elementów foreach");
+		start = System.currentTimeMillis();
+		suma = 0;
+		for(int x : lista) {
+			suma += x;
+		}
+		koniec = System.currentTimeMillis();
+		System.out.println(koniec - start + " ms");
+		System.out.println("wynik="+suma);
+	}
+
+	public static void main(String[] args) {	
+		List<Integer> linked = new LinkedList<>();
+		List<Integer> tablicowa = new ArrayList<>();	
+		
+		System.out.println("LinkedList:");
+		testujListe(linked);
+
+		System.out.println("\n\n================");
+		System.out.println("ArrayList:");
+		testujListe(tablicowa);
+	}
+}

src/p12_kolekcje/teoria/Slowniki.java

+package p12_kolekcje.teoria;
+
+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/p12_kolekcje/zbieranie_danych/P1_Tablica.java

+package p12_kolekcje.zbieranie_danych;
+
+import java.util.Arrays;
+import java.util.Scanner;
+
+public class P1_Tablica {
+
+	public static void main(String[] args) {
+		Scanner scanner = new Scanner(System.in);
+		// Podczas tworzenia tablicy musimy wiedzieć, ile elementów ma mieć.
+		
+		System.out.print("Ile imion podasz? ");
+		int size = scanner.nextInt();
+		scanner.nextLine(); // ingorujemy resztę linii, co ma znaczenie nawet, jeśli jest pusta
+		
+		String[] tablica = new String[size];
+		
+		for(int i = 0; i < tablica.length; i++) {
+			System.out.print("Podaj imię nr " + i + ": ");
+			String imie = scanner.nextLine();
+			tablica[i] = imie;
+		}
+		
+		System.out.println(Arrays.toString(tablica));
+		System.out.println();
+		
+		// Drugi etap: użytkownik podaje numer, a program odczytuje wartość z podanej pozycji.
+		// -1 kończy
+		while(true) {
+			System.out.print("Podaj nr pozycji: ");
+			int pozycja = scanner.nextInt();
+			scanner.nextLine();
+			if(pozycja == -1) {
+				break;
+			}
+			try {
+				String imie = tablica[pozycja];
+				System.out.println("Osoba nr " + pozycja + " to " + imie);
+			} catch (Exception e) {
+				System.out.println(e);
+			}
+		}
+	}
+
+}

src/p12_kolekcje/zbieranie_danych/P2_Lista.java

+package p12_kolekcje.zbieranie_danych;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Scanner;
+
+import javax.print.attribute.standard.Sides;
+
+public class P2_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);
+		// Gdy używamy listy nie musimy z wyprzedzeniem znać jej rozmiaru.
+		// Do listy zawsze można dodać kolejny element na końcu (*)
+		// (*) - realnymi ograniczeniami są: 1) rozmiar int, 2) dostępna pamięć
+		
+		List<String> lista = new ArrayList<>();
+		
+		while(true) {
+			System.out.print("Podaj imię: ");
+			// pusty String oznacza koniec
+			String imie = scanner.nextLine();
+			if(imie.isEmpty()) {
+				break;
+			}
+			lista.add(imie);
+		}
+		
+		System.out.println("Liczba odczytanych elementów: " + lista.size());
+		System.out.println(lista);
+		System.out.println();
+		
+		// Drugi etap: użytkownik podaje numer, a program odczytuje wartość z podanej pozycji.
+		// -1 kończy
+		while(true) {
+			System.out.print("Podaj nr pozycji: ");
+			int pozycja = scanner.nextInt();
+			scanner.nextLine();
+			if(pozycja == -1) {
+				break;
+			}
+			try {
+				String imie = lista.get(pozycja);
+				System.out.println("Osoba nr " + pozycja + " to " + imie);
+			} catch (Exception e) {
+				System.out.println(e);
+			}
+		}
+	}
+
+}

src/p12_kolekcje/zbieranie_danych/P2_Lista_Sortowanie.java

+package p12_kolekcje.zbieranie_danych;
+
+import java.text.Collator;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Scanner;
+
+import javax.print.attribute.standard.Sides;
+
+public class P2_Lista_Sortowanie {
+	// 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);
+		// Gdy używamy listy nie musimy z wyprzedzeniem znać jej rozmiaru.
+		// Do listy zawsze można dodać kolejny element na końcu (*)
+		// (*) - realnymi ograniczeniami są: 1) rozmiar int, 2) dostępna pamięć
+		
+		List<String> lista = new ArrayList<>();
+		
+		while(true) {
+			System.out.print("Podaj imię: ");
+			// pusty String oznacza koniec
+			String imie = scanner.nextLine();
+			if(imie.isEmpty()) {
+				break;
+			}
+			lista.add(imie);
+		}
+		
+		System.out.println("Liczba odczytanych elementów: " + lista.size());
+		System.out.println(lista);
+		System.out.println("Sortowanie...");
+		lista.sort(Collator.getInstance());
+		System.out.println(lista);
+		System.out.println();
+		
+		// Drugi etap: użytkownik podaje numer, a program odczytuje wartość z podanej pozycji.
+		// -1 kończy
+		while(true) {
+			System.out.print("Podaj nr pozycji: ");
+			int pozycja = scanner.nextInt();
+			scanner.nextLine();
+			if(pozycja == -1) {
+				break;
+			}
+			try {
+				String imie = lista.get(pozycja);
+				System.out.println("Osoba nr " + pozycja + " to " + imie);
+			} catch (Exception e) {
+				System.out.println(e);
+			}
+		}
+	}
+
+}

src/p12_kolekcje/zbieranie_danych/P3_HashSet.java

+package p12_kolekcje.zbieranie_danych;
+
+import java.util.HashSet;
+import java.util.Scanner;
+import java.util.Set;
+
+public class P3_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ść (wg własnych zasad w oparciu o haszkody, na co nie mamy wpływu)
+	//   → 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<>();
+		
+		while(true) {
+			System.out.print("Podaj imię: ");
+			// pusty String oznacza koniec
+			String imie = scanner.nextLine();
+			if(imie.isEmpty()) {
+				break;
+			}
+			zbior.add(imie);
+		}
+		
+		System.out.println(zbior);
+		System.out.println();
+		
+		// Drugi etap: użytkownik podaje imię, a program sprawdza, czy takie imię istnieje - to jest najbardziej podstawowa operacja dla zbiorów.
+		// pusty string kończy
+		while(true) {
+			System.out.print("Podaj imię: ");
+			String imie = scanner.nextLine();
+			if(imie.isEmpty()) {
+				break;
+			}
+			if(zbior.contains(imie)) {
+				System.out.println("TAK");
+			} else {
+				System.out.println("NIE");
+			}
+		}
+	}
+
+}

src/p12_kolekcje/zbieranie_danych/P4_TreeSet.java

+package p12_kolekcje.zbieranie_danych;
+
+import java.util.Scanner;
+import java.util.Set;
+import java.util.TreeSet;
+
+public class P4_TreeSet {
+
+	public static void main(String[] args) {
+		Scanner scanner = new Scanner(System.in);
+		
+		Set<String> zbior = new TreeSet<>();
+		
+		while(true) {
+			System.out.print("Podaj imię: ");
+			// pusty String oznacza koniec
+			String imie = scanner.nextLine();
+			if(imie.isEmpty()) {
+				break;
+			}
+			zbior.add(imie);
+		}
+		
+		System.out.println(zbior);
+		System.out.println();
+		
+		// Drugi etap: użytkownik podaje imię, a program sprawdza, czy takie imię istnieje - to jest najbardziej podstawowa operacja dla zbiorów.
+		// pusty string kończy
+		while(true) {
+			System.out.print("Podaj imię: ");
+			String imie = scanner.nextLine();
+			if(imie.isEmpty()) {
+				break;
+			}
+			if(zbior.contains(imie)) {
+				System.out.println("TAK");
+			} else {
+				System.out.println("NIE");
+			}
+		}
+	}
+
+}

src/p12_kolekcje/zbieranie_danych/P5_HashMap.java

+package p12_kolekcje.zbieranie_danych;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Scanner;
+
+public class P5_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);
+		
+		// W tym słowniku dla imienia osoby pamiętamy wiek tej osoby.
+		// String (mię) jest kluczem, Integer (wiek) jest wartością.
+		Map<String, Integer> slownik = new HashMap<>();
+		
+		while(true) {
+			System.out.print("Podaj imię: ");
+			// pusty String oznacza koniec
+			String imie = scanner.nextLine();
+			if(imie.isEmpty()) {
+				break;
+			}
+			System.out.print("Podaj wiek: ");
+			int wiek = scanner.nextInt();
+			scanner.nextLine();
+			slownik.put(imie, wiek);
+		}
+		
+		System.out.println(slownik);
+		System.out.println();
+		
+		// Drugi etap: użytkownik podaje imię, a program odczytuje wartość ze słownika (czyli wiek tej osoby)
+		while(true) {
+			System.out.print("Podaj imię: ");
+			String imie = scanner.nextLine();
+			if(imie.isEmpty()) {
+				break;
+			}
+			// podstawową operacją do odczytywania danych ze słownika jest get(klucz)
+			// jeśli istnieje wpis o podanym kluczu, to wynikiem jest wartość spod tego klucza
+			// jeśli nie istnieje, to wynikiem jest null
+			// w związku z tym gdy czytamy dane ze słownika bez wcześniejszego sprawdzenia, czy klucz istnieje,
+			// trzeba użyć zmiennej typu obiektowego (tutaj Integer, a nie int)
+			Integer wiek = slownik.get(imie);
+			if(wiek == null) {
+				System.out.println("W słowniku nie osoby " + imie);
+			} else {
+				System.out.println("Osoba " + imie + " ma " + wiek + " lat");
+			}
+			
+			// Można też użyć operacji containsKey do sprawdzenia, czy słownik zawiera podany klucz
+//			if(slownik.containsKey(imie)) {
+//				System.out.println("Osoba " + imie + " ma " + slownik.get(imie) + " lat.");
+//			} else {
+//				System.out.println("W słowniku nie osoby " + imie);
+//			}
+		}
+	}
+
+}

src/p12_kolekcje/zbieranie_danych/P6_TreeMap.java

+package p12_kolekcje.zbieranie_danych;
+
+import java.util.Map;
+import java.util.Scanner;
+import java.util.TreeMap;
+
+public class P6_TreeMap {
+	// Podobnie, jak w przypadku zbiorów (Set), dla słowników (Map) mamy takie implementacje,
+	// które róznią się kolejnością danych:
+	// - HashMap - kolejność techniczna / chaotyczna
+	// - LinkedHashMap - kolejność, w jakiej elementy były dodawane po raz pierwszy
+	// - TreeMap - dane posortowane wg kluczy
+	
+	// W zaawansowanych zastosowaniach ważną implementacją słowników jest ConcurrentHashMap,
+	// która poprawnie i wydajnie działa w aplikacjach wielowątkowych (rózne wątki mogą korzytać jednocześnie).
+	
+	public static void main(String[] args) {
+		Scanner scanner = new Scanner(System.in);
+		
+		// W tym słowniku dla imienia osoby pamiętamy wiek tej osoby.
+		// String (mię) jest kluczem, Integer (wiek) jest wartością.
+		Map<String, Integer> slownik = new TreeMap<>();
+		
+		while(true) {
+			System.out.print("Podaj imię: ");
+			// pusty String oznacza koniec
+			String imie = scanner.nextLine();
+			if(imie.isEmpty()) {
+				break;
+			}
+			System.out.print("Podaj wiek: ");
+			int wiek = scanner.nextInt();
+			scanner.nextLine();
+			slownik.put(imie, wiek);
+		}
+		
+		System.out.println(slownik);
+		System.out.println();
+		
+		// Drugi etap: użytkownik podaje imię, a program odczytuje wartość ze słownika (czyli wiek tej osoby)
+		while(true) {
+			System.out.print("Podaj imię: ");
+			String imie = scanner.nextLine();
+			if(imie.isEmpty()) {
+				break;
+			}
+			// podstawową operacją do odczytywania danych ze słownika jest get(klucz)
+			// jeśli istnieje wpis o podanym kluczu, to wynikiem jest wartość spod tego klucza
+			// jeśli nie istnieje, to wynikiem jest null
+			// w związku z tym gdy czytamy dane ze słownika bez wcześniejszego sprawdzenia, czy klucz istnieje,
+			// trzeba użyć zmiennej typu obiektowego (tutaj Integer, a nie int)
+			Integer wiek = slownik.get(imie);
+			if(wiek == null) {
+				System.out.println("W słowniku nie osoby " + imie);
+			} else {
+				System.out.println("Osoba " + imie + " ma " + wiek + " lat");
+			}
+			
+			// Można też użyć operacji containsKey do sprawdzenia, czy słownik zawiera podany klucz
+//			if(slownik.containsKey(imie)) {
+//				System.out.println("Osoba " + imie + " ma " + slownik.get(imie) + " lat.");
+//			} else {
+//				System.out.println("W słowniku nie osoby " + imie);
+//			}
+		}
+	}
+
+}

src/p12_kolekcje/zbieranie_danych/P7_Queue.java

+package p12_kolekcje.zbieranie_danych;
+
+import java.util.LinkedList;
+import java.util.Queue;
+import java.util.Scanner;
+
+public class P7_Queue {
+	// Kolejka to struktura danych zoptymalizowana pod kątem dostępu do "następnego elementu"
+	// (operacja poll() lub get()).
+	// * Kolejka prosta (FIFO) 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/p12_kolekcje/zbieranie_danych/P8_PriorityQueue.java

+package p12_kolekcje.zbieranie_danych;
+
+import java.util.PriorityQueue;
+import java.util.Queue;
+import java.util.Scanner;
+
+public class P8_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");
+	}
+
+}