Dalsze prykłady kolekcji

src/p12_kolekcje/a_list/Listy.java

@@ -34,6 +34,7 @@ public class Listy {
 		
 		// dodaje na okreslona pozycje, przesuwa dotychczasowe elementy w prawo
 		// tu może być od 0 do 4, ale już nie 5 (IOOBExn)
+		System.out.println(lista);
 		lista.add(2, "ewa");
 		lista.add(lista.size(), "ostatnia"); // OK
 		System.out.println(lista);

src/p12_kolekcje/b_set_map/ListyIZbiory.java

+package p12_kolekcje.b_set_map;
+
+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"); hasz.add("ala"); linkedHasz.add("ala"); drzewo.add("ala");
+		al.add("ola"); lista.add("ola"); hasz.add("ola"); linkedHasz.add("ola"); drzewo.add("ola");
+		al.add("ela"); lista.add("ela"); hasz.add("ela"); linkedHasz.add("ela"); drzewo.add("ela");
+		al.add("ula"); lista.add("ula"); hasz.add("ula"); linkedHasz.add("ula"); drzewo.add("ula");
+		al.add("ola"); lista.add("ola"); hasz.add("ola"); linkedHasz.add("ola"); drzewo.add("ola");
+
+		System.out.println("ArrayList:     "+al);
+		System.out.println("LinkedList:    "+lista);
+		System.out.println("HashSet:       "+hasz);
+		System.out.println("LinkedHashSet: "+linkedHasz);
+		System.out.println("TreeSet:       "+drzewo);
+		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/b_set_map/NoweOperacjeMap.java

+package p12_kolekcje.b_set_map;
+
+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/p12_kolekcje/b_set_map/Slowniki.java

+package p12_kolekcje.b_set_map;
+
+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/b_set_map/Tree1.java

+package p12_kolekcje.b_set_map;
+
+import java.util.Arrays;
+import java.util.SortedSet;
+import java.util.TreeSet;
+
+public class Tree1 {
+
+	public static void main(String[] args) {
+		
+		// TreeSet implementuje dodatkowe interfejsy:
+		// SortedSet<String>
+		// NavigableSet<String>
+		TreeSet<String> imiona = new TreeSet<>(
+				Arrays.asList("Ala", "Ola", "Ula", "Ela", "Ewa", "Ania", "Kasia", "Aga", "Iwona", "Magda", "Iza"));
+		
+		
+		System.out.println(imiona);
+		
+		SortedSet<String> head1 = imiona.headSet("Iwona");
+		System.out.println(head1); // obejmuje wszystkie elementy < Iwona
+		
+		SortedSet<String> head2 = imiona.headSet("Iwona", true);
+		System.out.println(head2); // obejmuje wszystkie elementy <= Iwona
+
+		SortedSet<String> tail1 = imiona.tailSet("Iwona");
+		System.out.println(tail1); // obejmuje wszystkie elementy >= Iwona
+		
+		SortedSet<String> tail2 = imiona.tailSet("Iwona", false);
+		System.out.println(tail2); // obejmuje wszystkie elementy > Iwona
+		// headSet i tailSet (bez parametru inclusive) dają łącznie cały zbiór
+		System.out.println();
+		
+		// Jako granicę można podawać także elementy niewystępujące w kolekcji
+		SortedSet<String> head3 = imiona.headSet("Jola");
+		System.out.println(head3);
+		
+		SortedSet<String> sub1 = imiona.subSet("Ela", "Iwona"); // domyslnie inclusive: true / false
+		System.out.println(sub1);
+
+		SortedSet<String> sub2 = imiona.subSet("Ela", true, "Iwona", true);
+		System.out.println(sub2);
+		System.out.println("\n############");
+		
+		// to są "widoki", a nie kopie - zmiany w zbiorze pierwotnym są od razu widziane przez pobrane obiekty head/tail
+		System.out.println("Dodaję elementy...");
+		imiona.add("Julia");
+		imiona.add("Ewelina");
+		System.out.println(imiona);
+		System.out.println(head1);
+		System.out.println(tail1);
+		System.out.println();
+		
+		System.out.println("head.add(Basia)");
+		head1.add("Basia");
+		System.out.println(imiona);
+		System.out.println(head1);
+		System.out.println(tail1);
+		System.out.println();
+		
+		System.out.println("head.remove(Ewa)");
+		System.out.println("head.remove(Magda)");
+		head1.remove("Ewa");
+		head1.remove("Zosia"); // nie ma takiego elementu, nie ma błędu
+		head1.remove("Magda"); // nie usuwa, nie ma błędu
+		System.out.println(imiona);
+		System.out.println(head1);
+		System.out.println(tail1);
+		System.out.println();		
+		
+		System.out.println("head.add(Zosia)");
+		head1.add("Zosia"); // IllegalArgumentException: key out of range
+		System.out.println(imiona);
+		System.out.println(head1);
+		System.out.println(tail1);
+		System.out.println();
+	}
+
+}

src/p12_kolekcje/b_set_map/Tree2.java

+package p12_kolekcje.b_set_map;
+
+import java.util.Arrays;
+import java.util.NavigableSet;
+import java.util.TreeSet;
+
+public class Tree2 {
+
+	public static void main(String[] args) {
+		
+		NavigableSet<String> imiona = new TreeSet<>(
+				Arrays.asList("Ala", "Ola", "Ula", "Ela", "Ewa", "Ania", "Kasia", "Aga", "Iwona", "Magda", "Iza"));
+
+		
+		System.out.println(imiona);
+		
+		System.out.println("first: " + imiona.first());
+		System.out.println("last : " + imiona.last());
+		
+		System.out.println(imiona);
+		System.out.println();
+		
+		System.out.println("pętla first / higher");
+		String s = imiona.first();
+		while(s != null) {
+			System.out.println(s);
+			s = imiona.higher(s);
+		}
+		System.out.println("========================");
+		System.out.println("pętla last / lower");
+		s = imiona.last();
+		while(s != null) {
+			System.out.println(s);
+			s = imiona.lower(s);
+		}
+		
+		System.out.println("========================");
+		System.out.println("pętla poll - usuwanie");
+		System.out.println("size: " + imiona.size());
+		
+		while((s = imiona.pollFirst()) != null) {
+			System.out.println(" # " + s);
+		}
+		
+		System.out.println("size: " + imiona.size());
+		// analogicznie pollLast()
+	}
+
+}

src/p12_kolekcje/b_set_map/ZbiorDziwnieSortowany.java

+package p12_kolekcje.b_set_map;
+
+import java.math.BigDecimal;
+import java.text.Collator;
+import java.util.HashSet;
+import java.util.Set;
+import java.util.TreeSet;
+
+public class ZbiorDziwnieSortowany {
+
+	public static void main(String[] args) {
+		TreeSet<String> normalny = new TreeSet<>();
+		TreeSet<String> alfabetyczny = new TreeSet<>(Collator.getInstance());
+		// TreeSet<String> alfabetyczny = new TreeSet<>(Collator.getInstance(new Locale("fr", "FR")));
+		TreeSet<String> dziwny = new TreeSet<>((a,b) -> a.length() - b.length());
+		
+		normalny.add("Ala");
+		alfabetyczny.add("Ala");
+		dziwny.add("Ala");
+
+		normalny.add("Ącki");
+		alfabetyczny.add("Ącki");
+		dziwny.add("Ącki");
+
+		normalny.add("Łucja");
+		alfabetyczny.add("Łucja");
+		dziwny.add("Łucja");
+
+		normalny.add("Wiktor");
+		alfabetyczny.add("Wiktor");
+		dziwny.add("Wiktor");
+
+		normalny.add("Hermenegilda");
+		alfabetyczny.add("Hermenegilda");
+		dziwny.add("Hermenegilda");
+		
+		normalny.add("Ola");
+		alfabetyczny.add("Ola");
+		dziwny.add("Ola");
+		
+		// Ola jest traktowana jak == Ala, bo comparator zwraca 0 gdy napisy są tej samej długości
+		// TreeSet i TreeMap nie uzywają equals do sprawdzenia czy elementy sa równe, ograniczają się do użycia compare albo compareTo
+
+		System.out.println(normalny);
+		System.out.println(alfabetyczny);
+		System.out.println(dziwny);
+		
+		System.out.println();
+		
+		System.out.println("Sprawa BigDecimal:");
+		BigDecimal[] liczby = {
+			new BigDecimal("123.00"),
+			new BigDecimal("123.0"),
+			new BigDecimal("123"),
+			new BigDecimal("124"),
+		};
+		
+		Set<BigDecimal> t = new TreeSet<>();
+		Set<BigDecimal> h = new HashSet<>();
+		for(BigDecimal b : liczby) {
+			t.add(b);
+			h.add(b);
+		}
+		
+		System.out.println("Tree: " + t);
+		System.out.println("Hash: " + h);
+	}
+}

src/p12_kolekcje/b_set_map/ZmianaKolejnosciWHaszSecie.java

+package p12_kolekcje.b_set_map;
+
+import java.util.Arrays;
+import java.util.HashSet;
+
+public class ZmianaKolejnosciWHaszSecie {
+
+	public static void main(String[] args) {
+		
+		HashSet<String> set = new HashSet<>();
+		
+		set.addAll(Arrays.asList("Ala", "Ola", "Ula", "Ela", "Ewa", "Ania", "Kasia", "Aga", "Iwona", "Magda", "Iza"));
+		
+		System.out.println(set.size());
+		System.out.println(set);
+		
+		set.add("Julia");
+		System.out.println(set.size());
+		System.out.println(set);
+
+		set.add("Ewelina");
+		System.out.println(set.size());
+		System.out.println(set);
+		
+//		for (String s : set) {
+//			int hash = s.hashCode();
+//			System.out.printf("%10s : hash = %10d , h%%16 = %2d , h%%32 = %2d\n",
+//					s, hash, hash%16, hash%32);
+//		}
+		
+	}
+
+}

src/p12_kolekcje/c_queue/KolejkaJakoStos.java

+package p12_kolekcje.c_queue;
+
+import java.util.ArrayDeque;
+
+public class KolejkaJakoStos {
+
+	public static void main(String[] args) {
+		ArrayDeque<Integer> stos = new ArrayDeque<>();
+		System.out.println(stos);
+		
+		for(int i = 1; i < 10; i++) {
+			System.out.println(i*i);
+			stos.push(i*i);
+		}
+		
+		System.out.println();
+		System.out.println(stos);
+		System.out.println();
+		
+		while(! stos.isEmpty()) {
+			Integer liczba = stos.pop();
+			System.out.println(liczba);
+		}
+	}
+}

src/p12_kolekcje/c_queue/Kolejki.java

+package p12_kolekcje.c_queue;
+
+import java.util.ArrayDeque;
+import java.util.PriorityQueue;
+import java.util.Queue;
+
+public class Kolejki {
+
+	public static void main(String[] args) {
+		Queue<String> kolejka; // ewentualnie Deque<String>
+		String elem;
+		
+		System.out.println("Kolejka prosta:"); // FIFO
+		kolejka = new ArrayDeque<>();
+		// kolejka = new LinkedList<>();
+		kolejka.add("ala");
+		kolejka.add("ola");
+		kolejka.add("ela");
+		kolejka.add("ula");
+		System.out.println("Cała: " + kolejka);
+		System.out.println("Dodaję aaa");
+		kolejka.add("aaa");
+		System.out.println(kolejka);
+
+		System.out.println("Wyjmuję w pętli:");
+		while((elem = kolejka.poll()) != null ) {
+			System.out.println(elem);
+		}
+
+		System.out.println("\nKolejka priorytetowa:");
+		kolejka = new PriorityQueue<>();
+		kolejka.add("ala");
+		kolejka.add("ola");
+		kolejka.add("ela");
+		kolejka.add("ula");
+		System.out.println("Cała: " + kolejka);
+
+		System.out.println("Dodaję aaa");
+		kolejka.add("aaa");
+		System.out.println(kolejka);
+		// jako pierwszy element w PriorityQueue występuje najmniejszy 
+		
+
+		System.out.println("Wyjmuję w pętli:");
+		while((elem = kolejka.poll()) != null) {
+			System.out.println(elem);	
+		}
+	}
+}

src/p12_kolekcje/c_queue/Kolejki_Operacje.java

+package p12_kolekcje.c_queue;
+
+import java.util.ArrayDeque;
+import java.util.Arrays;
+import java.util.Deque;
+
+public class Kolejki_Operacje {
+
+	public static void main(String[] args) {
+		Deque<String> kolejka = new ArrayDeque<String>(
+				Arrays.asList("Ala", "Ula", "Ola", "Kasia"));
+		
+		
+		System.out.println(kolejka);
+		
+		// odczyt bez usuwania, zwracają null jeśli kolejka jest pusta
+		System.out.println("peek / peekFirst / peekLast");
+		System.out.println(kolejka.peek());
+		System.out.println(kolejka.peekFirst());
+		System.out.println(kolejka.peekLast());
+		System.out.println();
+		
+		// odczyt bez usuwania, wyrzucają wyjątek jeśli kolejka jest pusta
+		System.out.println("element / getFirst / getLast");
+		System.out.println(kolejka.element());
+		System.out.println(kolejka.getFirst());
+		System.out.println(kolejka.getLast());
+		System.out.println();
+		
+		// dodawanie na końcu i na początku
+		kolejka.add("Zosia");
+		kolejka.addLast("Zuzia");
+		kolejka.addFirst("Ania");
+		System.out.println(kolejka);
+
+		kolejka.offer("Zosia 2");
+		kolejka.offerLast("Zuzia 2");
+		kolejka.offerFirst("Ania 2");
+		System.out.println(kolejka);
+		System.out.println();
+		
+		// usuwanie - poll zwracają null jeśli kolejka jest pusta
+		String s;
+		s = kolejka.poll(); // pobiera i usuwa pierwszy element
+		System.out.println(s);
+		s = kolejka.pollFirst();
+		System.out.println(s);
+		s = kolejka.pollLast();
+		System.out.println(s);
+		System.out.println();
+
+		// usuwanie - remove wyrzucają wyjątek jeśli kolejka jest pusta
+		s = kolejka.remove();
+		System.out.println(s);
+		s = kolejka.removeFirst();
+		System.out.println(s);
+		s = kolejka.removeLast();
+		System.out.println(s);
+		System.out.println();
+		
+		kolejka.add("Zosia");
+		kolejka.add("Ola");
+		System.out.println(kolejka);
+		// [Ola, Kasia, Zosia, Zuzia, Zosia, Ola]
+		
+		boolean b;
+		b = kolejka.remove("Ola"); // usuwa jedno wystąpienie, równoważne removeFirstOccurrence
+		System.out.println(kolejka);
+		
+		kolejka.removeLastOccurrence("Zosia");
+		System.out.println(kolejka);
+		
+	}
+}

src/p12_kolekcje/e_iterator/Iteratory.java

+package p12_kolekcje.e_iterator;
+
+import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.List;
+
+public class Iteratory {
+
+	// Kod jest napisany tak, jak pisało się w Javie 1.4
+	// Nie było generyków (trzeba rzutować)
+	// Nie było pętli for-each - trzeba używać iteratorów
+	
+	public static void main(String[] args) {
+		List lista = new LinkedList();
+		lista.add("ala");
+		lista.add("ola");
+		lista.add("ela");
+		lista.add("ula");
+		System.out.println("Na początku: " + lista);
+		
+		Iterator it = lista.iterator();
+		while(it.hasNext()) {
+			String element = (String)it.next();
+			System.out.println(element);
+			if("ela".equals(element)) {
+				it.remove();
+			}
+		}
+		
+		System.out.println("Na koniec: " + lista);
+	}
+}

src/p12_kolekcje/e_iterator/IteratoryListowe.java

+package p12_kolekcje.e_iterator;
+
+import java.util.ListIterator;
+import java.util.LinkedList;
+import java.util.List;
+
+public class IteratoryListowe {
+
+	// Iteratory wciąż mogą się przydać, najbardziej gdy używamy klasy LinkedList,
+	// bo w niej nie ma "random access" i właśnie za pomocą iteratora możemy 
+	// przeglądać listę i ją modyfikować "w locie"
+	public static void main(String[] args) {
+		List<String> lista = new LinkedList<>();
+		lista.add("ala");
+		lista.add("ola");
+		lista.add("ela");
+		lista.add("ula");
+		System.out.println("Na początku: " + lista);
+		
+		ListIterator<String> it = lista.listIterator();
+		
+		while(it.hasNext()) {
+			String element = it.next();
+			System.out.println(element);
+			if("ela".equals(element)) {
+				it.add("maja"); // za element bieżący, ale nowowstawione elementy nie będą odwiedzone przez ten iterator
+				it.add("gucio");
+			} else if("ola".equals(element)) {
+				it.set("Aleksandra");
+			} else if("ula".equals(element)) {
+				it.remove();
+			}
+		}
+		System.out.println();
+		
+		it = lista.listIterator(3);
+		while(it.hasPrevious()) {
+			System.out.println(it.previousIndex() + " " + it.previous());
+		}
+		
+		System.out.println("Na koniec: " + lista);
+	}
+}

src/p12_kolekcje/e_iterator/Konkurencja1.java

+package p12_kolekcje.e_iterator;
+
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+
+public class Konkurencja1 {
+
+	public static void main(String[] args) {
+		List<String> lista = new ArrayList<>();
+		lista.add("ala");
+		lista.add("ola");
+		lista.add("ela");
+		lista.add("ula");
+		System.out.println("Na początku: " + lista);
+
+		// można używać wielu iteratorów do odczytu kolekcji - to jest OK
+		Iterator<String> it1 = lista.iterator();
+		while(it1.hasNext()) {
+			String element = it1.next();
+			System.out.print(element);
+			
+			Iterator<String> it2 = lista.iterator();
+			while(it2.hasNext()) {
+				System.out.print(" " + it2.next().length());
+			}
+			System.out.println();
+		}
+	}
+
+}

src/p12_kolekcje/e_iterator/Konkurencja2.java

+package p12_kolekcje.e_iterator;
+
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+
+public class Konkurencja2 {
+
+	public static void main(String[] args) {
+		List<String> lista = new ArrayList<>();
+		lista.add("ala");
+		lista.add("ola");
+		lista.add("ela");
+		lista.add("ula");
+		System.out.println("Na początku: " + lista);
+
+		Iterator<String> it1 = lista.iterator();
+		while(it1.hasNext()) {
+			String element = it1.next();
+			System.out.print(element);
+			
+			Iterator<String> it2 = lista.iterator();
+			while(it2.hasNext()) {
+				String elem2 = it2.next();
+				System.out.print(" " + elem2.length());
+				if(elem2.charAt(0) == 'o') {
+					it2.remove();
+				}
+			}
+			System.out.println();
+		}
+		// Jesli uzywamy iterator (it1) a w tym czasie w inny sposób zmienimy kolekcję
+		// (np. innym iteratorem), to kolejna operacja na tym pierwszym iteratorze skończy sie wjątkiem ConcurrectModificationEx
+	}
+
+}

src/p12_kolekcje/e_iterator/Konkurencja3.java

+package p12_kolekcje.e_iterator;
+
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+
+public class Konkurencja3 {
+
+	public static void main(String[] args) {
+		List<String> lista = new ArrayList<>();
+		lista.add("ala");
+		lista.add("ola");
+		lista.add("ela");
+		lista.add("ula");
+		System.out.println("Na początku: " + lista);
+
+		
+		// wyjątek pojawia się także gdy modyfikujemy listę metodami add/remove
+		// w trakcie przeglądania jej jakimś iteratorem
+		Iterator<String> it = lista.iterator();
+		while(it.hasNext()) {
+			String element = it.next();
+			System.out.println(element);
+			if(element.charAt(0) == 'o') {
+				// lista.set(3, "Agata"); // to nie spowodowało błędu
+
+				lista.remove(2); // to psuje działanie pętli for-each
+				// lista.add("ewa"); // to też psuje
+				System.out.println("już usunąłem");
+				//break;
+			}
+		}
+		System.out.println("koniec");
+	}
+
+}

src/p12_kolekcje/e_iterator/Konkurencja4.java

+package p12_kolekcje.e_iterator;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class Konkurencja4 {
+
+	public static void main(String[] args) {
+		List<String> lista = new ArrayList<>();
+		lista.add("ala");
+		lista.add("ola");
+		lista.add("ela");
+		lista.add("ula");
+		System.out.println("Na początku: " + lista);
+		
+		// wyjątek pojawia się także gdy modyfikujemy listę metodami add/remove
+		// w trakcie przeglądania jej jakimś iteratorem
+		// pętla for-each ma w sobie zaszyty niejawny iterator
+		for (String element : lista) {
+			System.out.println(element);
+			if(element.charAt(0) == 'o') {
+				// lista.set(3, "Agata"); // to nie spowodowało błędu
+
+				lista.remove(2); // to psuje działanie pętli for-each
+				// lista.add("ewa"); // to też psuje
+				System.out.println("już usunąłem");
+			}
+		}
+	}
+
+}

src/p12_kolekcje/e_iterator/Konkurencja6.java

+package p12_kolekcje.e_iterator;
+
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+import java.util.ListIterator;
+
+public class Konkurencja6 {
+
+	public static void main(String[] args) {
+		List<String> lista = new ArrayList<>();
+		lista.add("Ala");
+		lista.add("Ola");
+		lista.add("Ela");
+		lista.add("Ula");
+		System.out.println(lista);
+		
+		String a, b, c;
+		
+		Iterator<String> it1 = lista.iterator();
+		a = it1.next();
+		System.out.println("it1 jest na pozycji " + a);
+		
+		ListIterator<String> it2 = lista.listIterator();
+		it2.next();
+		b = it2.next();
+		System.out.println("it2 jest na pozycji " + b);
+
+		a = it1.next();
+		a = it1.next();
+		System.out.println("it1 jest na pozycji " + a);
+		// dopóki tylko odczytujemy elementy kolekcji, można używać wielu iteratorów jednocześnie
+		System.out.println();
+
+		
+		it2.add("Jola");
+		// it2.remove();
+		// lista.add("Fasola");
+		System.out.println("dodałem nowy element za pomocą it2");
+		System.out.println(lista);
+		
+		try {
+			// Kolekcja została zmodyfikowana nie poprzez iterator it1.
+			// Teraz próba wykonania operacji poprzed it1 kończy się wyjątkiem.
+			
+			System.out.println("przesuwam it1");
+			a = it1.next();
+			System.out.println("it1 jest na pozycji " + a);
+		} catch (Exception e) {
+			System.out.println("Wyjątek " + e);
+		}
+
+	}
+
+}

src/p12_kolekcje/e_iterator/Konkurencja7a.java

+package p12_kolekcje.e_iterator;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class Konkurencja7a {
+
+	public static void main(String[] args) {
+		List<String> lista = new ArrayList<>();
+		lista.add("Ala");
+		lista.add("Ola");
+		lista.add("Ela");
+		lista.add("Ula");
+		System.out.println(lista);
+		
+		for (String s : lista) {
+			System.out.println(s);
+			if(s.equals("Ela")) {
+				lista.add("Nowy"); // EXN
+			}
+		}
+	}
+
+}

src/p12_kolekcje/e_iterator/Konkurencja7b.java

+package p12_kolekcje.e_iterator;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class Konkurencja7b {
+
+	public static void main(String[] args) {
+		List<String> lista = new ArrayList<>();
+		lista.add("Ala");
+		lista.add("Ola");
+		lista.add("Ela");
+		lista.add("Ula");
+		System.out.println(lista);
+		
+		for (String s : lista) {
+			System.out.println(s);
+			if(s.equals("Ela")) {
+				lista.set(3, "Urszula"); // nie powoduje błędu
+			}
+		}
+	}
+
+}

src/p12_kolekcje/s_sortowanie/KomparatorDlugosciNapisow.java

+package p12_kolekcje.s_sortowanie;
+
+import java.util.Comparator;
+
+public class KomparatorDlugosciNapisow implements Comparator<String> {
+	public int compare(String s1, String s2) {
+		/* Jeśli zwracam <0 to znaczy że s1 uważam za mniejsze.
+		 * Jeśli zwracam >0 to znaczy że s1 uważam za większe.
+		 * Jeśli zwracam 0 to znaczy, że są równe.
+		 */
+		return s1.length() - s2.length();
+	}
+}

src/p12_kolekcje/s_sortowanie/Sortowanie1.java

+package p12_kolekcje.s_sortowanie;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+
+public class Sortowanie1 {
+
+	public static void main(String[] args) {
+		String[] imiona = { "Ala", "Ola", "Iwona", "Magdalena", "Joanna", "Anna", "Teresa",
+				"Żaneta", "Ęcki", "Ącki", "Agnieszka", "ala", "Łucja", "Julia", "Julitta", "Zuzanna" };
+
+		List<String> lista = new ArrayList<>(Arrays.asList(imiona));
+		System.out.println(lista);
+
+		// dostępne "od początku" kolekcji w Javie
+		System.out.println("\nCollections.sort");
+		Collections.sort(lista);
+		System.out.println(lista);
+		// Domyślnie porównywanie Stringów bazuje na kodach Unicode poszczególnych znaków
+
+		System.out.println("\nCollections.shuffle");
+		Collections.shuffle(lista);
+		System.out.println(lista);
+
+		// Od Javy 8 można też tak:
+		System.out.println("\nlista.sort(null)");
+		lista.sort(null);
+		System.out.println(lista);	
+	}
+}

src/p12_kolekcje/s_sortowanie/Sortowanie2.java

+package p12_kolekcje.s_sortowanie;
+
+import java.text.Collator;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.List;
+import java.util.Locale;
+
+public class Sortowanie2 {
+	public static void main(String[] args) {
+		String[] imiona = { "Ala", "Ola", "Iwona", "Magdalena", "Joanna", "Anna", "Teresa",
+				"Żaneta", "Ęcki", "Ącki", "ala", "Agnieszka", "Łucja", "Julia", "Julitta", "Ela", "Zuzanna" };
+
+		List<String> lista = new ArrayList<>(Arrays.asList(imiona));
+		System.out.println(lista);
+
+		// Pierwszy sposób utworzenia komparatora: oddzielna klasa
+
+		System.out.println("\nlista.sort( komparator )");
+		// Collections.shuffle(lista);
+		KomparatorDlugosciNapisow komparator = new KomparatorDlugosciNapisow();
+		lista.sort(komparator);
+		System.out.println(lista);
+
+		System.out.println("\nCollections.sort( lista, komparator )");
+		Collections.sort(lista, komparator);
+		System.out.println(lista);
+
+		// Drugi sposób utworzenia komparatora: klasa anonimowa
+		// Składnia dostepna od początków Javy
+		System.out.println("\nlista.sort( klasa anonimowa )");
+		lista.sort(new Comparator<String>() {
+			public int compare(String s1, String s2) {
+				return s2.length() - s1.length();
+			}
+		});
+		System.out.println(lista);
+
+		// Trzeci sposób utworzenia komparatora:
+		// wyrażenie lambda (od Javy 8)
+		System.out.println("\nlista.sort( lambda )");
+		lista.sort((s1, s2) -> s1.length() - s2.length());
+		System.out.println(lista);
+
+		System.out.println("\nCollator");
+		lista.sort(Collator.getInstance());  // wg bieżących ustawień językowych w systemie
+		System.out.println(lista);
+		lista.sort(Collator.getInstance(Locale.CANADA_FRENCH));
+		System.out.println(lista);
+		lista.sort(Collator.getInstance(new Locale("pl", "PL")));
+		System.out.println(lista);
+	}
+}

src/p12_kolekcje/s_sortowanie/Sortowanie3.java

+package p12_kolekcje.s_sortowanie;
+
+import java.text.Collator;
+import java.util.Arrays;
+
+public class Sortowanie3 {
+
+	public static void main(String[] args) {
+		String[] imiona = { "Ala", "Ola", "Iwona", "Magdalena", "Joanna", "Anna", "Teresa",
+				"Żaneta", "Ęcki", "Ącki", "Agnieszka", "ala", "Łucja", "Julia", "Julitta", "Zuzanna" };
+		
+		System.out.println("Sortowanie tablicy");
+		System.out.println(Arrays.toString(imiona));
+		Arrays.sort(imiona);
+		System.out.println(Arrays.toString(imiona));		
+		Arrays.sort(imiona, Collator.getInstance()); // jako Comparator
+		System.out.println(Arrays.toString(imiona));				
+		Arrays.sort(imiona, (s1, s2) -> s1.length() - s2.length());
+		System.out.println(Arrays.toString(imiona));		
+	}
+}

src/p12_kolekcje/zbieranie_danych/ZbieranieDanych3_Queue.java

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

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

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

+package p12_kolekcje.zbieranie_danych;
+
+import java.util.Scanner;
+import java.util.Set;
+import java.util.TreeSet;
+
+public class ZbieranieDanych6_TreeSet {
+    // 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 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/p12_kolekcje/zbieranie_danych/ZbieranieDanych7_HashMap.java

+package p12_kolekcje.zbieranie_danych;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Scanner;
+
+public class ZbieranieDanych7_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.");
+            }
+		}
+	}
+
+}