poprawki w kolekcjach

src/main/java/gotowe/p25_kolekcje/a_list/PorownanieSzybkosciList.java

@@ -29,8 +29,9 @@ public class PorownanieSzybkosciList {
 		
 		System.out.println("\nDodawanie na początek... ");
 		start = System.currentTimeMillis();
+		Integer element = 333; // 333 jest elementem (wartością) a nie indeksem
 		for(int i=0; i < 10000; i++) {
-			lista.add(0, 333);  // 333 jest elementem (wartością) a nie indeksem
+			lista.add(0, element);
 			// Szybko dla LinkedList, wolno dla ArrayList
 		}
 		koniec = System.currentTimeMillis();

src/main/java/gotowe/p25_kolekcje/zbieranie_danych/P1_Tablica.java

+package gotowe.p25_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/main/java/gotowe/p25_kolekcje/zbieranie_danych/P2_Lista.java

+package gotowe.p25_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/main/java/gotowe/p25_kolekcje/zbieranie_danych/P2_Lista_Sortowanie.java

+package gotowe.p25_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/main/java/gotowe/p25_kolekcje/zbieranie_danych/P3_HashSet.java

+package gotowe.p25_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/main/java/gotowe/p25_kolekcje/zbieranie_danych/P4_TreeSet.java

+package gotowe.p25_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/main/java/gotowe/p25_kolekcje/zbieranie_danych/P5_HashMap.java

+package gotowe.p25_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/main/java/gotowe/p25_kolekcje/zbieranie_danych/P6_TreeMap.java

+package gotowe.p25_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/main/java/gotowe/p25_kolekcje/zbieranie_danych/P7_Queue.java

+package gotowe.p25_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/main/java/gotowe/p25_kolekcje/zbieranie_danych/P8_PriorityQueue.java

+package gotowe.p25_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");
+	}
+
+}