gotowe przykłady na streamy i nie tylko

src/main/java/emps/v1_nieobiektowo/P1_WypiszDane.java

+package emps.v1_nieobiektowo;
+
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.util.Scanner;
+
+// Program dla każdego pracownika wypisuje tekst postaci
+// Steven King (President) zarabia 24000
+public class P1_WypiszDane {
+
+	public static void main(String[] args) {
+		try(Scanner scanner = new Scanner(new File("emps.csv"))) {
+			while(scanner.hasNextLine()) {
+				String linia = scanner.nextLine();
+				// System.out.println(linia);
+				// String[] t = linia.split(";", -1);
+				String[] t = linia.split(";");
+				System.out.println(java.util.Arrays.toString(t));
+				// System.out.printf("Pracownik %s %s (%s) zarabia %s%n", t[1], t[2], t[3], t[4]);
+			}
+		} catch (FileNotFoundException e) {
+			e.printStackTrace();
+		}
+	}
+
+}

src/main/java/emps/v1_nieobiektowo/P2_WypiszWybranych.java

+package emps.v1_nieobiektowo;
+
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.util.Scanner;
+
+// Zadania:
+// P2_WypiszWybranych - wypisz tych pracowników, którzy zarabiają co najmniej 10 tys
+
+public class P2_WypiszWybranych {
+
+	public static void main(String[] args) {
+		final int limit = 10_000;
+		System.out.printf("Pracownicy zarabiający co najmniej %d:%n", limit);
+
+		try(Scanner scanner = new Scanner(new File("emps.csv"))) {
+			scanner.nextLine(); // aby pominąć pierwszą linię z tytułami kolumn
+			while(scanner.hasNextLine()) {
+				String linia = scanner.nextLine();
+				String[] t = linia.split(";");
+				int salary = Integer.parseInt(t[4]);
+				if(salary >= limit) {
+					System.out.printf("Pracownik %s %s (%s) zarabia %s%n", t[1], t[2], t[3], t[4]);
+				}
+			}
+		} catch (FileNotFoundException e) {
+			e.printStackTrace();
+		}
+	}
+
+}

src/main/java/emps/v1_nieobiektowo/P3_SredniaWszystkich.java

+package emps.v1_nieobiektowo;
+
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.util.Scanner;
+
+// P3_SredniaWszystkich - oblicz średnią pensję wszystkich pracowników
+
+public class P3_SredniaWszystkich {
+
+	public static void main(String[] args) {
+		try(Scanner scanner = new Scanner(new File("emps.csv"))) {
+			scanner.nextLine();
+			int suma = 0;
+			int ile = 0;
+			while(scanner.hasNextLine()) {
+				String linia = scanner.nextLine();
+				String[] t = linia.split(";");
+				int salary = Integer.parseInt(t[4]);
+				suma += salary;
+				ile++;
+			}
+			double srednia = (double)suma / ile;
+			System.out.println(srednia);
+		} catch (FileNotFoundException e) {
+			e.printStackTrace();
+		}
+	}
+
+}

src/main/java/emps/v1_nieobiektowo/P4_SredniaJedenJob.java

+package emps.v1_nieobiektowo;
+
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.util.Objects;
+import java.util.Scanner;
+
+import javax.swing.JOptionPane;
+
+// P4_SredniaJedenJob - użytkownik wpisuje nazwę stanowiska (np Programmer),
+//     a program oblicza liczbę pracowników oraz średnią pensję na tym stanowisku
+public class P4_SredniaJedenJob {
+
+	public static void main(String[] args) {
+		String szukanyJob = JOptionPane.showInputDialog("Podaj nazwę stanowiska");
+
+		try(Scanner scanner = new Scanner(new File("emps.csv"))) {
+		    scanner.nextLine();
+			double suma = 0;
+			int ile = 0;
+			while(scanner.hasNextLine()) {
+				String linia = scanner.nextLine();
+				String[] t = linia.split(";");
+				if(Objects.equals(t[3], szukanyJob)) {
+					suma += Integer.parseInt(t[4]);
+					ile++;
+				}
+			}
+			if(ile > 0) {
+				double srednia = suma / ile;
+				JOptionPane.showMessageDialog(null, String.format(
+						"Na stanowisku %s pracuje %d osób.\nŚrednia pensja wynosi %.2f",
+						szukanyJob, ile, srednia));
+			} else {
+				JOptionPane.showMessageDialog(null, String.format("Nikt nie pracuje na stanowisku %s.", szukanyJob),
+						"Brak danych", JOptionPane.WARNING_MESSAGE);
+			}
+		} catch (FileNotFoundException e) {
+			e.printStackTrace();
+		}
+	}
+
+}

src/main/java/emps/v1_nieobiektowo/SredniaProgramistow.java

+package emps.v1_nieobiektowo;
+
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.util.Scanner;
+
+public class SredniaProgramistow {
+
+	public static void main(String[] args) {
+		try(Scanner scanner = new Scanner(new File("emps.csv"))) {
+		    scanner.nextLine();
+		    int suma = 0;
+		    int ile = 0;
+			while(scanner.hasNextLine()) {
+				String linia = scanner.nextLine();
+				String[] t = linia.split(";");
+				if("Programmer".equals(t[3]) ) {
+				    suma += Integer.parseInt(t[4]);
+				    ile++;
+				}
+			}
+			double srednia = 1. * suma / ile;
+			System.out.println(srednia);
+		} catch (FileNotFoundException e) {
+			e.printStackTrace();
+		}
+	}
+
+}

src/main/java/emps/v2_obiektowo/Employee.java

+package emps.v2_obiektowo;
+
+import java.time.LocalDate;
+import java.util.Objects;
+
+public class Employee {
+    private int employeeId;
+    private String firstName;
+    private String lastName;
+    private String jobTitle;
+    private int salary;
+    private LocalDate hireDate;
+    private String departmentName;
+    private String address;
+    private String postalCode;
+    private String city;
+    private String country;
+
+    public Employee(int employeeId, String firstName, String lastName, String jobTitle, int salary, LocalDate hireDate,
+            String departmentName, String address, String postalCode, String city, String country) {
+        this.employeeId = employeeId;
+        this.firstName = firstName;
+        this.lastName = lastName;
+        this.jobTitle = jobTitle;
+        this.salary = salary;
+        this.hireDate = hireDate;
+        this.departmentName = departmentName;
+        this.address = address;
+        this.postalCode = postalCode;
+        this.city = city;
+        this.country = country;
+    }
+
+    public int getEmployeeId() {
+        return employeeId;
+    }
+
+    public void setEmployeeId(int employeeId) {
+        this.employeeId = employeeId;
+    }
+
+    public String getFirstName() {
+        return firstName;
+    }
+
+    public void setFirstName(String firstName) {
+        this.firstName = firstName;
+    }
+
+    public String getLastName() {
+        return lastName;
+    }
+
+    public void setLastName(String lastName) {
+        this.lastName = lastName;
+    }
+
+    public String getJobTitle() {
+        return jobTitle;
+    }
+
+    public void setJobTitle(String jobTitle) {
+        this.jobTitle = jobTitle;
+    }
+
+    public int getSalary() {
+        return salary;
+    }
+
+    public void setSalary(int salary) {
+        this.salary = salary;
+    }
+
+    public LocalDate getHireDate() {
+        return hireDate;
+    }
+
+    public void setHireDate(LocalDate hireDate) {
+        this.hireDate = hireDate;
+    }
+
+    public String getDepartmentName() {
+        return departmentName;
+    }
+
+    public void setDepartmentName(String departmentName) {
+        this.departmentName = departmentName;
+    }
+
+    public String getAddress() {
+        return address;
+    }
+
+    public void setAddress(String address) {
+        this.address = address;
+    }
+
+    public String getPostalCode() {
+        return postalCode;
+    }
+
+    public void setPostalCode(String postalCode) {
+        this.postalCode = postalCode;
+    }
+
+    public String getCity() {
+        return city;
+    }
+
+    public void setCity(String city) {
+        this.city = city;
+    }
+
+    public String getCountry() {
+        return country;
+    }
+
+    public void setCountry(String country) {
+        this.country = country;
+    }
+
+    @Override
+    public String toString() {
+        return "Employee [employeeId=" + employeeId + ", firstName=" + firstName + ", lastName=" + lastName
+                + ", jobTitle=" + jobTitle + ", salary=" + salary + ", hireDate=" + hireDate + ", departmentName="
+                + departmentName + ", address=" + address + ", postalCode=" + postalCode + ", city=" + city
+                + ", country=" + country + "]";
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(address, city, country, departmentName, employeeId, firstName, hireDate, jobTitle, lastName,
+                postalCode, salary);
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (this == obj)
+            return true;
+        if (obj == null)
+            return false;
+        if (getClass() != obj.getClass())
+            return false;
+        Employee other = (Employee) obj;
+        return Objects.equals(address, other.address) && Objects.equals(city, other.city)
+                && Objects.equals(country, other.country) && Objects.equals(departmentName, other.departmentName)
+                && employeeId == other.employeeId && Objects.equals(firstName, other.firstName)
+                && Objects.equals(hireDate, other.hireDate) && Objects.equals(jobTitle, other.jobTitle)
+                && Objects.equals(lastName, other.lastName) && Objects.equals(postalCode, other.postalCode)
+                && salary == other.salary;
+    }
+
+}

src/main/java/emps/v2_obiektowo/Grupowanie0.java

+package emps.v2_obiektowo;
+
+import java.util.List;
+import java.util.Set;
+import java.util.TreeSet;
+
+public class Grupowanie0 {
+// Wersja mało wydajna.
+// Dla każdego joba ponownie przeglądana jest cała lista pracowników.
+
+    public static void main(String[] args) {
+        List<Employee> emps = ObslugaCSV.wczytaj();
+        // etap 1: ustal zbiór jobów bez powtórzeń
+        Set<String> jobs = new TreeSet<>();
+        for(Employee emp : emps) {
+            jobs.add(emp.getJobTitle());
+        }
+        // System.out.println(jobs);
+
+        // etap 2: dla każdego joba przeglądamy listę emps i liczymy statystyki tych pracowników, którzy mają taki job
+        for(String job : jobs) {
+            double suma = 0;
+            int ile = 0;
+            for(Employee emp : emps) {
+                if(emp.getJobTitle().equals(job)) {
+                    suma += emp.getSalary();
+                    ile++;
+                }
+            }
+            double srednia = suma / ile;
+            System.out.printf("%32s | %2d | %8.2f\n", job, ile, srednia);
+        }
+
+    }
+
+}

src/main/java/emps/v2_obiektowo/Grupowanie1.java

+package emps.v2_obiektowo;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+public class Grupowanie1 {
+    // W tej wersji widzimy klasyczny algorytm "agregacji danych za pomocą slownika"
+    // Listę pracowników przeglądamy tylko raz, na bieżąco aktualizując słowniki.
+    // W tej wersji używamy tylko podstawowych operacji na kolekcjach (sprzed Java 8
+
+    public static void main(String[] args) {
+        List<Employee> emps = ObslugaCSV.wczytaj();
+
+        Map<String, Integer> sumy = new HashMap<>();
+        Map<String, Integer> ilosci = new HashMap<>();
+
+        for(Employee emp : emps) {
+            if(sumy.containsKey(emp.getJobTitle())) {
+                // gdy to jest kolejny pracownik ze stanowiska, które już występowało
+                int suma = sumy.get(emp.getJobTitle());
+                suma += emp.getSalary();
+                sumy.put(emp.getJobTitle(), suma);
+                int ile = ilosci.get(emp.getJobTitle());
+                ile += 1;
+                ilosci.put(emp.getJobTitle(), ile);
+            } else {
+                // gdy to jest pierwszy pracownik z danego stanowiska
+                sumy.put(emp.getJobTitle(), emp.getSalary());
+                ilosci.put(emp.getJobTitle(), 1);
+            }
+        }
+
+        for(String job : sumy.keySet()) {
+            int suma = sumy.get(job);
+            int ile = ilosci.get(job);
+            double srednia = (double)suma / ile;
+            System.out.printf("%32s | %2d | %8.2f\n", job, ile, srednia);
+        }
+
+    }
+
+}

src/main/java/emps/v2_obiektowo/Grupowanie1a.java

+package emps.v2_obiektowo;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+public class Grupowanie1a {
+
+    public static void main(String[] args) {
+        List<Employee> emps = ObslugaCSV.wczytaj();
+        Map<String, Integer> sumy = new HashMap<>();
+        Map<String, Integer> ilosci = new HashMap<>();
+
+        for(Employee emp : emps) {
+            String jobTitle = emp.getJobTitle();
+            if(sumy.containsKey(jobTitle)) {
+                // gdy to jest kolejny pracownik ze stanowiska, które już występowało
+                sumy.put(jobTitle, sumy.get(jobTitle) + emp.getSalary());
+                ilosci.put(jobTitle, ilosci.get(jobTitle) + 1);
+            } else {
+                // gdy to jest pierwszy pracownik z danego stanowiska
+                sumy.put(jobTitle, emp.getSalary());
+                ilosci.put(jobTitle, 1);
+            }
+        }
+
+        for(String job : sumy.keySet()) {
+            int suma = sumy.get(job);
+            int ile = ilosci.get(job);
+            double srednia = (double)suma / ile;
+            System.out.printf("%32s | %2d | %8.2f\n", job, ile, srednia);
+        }
+    }
+
+}

src/main/java/emps/v2_obiektowo/Grupowanie2.java

+package emps.v2_obiektowo;
+
+import java.util.List;
+import java.util.Map;
+import java.util.TreeMap;
+
+public class Grupowanie2 {
+	// W tej wersji używam operacji getOrDefault (od Java 8), dzięki czemu nie trzeba pisać if
+
+	public static void main(String[] args) {
+		List<Employee> emps = ObslugaCSV.wczytaj();
+
+		Map<String, Integer> sumy = new TreeMap<>();
+		Map<String, Integer> ilosci = new TreeMap<>();
+
+		for(Employee emp : emps) {
+			int suma = sumy.getOrDefault(emp.getJobTitle(), 0);
+			sumy.put(emp.getJobTitle(), suma + emp.getSalary());
+			int ile = ilosci.getOrDefault(emp.getJobTitle(), 0);
+			ilosci.put(emp.getJobTitle(), ile+1);
+		}
+
+		for(String job : sumy.keySet()) {
+			int suma = sumy.get(job);
+			int ile = ilosci.get(job);
+			double srednia = (double)suma / ile;
+			System.out.printf("| %-32s | %2d | %8.2f |%n", job, ile, srednia);
+		}
+	}
+
+}

src/main/java/emps/v2_obiektowo/Grupowanie2a.java

+package emps.v2_obiektowo;
+
+import java.util.List;
+import java.util.Map;
+import java.util.TreeMap;
+
+public class Grupowanie2a {
+	// W tej wersji używam operacji getOrDefault (od Java 8), dzięki czemu nie trzeba pisać if
+
+	public static void main(String[] args) {
+		List<Employee> emps = ObslugaCSV.wczytaj();
+		Map<String, Integer> sumy = new TreeMap<>();
+		Map<String, Integer> ilosci = new TreeMap<>();
+		for(Employee emp : emps) {
+			final String jobTitle = emp.getJobTitle();
+            sumy.put(jobTitle, sumy.getOrDefault(jobTitle, 0) + emp.getSalary());
+			ilosci.put(jobTitle, ilosci.getOrDefault(jobTitle, 0) + 1);
+		}
+
+		for(String job : sumy.keySet()) {
+			int suma = sumy.get(job);
+			int ile = ilosci.get(job);
+			double srednia = (double)suma / ile;
+			System.out.printf("| %-32s | %2d | %8.2f |%n", job, ile, srednia);
+		}
+	}
+
+}

src/main/java/emps/v2_obiektowo/Grupowanie3.java

+package emps.v2_obiektowo;
+
+import java.util.List;
+import java.util.Map;
+import java.util.TreeMap;
+
+public class Grupowanie3 {
+	// W tej wersji używam operacji putIfAbsent / computeIfPresent (można też użyć compute)
+
+	public static void main(String[] args) {
+		List<Employee> emps = ObslugaCSV.wczytaj("emps.csv");
+		Map<String, Integer> sumy = new TreeMap<>();
+		Map<String, Integer> ilosci = new TreeMap<>();
+
+		for(Employee emp : emps) {
+			// co wstawić w razie braku danych (gdy dane już są - krok jest pomijany)
+			sumy.putIfAbsent(emp.getJobTitle(), 0);
+			// w jaki sposób uzyskuje się nową wartość na podstawie klucza oraz starej wartości
+			sumy.computeIfPresent(emp.getJobTitle(), (job, staraSuma) -> staraSuma + emp.getSalary());
+
+			ilosci.putIfAbsent(emp.getJobTitle(), 0);
+			ilosci.computeIfPresent(emp.getJobTitle(), (job, staraIlosc) -> staraIlosc + 1);
+		}
+
+		sumy.keySet().forEach(job -> {
+			int suma = sumy.get(job);
+			int ile = ilosci.get(job);
+			double srednia = (double)suma / ile;
+			System.out.printf("| %-32s | %2d | %8.2f |%n", job, ile, srednia);
+		});
+	}
+
+}

src/main/java/emps/v2_obiektowo/Grupowanie4.java

+package emps.v2_obiektowo;
+
+import java.util.List;
+import java.util.Map;
+import java.util.TreeMap;
+
+public class Grupowanie4 {
+	// W tej wersji używam operacji merge (od Java 8), która został wymyślona dokładnie po to,
+	// aby rozwiązywać takie zadania, jak to.
+
+	// merge(KLUCZ, WARTOSC, FUNKCJA) działa tak:
+	// - jeśli w słowniku nie ma jeszcze niczego pod KLUCZem, to wstawiana jest tam WARTOSC
+	// - jeśli w słowniku pod KLUCZem jest STARA_WARTOSC, to wywoływana jest FUNKCJA(STARA_WARTOSC, WARTOSC)
+	//   a uzyskany wynik jest zapisywany z powrotem do słownika pod KLUCZ
+
+	public static void main(String[] args) {
+		List<Employee> emps = ObslugaCSV.wczytaj();
+		Map<String, Integer> sumy = new TreeMap<>();
+		Map<String, Integer> ilosci = new TreeMap<>();
+
+		for(Employee emp : emps) {
+			sumy.merge(emp.getJobTitle(), emp.getSalary(), Integer::sum);
+			ilosci.merge(emp.getJobTitle(), 1, Integer::sum);
+		}
+
+		for(String job : sumy.keySet()) {
+			int suma = sumy.get(job);
+			int ile = ilosci.get(job);
+			double srednia = (double)suma / ile;
+			System.out.printf("| %-32s | %2d | %8.2f |%n", job, ile, srednia);
+		}
+	}
+
+}

src/main/java/emps/v2_obiektowo/Grupowanie5.java

+package emps.v2_obiektowo;
+
+import java.util.List;
+import java.util.Map;
+import java.util.TreeMap;
+
+public class Grupowanie5 {
+
+	public static void main(String[] args) {
+		List<Employee> emps = ObslugaCSV.wczytaj();
+		Map<String, int[]> slownik = new TreeMap<>();
+
+		for(Employee emp : emps) {
+			if(slownik.containsKey(emp.getJobTitle())) {
+				// to jest kolejny pracownik z tego stanowiska → zwiększamy wartość w słowniku
+				int[] t = slownik.get(emp.getJobTitle());
+				t[0]++;
+				t[1] += emp.getSalary();
+				// dostaliśmy referencję do tablicy i gdy ją modyfikujemy, to słownik też to "widzi"
+			} else {
+				// to jest pierwszy pracownik z tego stanowiska → wpisujemy jego pensję jako wartość początkową
+				slownik.put(emp.getJobTitle(), new int[] {1, emp.getSalary()});
+			}
+		}
+
+		// przeglądamy "wpisy" w słowniku, czyli klucze wraz z wartościami
+		for(Map.Entry<String, int[]> entry : slownik.entrySet()) {
+			String job = entry.getKey();
+			int[] t = entry.getValue();
+			double srednia = (double)t[1] / t[0];
+			System.out.printf("%-32s | %2d | %8.2f\n", job, t[0], srednia);
+		}
+	}
+
+}

src/main/java/emps/v2_obiektowo/Grupowanie6.java

+package emps.v2_obiektowo;
+
+import java.util.List;
+import java.util.Map;
+import java.util.TreeMap;
+
+// Podejście obiektowe do grupowania.
+
+public class Grupowanie6 {
+
+	public static void main(String[] args) {
+		final List<Employee> emps = ObslugaCSV.wczytaj();
+		final Map<String, JobInfo> mapa = new TreeMap<>();
+
+		for(Employee emp : emps) {
+			final String jobTitle = emp.getJobTitle();
+			JobInfo jobInfo = mapa.get(jobTitle);
+			if(jobInfo == null) {
+				jobInfo = new JobInfo(jobTitle);
+				mapa.put(jobTitle, jobInfo);
+			}
+			jobInfo.update(emp);
+			// nie muszę robić put, bo operuję na tym samym obiekcie, który jest w slowniku (kwestia wskaźników/referncji)
+		}
+
+		for (JobInfo jobInfo : mapa.values()) {
+			System.out.println(jobInfo);
+		}
+	}
+
+	// Klasa zgnieżdżona - tylko dla przykładu.
+	// Równie dobrze mógłbym tę klase zdefiniować w osobnym pliku.
+
+	// Obiekt tej klasy przechowuje statystyki job
+	private static class JobInfo {
+		final String jobTitle;
+		int count = 0;
+		int sum = 0;
+		int min = Integer.MAX_VALUE;
+		int max = Integer.MIN_VALUE;
+
+		JobInfo(String jobTitle) {
+			this.jobTitle = jobTitle;
+		}
+
+		void update(Employee emp) {
+			int salary = emp.getSalary();
+			count++;
+			sum += salary;
+			if(salary < min) {
+				min = salary;
+			}
+			if(salary > max) {
+				max = salary;
+			}
+		}
+
+		double avg() {
+			return (double)sum / count;
+		}
+
+		@Override
+		public String toString() {
+			return "jobTitle=" + jobTitle + ", count=" + count + ", sum=" + sum + ", min=" + min + ", max="
+					+ max + ", avg=" + avg();
+		}
+	}
+}

src/main/java/emps/v2_obiektowo/MergeTlumaczenie.java

+package emps.v2_obiektowo;
+
+import java.util.List;
+import java.util.Map;
+import java.util.TreeMap;
+
+public class MergeTlumaczenie {
+
+    public static void main(String[] args) {
+        List<Employee> emps = ObslugaCSV.wczytaj();
+        Map<String, String> map = new TreeMap<>();
+        for(Employee emp : emps) {
+            // map.merge(emp.getDepartmentName(), emp.getLastName(), String::concat);
+            map.merge(emp.getDepartmentName(), emp.getLastName(), (str, name) -> str + ", " + name);
+        }
+        map.forEach((dep, names) -> System.out.println(dep + " → " + names));
+    }
+
+}

src/main/java/emps/v2_obiektowo/ObslugaCSV.java

+package emps.v2_obiektowo;
+
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.PrintWriter;
+import java.time.LocalDate;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Scanner;
+
+public class ObslugaCSV {
+	public static List<Employee> wczytaj() {
+		// używa domyślnego pliku
+		return wczytaj("emps.csv");
+	}
+
+	public static List<Employee> wczytaj(String sciezka) {
+		return wczytaj(new File(sciezka));
+	}
+
+	public static List<Employee> wczytaj(File plik) {
+		List<Employee> emps = new ArrayList<>();
+		try(Scanner scanner = new Scanner(plik)) {
+			scanner.nextLine(); // pomijamy pierwszą linię
+			while(scanner.hasNextLine()) {
+				String linia = scanner.nextLine();
+				String[] t = linia.split(";", -1);
+				Employee emp = new Employee(Integer.parseInt(t[0]), t[1], t[2], t[3],
+						Integer.parseInt(t[4]), LocalDate.parse(t[5]),
+						t[6], t[7], t[8], t[9], t[10]);
+				emps.add(emp);
+			}
+		} catch (FileNotFoundException e) {
+			e.printStackTrace();
+			// w razie błędu (brak pliku) wypiszemy czerwone teksty na ekran, ale nie przerwiemy programu, tylko zwrócimy pustą listę
+		}
+		return emps;
+	}
+
+	public static void zapisz(List<Employee> lista, File plik) {
+		try(PrintWriter out = new PrintWriter(plik)) {
+			out.println(
+					"employee_id;first_name;last_name;job_title;salary;hire_date;department_name;address;postal_code;city;country");
+			for(Employee emp : lista) {
+				out.printf("%d;%s;%s;%s;%d;%s;%s;%s;%s;%s;%s\n", emp.getEmployeeId(), emp.getFirstName(),
+						emp.getLastName(), emp.getJobTitle(), emp.getSalary(), emp.getHireDate(),
+						emp.getDepartmentName(), emp.getAddress(), emp.getPostalCode(), emp.getCity(),
+						emp.getCountry());
+			}
+		} catch (FileNotFoundException e) {
+			e.printStackTrace();
+		}
+	}
+
+	public static void zapisz(List<Employee> lista, String sciezka) {
+		zapisz(lista, new File(sciezka));
+	}
+
+	public static void zapisz(List<Employee> lista) {
+		zapisz(lista, "emps.csv");
+	}
+
+}

src/main/java/emps/v2_obiektowo/P0_WypiszWszystko.java

+package emps.v2_obiektowo;
+
+import java.util.List;
+
+public class P0_WypiszWszystko {
+
+    public static void main(String[] args) {
+        List<Employee> emps = ObslugaCSV.wczytaj("emps.csv");
+        System.out.println("Wczytano rekordów " + emps.size());
+        for(Employee emp : emps) {
+            System.out.println(emp);
+        }
+    }
+
+}

src/main/java/emps/v2_obiektowo/P1_WypiszWybranePola.java

+package emps.v2_obiektowo;
+
+import java.util.List;
+
+public class P1_WypiszWybranePola {
+
+    public static void main(String[] args) {
+        List<Employee> emps = ObslugaCSV.wczytaj("emps.csv");
+        System.out.println("Wczytano rekordów " + emps.size());
+        for(Employee emp : emps) {
+            System.out.println(emp.getFirstName() + " " + emp.getLastName() + " (" + emp.getJobTitle() + ") zarabia " + emp.getSalary());
+//            System.out.printf("%s %s (%s) zarabia %s%n",
+//                    emp.getFirstName(), emp.getLastName(), emp.getJobTitle(), + emp.getSalary());
+        }
+    }
+
+}

src/main/java/emps/v2_obiektowo/P2_WypiszBogatych.java

+package emps.v2_obiektowo;
+
+import java.util.List;
+
+// Wypisujemy dane pracowników zarabiających >= 10 tys
+public class P2_WypiszBogatych {
+
+	public static void main(String[] args) {
+		int limit = 10000;
+
+		List<Employee> emps = ObslugaCSV.wczytaj();
+		System.out.printf("Co najmniej %d zarbiają pracownicy:%n", limit);
+		for(Employee emp : emps) {
+			if(emp.getSalary() >= limit) {
+				System.out.printf(" * %s %s (%s) z pensją %s%n",
+					emp.getFirstName(), emp.getLastName(), emp.getJobTitle(), emp.getSalary());
+			}
+		}
+	}
+
+}

src/main/java/emps/v2_obiektowo/P3_SredniaWszystkich.java

+package emps.v2_obiektowo;
+
+import java.util.List;
+
+// P3_SredniaWszystkich - oblicz średnią pensję wszystkich pracowników
+
+public class P3_SredniaWszystkich {
+
+	public static void main(String[] args) {
+		List<Employee> emps = ObslugaCSV.wczytaj();
+		int suma = 0;
+		int ile = 0;
+		for(Employee emp : emps) {
+			suma += emp.getSalary();
+			ile++;
+		}
+		double srednia = 1. * suma / ile;
+		System.out.println(srednia);
+	}
+
+}

src/main/java/emps/v2_obiektowo/P4_SredniaJedenJob_v1.java

+package emps.v2_obiektowo;
+
+import java.util.List;
+import java.util.Objects;
+
+import javax.swing.JOptionPane;
+
+// P4_SredniaJedenJob - użytkownik wpisuje nazwę stanowiska (np Programmer),
+// a program oblicza liczbę pracowników oraz średnią pensję na tym stanowisku
+
+public class P4_SredniaJedenJob_v1 {
+
+	public static void main(String[] args) {
+		String szukanyJob = JOptionPane.showInputDialog("Podaj nazwę stanowiska");
+		List<Employee> emps = ObslugaCSV.wczytaj("emps.csv");
+		double suma = 0;
+		int ile = 0;
+		for(Employee emp : emps) {
+			if(Objects.equals(emp.getJobTitle(), szukanyJob)) {
+				suma += emp.getSalary();
+				ile++;
+			}
+		}
+
+		if(ile > 0) {
+			double srednia = suma / ile;
+			JOptionPane.showMessageDialog(null, String.format(
+					"Na stanowisku %s pracuje %d osób.\nŚrednia pensja wynosi %.2f",
+					szukanyJob, ile, srednia));
+		} else {
+			JOptionPane.showMessageDialog(null, String.format("Nikt nie pracuje na stanowisku %s.", szukanyJob),
+					"Brak danych", JOptionPane.WARNING_MESSAGE);
+		}
+	}
+}

src/main/java/emps/v2_obiektowo/P4_SredniaJedenJob_v2.java

+package emps.v2_obiektowo;
+
+import java.util.List;
+
+import javax.swing.JOptionPane;
+
+// P4_SredniaJedenJob - użytkownik wpisuje nazwę stanowiska (np Programmer),
+// a program oblicza liczbę pracowników oraz średnią pensję na tym stanowisku
+// v2 - w tej wersji w oknie dialogowym podajemy przykładową wartość Programmer
+// dodatkowo ignorujemy wielkość liter
+
+public class P4_SredniaJedenJob_v2 {
+
+	public static void main(String[] args) {
+		String szukanyJob = JOptionPane.showInputDialog("Podaj nazwę stanowiska", "Programmer");
+		if(szukanyJob == null)
+			return;
+
+		List<Employee> emps = ObslugaCSV.wczytaj();
+		double suma = 0;
+		int ile = 0;
+		for(Employee emp : emps) {
+			if(szukanyJob.equalsIgnoreCase(emp.getJobTitle())) {
+				suma += emp.getSalary();
+				ile++;
+			}
+		}
+		if(ile > 0) {
+			double srednia = suma / ile;
+			JOptionPane.showMessageDialog(null, String.format(
+					"Na stanowisku %s pracuje %d osób.\nŚrednia pensja wynosi %.2f",
+					szukanyJob, ile, srednia));
+		} else {
+			JOptionPane.showMessageDialog(null, String.format("Nikt nie pracuje na stanowisku %s.", szukanyJob),
+					"Brak danych", JOptionPane.WARNING_MESSAGE);
+		}
+	}
+}

src/main/java/emps/v2_obiektowo/P4_SredniaJedenJob_v3.java

+package emps.v2_obiektowo;
+
+import java.io.File;
+import java.util.List;
+import java.util.Set;
+import java.util.TreeSet;
+
+import javax.swing.JFileChooser;
+import javax.swing.JOptionPane;
+import javax.swing.filechooser.FileNameExtensionFilter;
+
+// P4_SredniaJedenJob - użytkownik wpisuje nazwę stanowiska (np Programmer),
+// a program oblicza liczbę pracowników oraz średnią pensję na tym stanowisku
+// v3 - w tej wersji w oknie dialogowym wyświetlamy listę z wyborem jobów
+
+public class P4_SredniaJedenJob_v3 {
+
+	public static void main(String[] args) {
+		JFileChooser chooser = new JFileChooser(".");
+		chooser.setFileFilter(new FileNameExtensionFilter("Pliki CSV", "csv", "txt"));
+		int coSieStalo = chooser.showOpenDialog(null);
+		if(coSieStalo != JFileChooser.APPROVE_OPTION)
+			return;
+		
+		File plik = chooser.getSelectedFile();
+		List<Employee> emps = ObslugaCSV.wczytaj(plik);
+		
+		Set<String> jobs = new TreeSet<>();
+		for(Employee emp : emps) {
+			jobs.add(emp.getJobTitle());
+		}
+		
+		String szukanyJob = (String)JOptionPane.showInputDialog(null, "Wybierz stanowisko", "Wybór",
+				JOptionPane.QUESTION_MESSAGE, null, jobs.toArray(), "Programmer");
+		if(szukanyJob == null)
+			return;
+		
+		double suma = 0;
+		int ile = 0;
+		for(Employee emp : emps) {
+			if(szukanyJob.equals(emp.getJobTitle())) {
+				suma += emp.getSalary();
+				ile++;
+			}
+		}
+
+		if(ile > 0) {
+			double srednia = suma / ile;
+			JOptionPane.showMessageDialog(null, String.format(
+					"Na stanowisku %s pracuje %d osób.\nŚrednia pensja wynosi %.2f",
+					szukanyJob, ile, srednia));
+		} else {
+			JOptionPane.showMessageDialog(null, String.format("Nikt nie pracuje na stanowisku %s.", szukanyJob),
+					"Brak danych", JOptionPane.WARNING_MESSAGE);
+		}
+	}
+}

src/main/java/emps/v2_obiektowo/P5_MiastaBezPowtorzen.java

+package emps.v2_obiektowo;
+
+import java.util.List;
+import java.util.Set;
+import java.util.TreeSet;
+
+// Wypisz bez powtórzeń nazwy miast pojawiające się w pliku
+
+public class P5_MiastaBezPowtorzen {
+
+	public static void main(String[] args) {
+		List<Employee> emps = ObslugaCSV.wczytaj("emps.csv");
+		Set<String> miasta = new TreeSet<>();
+		for(Employee emp : emps) {
+			miasta.add(emp.getCity());
+		}
+		
+		System.out.println("Liczba miast: " + miasta.size());
+		for(String miasto : miasta) {
+			System.out.println(miasto);
+		}
+	}
+
+}

src/main/java/emps/v2_obiektowo/P6_MinMax_v1.java

+package emps.v2_obiektowo;
+
+import java.util.List;
+
+public class P6_MinMax_v1 {
+	// Wypisz dane pracownika, który zarabia najwięcej, oraz pracownika, który zarabia najmniej.
+	// (wypisz co najmniej imię, nazwisko i pensję)
+
+	// w tym rozwiązaniu wypiszę wszystkie osoby, które zarabiają maksymalną /minimalną pensję, nawet gdyby było ich więcej
+	public static void main(String[] args) {
+		List<Employee> emps = ObslugaCSV.wczytaj();
+
+		// etap 1a: ustalam maksymalną pensję
+		int maxSalary = 0;
+		for(Employee emp : emps) {
+			if(emp.getSalary() > maxSalary) {
+				maxSalary = emp.getSalary();
+			}
+		}
+
+		// etap 1b: ustalam minimalną pensję
+		int minSalary = maxSalary;
+		for(Employee emp : emps) {
+			if(emp.getSalary() < minSalary) {
+				minSalary = emp.getSalary();
+			}
+		}
+
+		// etap 2: ponownie przeglądając dane szukam KTO tyle zarabia i go wypisuję
+		System.out.println("najbogatsi: (pensja " + maxSalary +"):");
+		for(Employee emp : emps) {
+			if(emp.getSalary() == maxSalary) {
+				System.out.println(emp);
+			}
+		}
+
+		System.out.println("najbiedniejsi: (pensja " + minSalary +"):");
+		for(Employee emp : emps) {
+			if(emp.getSalary() == minSalary) {
+				System.out.println(emp);
+			}
+		}
+	}
+
+}

src/main/java/emps/v2_obiektowo/P6_MinMax_v2.java

+package emps.v2_obiektowo;
+
+import java.util.List;
+
+public class P6_MinMax_v2 {
+	// Wypisz kto zarabia najwięcej, a kto zarabia najmniej.
+	// (wypisz co najmniej imię, nazwisko i pensję)
+
+	public static void main(String[] args) {
+		List<Employee> emps = ObslugaCSV.wczytaj("emps.csv");
+		
+		int maxSalary = 0; // Integer.MIN_VALUE
+		int minSalary = Integer.MAX_VALUE;
+		String min = "";
+		String max = "";
+		
+		for(Employee emp : emps) {
+			if(emp.getSalary() > maxSalary) {
+				maxSalary = emp.getSalary();
+				max = emp.getFirstName() + " " + emp.getLastName();
+			}
+			if(emp.getSalary() < minSalary) {
+				minSalary = emp.getSalary();
+				min = emp.getFirstName() + " " + emp.getLastName();
+			}
+		}
+		
+		System.out.println("Najbogatszy: " + max + " " + maxSalary);
+		System.out.println("Najbiedniejszy: " + min + " " + minSalary);
+	}
+
+}

src/main/java/emps/v2_obiektowo/P6_MinMax_v3.java

+package emps.v2_obiektowo;
+
+import java.util.List;
+
+public class P6_MinMax_v3 {
+
+	public static void main(String[] args) {
+		List<Employee> emps = ObslugaCSV.wczytaj("emps.csv");
+		Employee max = null;
+		Employee min = null;
+
+		for(Employee emp : emps) {
+			if(max == null || emp.getSalary() > max.getSalary()) {
+				max = emp;
+			}
+			if(min == null || emp.getSalary() < min.getSalary()) {
+				min = emp;
+			}
+		}
+
+		System.out.println("Najbogatszy: " + max.getFirstName() + " " + max.getLastName() + " " + max.getSalary());
+		System.out.println("Najbiedniejszy: " + min.getFirstName() + " " + min.getLastName() + " " + min.getSalary());
+	}
+
+}

src/main/java/emps/v2_obiektowo/P6_MinMax_v4.java

+package emps.v2_obiektowo;
+
+import java.util.List;
+
+public class P6_MinMax_v4 {
+
+	public static void main(String[] args) {
+		List<Employee> emps = ObslugaCSV.wczytaj("emps.csv");
+		Employee max = emps.get(0); // od Java 21 mamy też: emps.getFirst();
+		Employee min = max;
+
+		for(Employee emp : emps) {
+			if(emp.getSalary() > max.getSalary()) {
+				max = emp;
+			}
+			if(emp.getSalary() < min.getSalary()) {
+				min = emp;
+			}
+		}
+		System.out.println("Najbogatszy: " + max.getFirstName() + " " + max.getLastName() + " " + max.getSalary());
+		System.out.println("Najbiedniejszy: " + min.getFirstName() + " " + min.getLastName() + " " + min.getSalary());
+	}
+
+}

src/main/java/emps/v2_obiektowo/P7_Sortowanie.java

+package emps.v2_obiektowo;
+
+import java.util.Comparator;
+import java.util.List;
+
+// P7 - wypisz pracowników posortowanych wg pensji rosnąco
+public class P7_Sortowanie {
+
+	public static void main(String[] args) {
+		List<Employee> emps = ObslugaCSV.wczytaj("emps.csv");
+
+		// takie sortowanie zadziałałoby tylko, gdyby klasa Employee implementowała Comparable
+//		emps.sort(null);
+
+		// Podejście do definiowania Comparatora oraz do samego sortowania sprzed Java 8
+		// "klasa anonimowa"
+//		Comparator<Employee> c = new Comparator<Employee>() {
+//            public int compare(Employee emp1, Employee emp2) {
+//                return emp2.getSalary() - emp1.getSalary();
+//            }
+//      };
+//		Collections.sort(emps, c);
+
+		// tutaj comparator zdefiniuję za pomocą wyrażenia lambda.
+//		emps.sort((emp1, emp2) -> emp2.getSalary() - emp1.getSalary());
+
+		// metoda compare z klas Integer, Long, Float, Double jest bardziej ogólnym sposobem porównania
+		// niż odejmowanie - jest odporna na integer overflow oraz działa dla liczb z ułamkiem
+//		emps.sort((emp1, emp2) -> -Integer.compare(emp1.getSalary(), emp2.getSalary()));
+
+		// można też napisać to bardziej wprost:
+		// posortuj obiekty Employee ze względu na ich pesję. odwrotnie
+		emps.sort(Comparator.comparingInt(Employee::getSalary).reversed());
+
+		for(Employee emp : emps) {
+		    System.out.printf(" * %s %s (%s) z pensją %s%n",
+                    emp.getFirstName(), emp.getLastName(), emp.getJobTitle(), emp.getSalary());
+		}
+		System.out.println();
+
+		System.out.println("Najbiednieszy: " + emps.getFirst());
+		System.out.println("Najbogatszy: " + emps.getLast());
+	}
+
+}
+

src/main/java/emps/v2_obiektowo/P9_Podwyzka.java

+package emps.v2_obiektowo;
+
+import java.util.List;
+import java.util.Scanner;
+
+public class P9_Podwyzka {
+
+	public static void main(String[] args) {
+	    Scanner sc = new Scanner(System.in);
+		List<Employee> emps = ObslugaCSV.wczytaj("emps.csv");
+		System.out.println("Podaj nazwę stanowiska: ");
+		String szukanyJob = sc.nextLine();
+		System.out.println("Podaj kwotę podwyżki: ");
+		int podwyzka = sc.nextInt();
+		int ile = 0;
+
+		for(Employee emp : emps) {
+			if(emp.getJobTitle().equalsIgnoreCase(szukanyJob)) {
+				emp.setSalary(emp.getSalary() + podwyzka);
+				ile++;
+			}
+		}
+		ObslugaCSV.zapisz(emps, "zmieniony.csv");
+		System.out.println("Zmieniono " + ile + " rekordów");
+	}
+
+}
+
+// W tej wersji klasa Employee jest "mutowalna" i można zmieniś salary w obiektach,
+// a następnie zapisać ała listę do pliku.
+

src/main/java/emps/v2_obiektowo/P9_PodwyzkaOkienkowa.java

+package emps.v2_obiektowo;
+
+import java.io.File;
+import java.util.List;
+
+import javax.swing.JFileChooser;
+import javax.swing.JOptionPane;
+
+public class P9_PodwyzkaOkienkowa {
+
+	public static void main(String[] args) {
+		JFileChooser chooser = new JFileChooser(".");
+		int coSieStalo = chooser.showOpenDialog(null);
+		if(coSieStalo != JFileChooser.APPROVE_OPTION) {
+			// jeśli nie wybrano pliku
+			return;
+		}
+		File plikWejsciowy = chooser.getSelectedFile();
+		
+		List<Employee> emps = ObslugaCSV.wczytaj(plikWejsciowy);
+		
+		String[] jobs = emps.stream()
+				.map(Employee::getJobTitle)
+				.distinct()
+				.sorted()
+				.toArray(String[]::new);
+		
+		String szukanyJob = (String)JOptionPane.showInputDialog(null, "Wybierz nazwę stanowiska", "Wybierz",
+				JOptionPane.QUESTION_MESSAGE, null, jobs, null);
+		
+		int podwyzka = Integer.parseInt(JOptionPane.showInputDialog("Podaj kwotę podwyżki"));
+		int ile = 0;
+		
+		for(Employee emp : emps) {
+			if(emp.getJobTitle().equals(szukanyJob)) {
+				emp.setSalary(emp.getSalary() + podwyzka);
+				ile++;
+			}
+		}
+		chooser.showSaveDialog(null);
+		if(coSieStalo != JFileChooser.APPROVE_OPTION) {
+			return;
+		}
+		File plikWyjsciowy = chooser.getSelectedFile();
+		ObslugaCSV.zapisz(emps, plikWyjsciowy);
+		JOptionPane.showMessageDialog(null, "Zmieniono " + ile + " rekordów");
+	}
+
+}

src/main/java/emps/v2_obiektowo/Samochod.java

+package emps.v2_obiektowo;
+
+public class Samochod {
+    private String marka, model;
+    private String nrRejstracyjny;
+    private double moc;
+    
+    public Samochod(String marka, String model, String nrRejstracyjny, double moc) {
+        this.marka = marka;
+        this.model = model;
+        this.nrRejstracyjny = nrRejstracyjny;
+        this.moc = moc;
+    }
+    
+    @Override
+    public String toString() {
+        return "Samochod [marka=" + marka + ", model=" + model + ", nrRejstracyjny=" + nrRejstracyjny + ", moc=" + moc + "]";
+    }
+
+    public String getMarka() {
+        return marka;
+    }
+
+    public void setMarka(String marka) {
+        this.marka = marka;
+    }
+
+    public String getModel() {
+        return model;
+    }
+
+    public void setModel(String model) {
+        this.model = model;
+    }
+
+    public String getNrRejstracyjny() {
+        return nrRejstracyjny;
+    }
+
+    public void setNrRejstracyjny(String nrRejstracyjny) {
+        this.nrRejstracyjny = nrRejstracyjny;
+    }
+
+    public double getMoc() {
+        return moc;
+    }
+
+    public void setMoc(double moc) {
+        this.moc = moc;
+    }
+
+}
+
+// Lombok - biblioteka, która automatycznie generuje gettery itd na podstawie adnotacji

src/main/java/emps/v2_obiektowo/zadania.txt

+/* Zadania do zrobienia:
+ *
+ * P2 - wypisz pracowników, którzy zarabiają ≥ 10 tysięcy
+ * P3 - średnia pensja w całej firmie
+ * P4 - program pyta o nazwę stanowiska i liczy średnią pensję na podanym stanowisku
+ * P5 - wypisz nazwy miast bez powtórzeń
+ * P6 - wypisz dane pracownika, który zarabia najwięcej, oraz tego, który zarabia najmniej
+ * P7 - posortuj pracowników malejąco wg pensji
+ * P9 - podwyżka - program pyta o nazwę stanowiska oraz o zmianę pensji (kwotowo)
+ *      i zapisuje do nowego(!) pliku dane wszystkich pracowników, ale dla podanego joba zmienia pensję o podaną kwotę
+ *
+ * Grupowanie - dla każdego joba występującego w pliku wypisz,
+ * ilu pracowników ma takie stanowsko i jaka jest ich średnia pensja.
+ *
+ select job_id, job_title, count(*), round(avg(salary)) from jobs join employees using(job_id) group by job_id;
+ */

src/main/java/emps/v3_funkcyjnie/CzegoSieNieDaWLambdach.java

+package emps.v3_funkcyjnie;
+
+import java.io.FileNotFoundException;
+import java.util.List;
+import java.util.concurrent.atomic.AtomicInteger;
+
+public class CzegoSieNieDaWLambdach {
+	static int sumaStatyczna = 0;
+
+	public static void main(String[] args) throws FileNotFoundException {
+		List<Employee> emps = ObslugaCSV.wczytaj();
+
+		// czy damy radę obliczyć sumę pensji za pomocą tego nowego forEach?
+		int sumaLokalna = 0;
+		int[] tablica = {0};
+		AtomicInteger ai = new AtomicInteger();
+
+		emps.forEach(emp -> {
+			// wewnątrz wyrażeń lambda nie wolno modyfikować zmiennych lokalnych
+			// zdefiniowanych przed tym wyrażeniem
+			// ograniczenie "effectively final"
+			// sumaLokalna += emp.getSalary();
+
+			// bardzo brzydkie, ale działa:
+			sumaStatyczna += emp.getSalary();
+			tablica[0] += emp.getSalary();
+			// ai.incrementAndGet(); // ++
+			ai.addAndGet(emp.getSalary()); // +=
+		});
+
+		System.out.println(sumaLokalna);
+		System.out.println(sumaStatyczna);
+		System.out.println(tablica[0]);
+		System.out.println(ai);
+		System.out.println();
+
+		// właściwe podejście w stylu funkcyjnym:
+		int suma = emps.stream().mapToInt(Employee::getSalary).sum();
+		System.out.println(suma);
+	}
+}

src/main/java/emps/v3_funkcyjnie/DaneOpcjonalne.java

+package emps.v3_funkcyjnie;
+
+import java.io.FileNotFoundException;
+import java.util.Comparator;
+import java.util.List;
+import java.util.Optional;
+import java.util.OptionalDouble;
+import java.util.Scanner;
+
+public class DaneOpcjonalne {
+
+	public static void main(String[] args) throws FileNotFoundException {
+		// Użytkownik podaje nazwę miasta, a program filtruje dane wczytane z pliku
+		// i oblicza średnią pensję oraz znajduje najbogatszego i najbiedniejszego pracownika.
+		// Przykład ma pokazać, jak można wykorzystać wyniki typu Optional.
+		Scanner scanner = new Scanner(System.in);
+		System.out.print("Podaj nazwę miasta: ");
+		String miasto = scanner.nextLine();
+
+		List<Employee> emps = ObslugaCSV.wczytaj();
+
+		OptionalDouble srednia = emps.stream()
+				.filter(emp -> emp.getCity().equals(miasto))
+				.mapToInt(Employee::getSalary)
+				.average();
+
+		Optional<Employee> min = emps.stream()
+				.filter(emp -> emp.getCity().equals(miasto))
+				.min(Comparator.comparingInt(Employee::getSalary));
+
+		Optional<Employee> max = emps.stream()
+				.filter(emp -> emp.getCity().equals(miasto))
+				.max(Comparator.comparingInt(Employee::getSalary));
+
+		System.out.println("średnia" + srednia);
+		System.out.println("min: " + min);
+		System.out.println("max: " + max);
+		System.out.println();
+
+		// Za pomocą isPresent / isEmpty można sprawdzać, czy obiekt zawiera wartość
+		if(srednia.isPresent()) {
+			// aby wydobyć liczbę z obiektu, piszemy getAsDouble (w przypadku pustego Optionala kończy się to błędem)
+			System.out.println("Średnia pensja = " + srednia.getAsDouble());
+		} else {
+			System.out.println("Brak danych");
+		}
+		System.out.println();
+
+		if(min.isPresent()) {
+			// aby dostać się do obiektu wewnątrz Optionala, piszemy get(); w razie braku danych powoduje to błąd
+			Employee emp = min.get();
+			System.out.println("Najbiedniejszy: " + emp.getFirstName() + " " + emp.getLastName() + " z pensją " + emp.getSalary());
+		} else {
+			System.out.println("Brak danych");
+		}
+
+		if(max.isEmpty()) {
+			System.out.println("Brak danych");
+		} else {
+			Employee emp = max.get();
+			System.out.println("Najbogatszy: " + emp.getFirstName() + " " + emp.getLastName() + " z pensją " + emp.getSalary());
+		}
+		System.out.println();
+
+		// Operacja orElse zwraca wartość z wnętrza Optionala, a w razie braku danych zwraca wartość alternatywną podaną w nawiasach
+		System.out.println("srednia.orElse(0) = " + srednia.orElse(0));
+		System.out.println("srednia.orElse(NaN) = " + srednia.orElse(Double.NaN));
+
+		// W przypadku obiektów użycie orElse wymagałoby posiadania "domyślnego pracownika", ew. można wstawić nulla
+		Employee fejkowy = new Employee(0, "Fejkowy", "Pracownik", "nikt", -1, null, "", "", "", "", "nieznany kraj");
+		System.out.println("najbiedniejszy lub zmyślony:");
+		System.out.println(min.orElse(fejkowy));
+
+		System.out.println("najbogatszy lub null:");
+		System.out.println(max.orElse(null));
+		System.out.println();
+
+		// Domyślnym wyjątkiem wyrzucanym w razie braku danych gdy robimy get jest NoSuchElementException
+		// System.out.println("Najbogatsza osoba to " + max.get().getLastName());
+
+		// ale możemy wyrzuć własny dedykowany wyjątek
+		// Podajemy to w formie lambdy, aby kod tworzący wyjątek został wykonany tylko wtedy, gdy jest naprawdę potrzebny
+//		String nazwisko = max.orElseThrow(() -> new RuntimeException("wielka bieda")).getLastName();
+//		System.out.println("Najbogatsza osoba to " + nazwisko);
+
+		// Na obiektach Optional (i w mniejszym stoniu na ich wersjach liczbowych) można wykonywać operacje
+		// przypominające operacje na strumieniach.
+		// Operacja map z Optionala jednego typu jest w stanie utworzyc Optional innego typu
+		// Na podstawie Optional<Employee> utworzymy Optional<String> zawierający dane pracownika
+		Optional<String> minTXT = min.map(emp -> "Najbiednieszy jest " + emp.getFirstName() + " " + emp.getLastName());
+		// Jeśli min był pusty, to minTXT też będzie pusty
+		// Jeśli min zawierał dane pracownika, to minTXT będzie zawierał tekst z imieniem i nazwiskiem pracownika
+		System.out.println("Optional<String>: " + minTXT);
+
+		// Można to wykorzystać w zapisie typu pipeline w taki sposób:
+		String maxTXT = emps.stream()
+				.filter(emp -> emp.getCity().equals(miasto))
+				.max(Comparator.comparingInt(Employee::getSalary))
+				.map(emp -> "Najbogatszy jest " + emp.getFirstName() + " " + emp.getLastName())
+				.orElse("Brak danych najbogatszego");
+
+		System.out.println("maxTXT: " + maxTXT);
+
+		// czasami może się zdarzyć, że wartość alternatywna jest obliczana w trakcie działania programu
+		// aby uniknąć niepotrzebnego obliczania (aby robić to tylko w przypadku braku danych), można podać wyrażenie lambda tworzące ten wynik
+
+		String maxTXT2 = emps.stream()
+				.filter(emp -> emp.getCity().equals(miasto))
+				.max(Comparator.comparingInt(Employee::getSalary))
+				.map(emp -> "Najbogatszy jest " + emp.getFirstName() + " " + emp.getLastName())
+				.orElseGet(() -> "Brak najbogatszego w mieście " + miasto);
+
+		System.out.println("maxTXT2: " + maxTXT2);
+
+		// Można też podać akcję, która zostanie wykonana tylko, gdy optional nie jest pusty
+		min.ifPresent(emp -> System.out.println("Znaleziony najbiedniejszy pracownik! - " + emp.getFirstName() + " " + emp.getLastName()));
+
+		// wersja z else (co zrobić w razie braku danych)
+		max.ifPresentOrElse(
+				emp -> System.out.println("Znaleziony najbogatszy pracownik! - " + emp.getFirstName() + " " + emp.getLastName()),
+				() -> System.out.println("Nie znaleziomo najbogatszego!"));
+
+		// oczywiście można to zastosować na końcu pipeline
+		emps.stream()
+				.filter(emp -> emp.getCity().equals(miasto))
+				.mapToInt(Employee::getSalary)
+				.average()
+				.ifPresentOrElse(
+						avg -> System.out.println("Jest średnia " + avg),
+						() -> System.out.println("Nie ma średniej"));
+	}
+
+}

src/main/java/emps/v3_funkcyjnie/Employee.java

+package emps.v3_funkcyjnie;
+
+import java.time.LocalDate;
+import java.util.Objects;
+
+public class Employee {
+    private int employeeId;
+    private String firstName;
+    private String lastName;
+    private String jobTitle;
+    private int salary;
+    private LocalDate hireDate;
+    private String departmentName;
+    private String address;
+    private String postalCode;
+    private String city;
+    private String country;
+
+    public Employee(int employeeId, String firstName, String lastName, String jobTitle, int salary, LocalDate hireDate,
+            String departmentName, String address, String postalCode, String city, String country) {
+        this.employeeId = employeeId;
+        this.firstName = firstName;
+        this.lastName = lastName;
+        this.jobTitle = jobTitle;
+        this.salary = salary;
+        this.hireDate = hireDate;
+        this.departmentName = departmentName;
+        this.address = address;
+        this.postalCode = postalCode;
+        this.city = city;
+        this.country = country;
+    }
+
+    public int getEmployeeId() {
+        return employeeId;
+    }
+
+    public void setEmployeeId(int employeeId) {
+        this.employeeId = employeeId;
+    }
+
+    public String getFirstName() {
+        return firstName;
+    }
+
+    public void setFirstName(String firstName) {
+        this.firstName = firstName;
+    }
+
+    public String getLastName() {
+        return lastName;
+    }
+
+    public void setLastName(String lastName) {
+        this.lastName = lastName;
+    }
+
+    public String getJobTitle() {
+        return jobTitle;
+    }
+
+    public void setJobTitle(String jobTitle) {
+        this.jobTitle = jobTitle;
+    }
+
+    public int getSalary() {
+        return salary;
+    }
+
+    public void setSalary(int salary) {
+        this.salary = salary;
+    }
+
+    public LocalDate getHireDate() {
+        return hireDate;
+    }
+
+    public void setHireDate(LocalDate hireDate) {
+        this.hireDate = hireDate;
+    }
+
+    public String getDepartmentName() {
+        return departmentName;
+    }
+
+    public void setDepartmentName(String departmentName) {
+        this.departmentName = departmentName;
+    }
+
+    public String getAddress() {
+        return address;
+    }
+
+    public void setAddress(String address) {
+        this.address = address;
+    }
+
+    public String getPostalCode() {
+        return postalCode;
+    }
+
+    public void setPostalCode(String postalCode) {
+        this.postalCode = postalCode;
+    }
+
+    public String getCity() {
+        return city;
+    }
+
+    public void setCity(String city) {
+        this.city = city;
+    }
+
+    public String getCountry() {
+        return country;
+    }
+
+    public void setCountry(String country) {
+        this.country = country;
+    }
+
+    @Override
+    public String toString() {
+        return "Employee [employeeId=" + employeeId + ", firstName=" + firstName + ", lastName=" + lastName
+                + ", jobTitle=" + jobTitle + ", salary=" + salary + ", hireDate=" + hireDate + ", departmentName="
+                + departmentName + ", address=" + address + ", postalCode=" + postalCode + ", city=" + city
+                + ", country=" + country + "]";
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(address, city, country, departmentName, employeeId, firstName, hireDate, jobTitle, lastName,
+                postalCode, salary);
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (this == obj)
+            return true;
+        if (obj == null)
+            return false;
+        if (getClass() != obj.getClass())
+            return false;
+        Employee other = (Employee) obj;
+        return Objects.equals(address, other.address) && Objects.equals(city, other.city)
+                && Objects.equals(country, other.country) && Objects.equals(departmentName, other.departmentName)
+                && employeeId == other.employeeId && Objects.equals(firstName, other.firstName)
+                && Objects.equals(hireDate, other.hireDate) && Objects.equals(jobTitle, other.jobTitle)
+                && Objects.equals(lastName, other.lastName) && Objects.equals(postalCode, other.postalCode)
+                && salary == other.salary;
+    }
+
+}

src/main/java/emps/v3_funkcyjnie/F0_WypiszWszystko.java

+package emps.v3_funkcyjnie;
+
+import java.util.List;
+
+public class F0_WypiszWszystko {
+
+	public static void main(String[] args) {
+		List<Employee> emps = ObslugaCSV.wczytaj();
+
+		// Aby zrobić coś dla każdego elementu listy, np. wypisać na ekran,
+		// można użyć operacji forEach.
+		// Do forEach można przekazać wyrażenie lambda mówiące, co zrobić z każdym elementem.
+		// emps.forEach(emp -> System.out.println(emp));
+
+		// W przypadku, gdy operacja sprowadza się do wywołania konkretnej metody, można użyć notacji "method reference".
+		emps.forEach(System.out::println);
+
+		// Można też najpierw pobrać "strumień" i dopiero na strumienia wywołać forEach, ale tu nie jest to konieczne.
+		// emps.stream().forEach(System.out::println);
+	}
+
+}

src/main/java/emps/v3_funkcyjnie/F1_WypiszDane.java

+package emps.v3_funkcyjnie;
+
+import java.util.List;
+
+public class F1_WypiszDane {
+
+	public static void main(String[] args) {
+		List<Employee> emps = ObslugaCSV.wczytaj("emps.csv");
+
+		// Cel: wypisać wybrane pola.
+		// Sposób 1: w wyrażeniu lambda napisać printa, który wypisuje wybrane rzeczy
+		// emps.forEach(emp -> System.out.println(emp.getFirstName() + " " + emp.getLastName() + " " + emp.getSalary()));
+
+		// Sposób 2, oparty o stream: najpierw mapujemy obiekty Employee na Stringi, a następnie wypisujemy te Stringi
+		emps.stream()
+			.map(emp -> emp.getFirstName() + " " + emp.getLastName() + " " + emp.getSalary())
+			.forEach(System.out::println);
+	}
+
+}

src/main/java/emps/v3_funkcyjnie/F2_Filtrowanie.java

+package emps.v3_funkcyjnie;
+
+import java.util.Comparator;
+import java.util.List;
+
+public class F2_Filtrowanie {
+    // Program wypisuje tylko zarabiających >= 10 tys,
+    // realizujemy to filtrowaniem, ale przy okazji pokazuję Wam schemat "filter / map" - podstawowe operacje na strumieniach.
+
+    public static void main(String[] args) {
+        List<Employee> emps = ObslugaCSV.wczytaj();
+
+        emps.stream()
+            .filter(emp -> emp.getSalary() >= 10_000)
+            .forEach(emp -> System.out.println(emp.getFirstName() + " " + emp.getLastName()));
+
+        System.out.println("\n-----------------------\n");
+
+        emps.stream()
+            .filter(emp -> emp.getSalary() <= 5000)
+            .sorted(Comparator.comparing(Employee::getSalary))
+            .map(emp -> emp.getFirstName() + " " + emp.getLastName() + " z pensją " + emp.getSalary())
+            .map(String::toUpperCase) // ew.  .map(s -> s.toUpperCase())
+            .forEach(System.out::println);
+
+        // Cały ten ↑ zapis jest określany "pipeline", który składa się z:
+        // - źródła danych
+        // - dowolnej liczby operacji pośrednich (intermediate, tutaj są to filter i map)
+        // - operacji końcowej (terminal, tutaj jest to forEach)
+        // Każdy obiekt przechodzi przez kolejne etapy przetwarzania, "schodzi z góry w dół".
+
+    }
+
+}

src/main/java/emps/v3_funkcyjnie/F3_SredniaWszystkich.java

+package emps.v3_funkcyjnie;
+
+import java.util.List;
+import java.util.OptionalDouble;
+import java.util.stream.Collectors;
+
+public class F3_SredniaWszystkich {
+
+	public static void main(String[] args) {
+		List<Employee> emps = ObslugaCSV.wczytaj("emps.csv");
+
+		/*
+		// Uwaga, to nie zadziała; to nie tak się robi.
+		// Wewnątrz wyrażeń lambda nie wolno modyfikować zmiennych lokalnych zdefiniowanych na zewnątrz tych wyrażeń.
+		// (generalnie - nie wolno uzywać zmiennych, które nie są "effectively final"
+		double suma = 0;
+		int ile = 0;
+		emps.forEach(emp -> {
+			suma += emp.getSalary();
+			ile++;
+		});
+		*/
+
+		// Można użyć gotowych dedykowanych rozwiązań
+		// 1) IntStream (istnieją jeszcze LongStream oraz DoubleStream; nie istnieje FloatStream)
+		OptionalDouble srednia1 = emps.stream()
+			.mapToInt(Employee::getSalary)
+			.average();
+		System.out.println(srednia1);
+		// Gdyby strumień był pusty, to wynikiem byłby pusty Optional.
+		// Aby dostać się do samej liczby, najelepiej zrobić to tak (w razie braku danych podstawi 0):
+
+		double srednia2 = emps.stream()
+			.mapToInt(Employee::getSalary)
+			.average()
+			.orElse(0);
+		System.out.println(srednia2);
+
+		// 2) odpowiedni Collector, czyli taka maszynka, która zbiera dane i na końcu zwraca wynik
+		Double srednia3 = emps.stream().collect(Collectors.averagingInt(Employee::getSalary));
+		System.out.println(srednia3);
+	}
+
+}

src/main/java/emps/v3_funkcyjnie/F4_SredniaJedenJob.java

+package emps.v3_funkcyjnie;
+
+import java.util.List;
+import java.util.OptionalDouble;
+
+import javax.swing.JOptionPane;
+
+public class F4_SredniaJedenJob {
+
+	public static void main(String[] args) {
+		List<Employee> emps = ObslugaCSV.wczytaj("emps.csv");
+		
+		String szukanyJob = JOptionPane.showInputDialog("Podaj szukany job", "Programmer");
+		
+		double srednia1 = emps.stream()
+			.filter(emp -> emp.getJobTitle().equalsIgnoreCase(szukanyJob))
+			.mapToInt(Employee::getSalary)
+			.average()
+			.orElse(0);
+		JOptionPane.showMessageDialog(null, "Wersja prosta: " + srednia1);
+		
+		// Jeśli chcemy sprawdzić, czy zostało coś znalezione, możemy zapisać wynik jako OptionalDouble i sprawdzić ifem
+		OptionalDouble srednia2 = emps.stream()
+			.filter(emp -> emp.getJobTitle().equalsIgnoreCase(szukanyJob))
+			.mapToInt(Employee::getSalary)
+			.average();
+		
+		if(srednia2.isPresent()) {
+			JOptionPane.showMessageDialog(null, String.format(
+					"Średnia pensja na stanowisku %s wynosi %.2f",
+					szukanyJob, srednia2.getAsDouble()));
+		} else {
+			JOptionPane.showMessageDialog(null, String.format("Nikt nie pracuje na stanowisku %s.", szukanyJob),
+					"Brak danych", JOptionPane.WARNING_MESSAGE);
+		}
+	}
+
+}

src/main/java/emps/v3_funkcyjnie/F5_MiastaBezPowtorzen.java

+package emps.v3_funkcyjnie;
+
+import java.util.List;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+public class F5_MiastaBezPowtorzen {
+
+	public static void main(String[] args) {
+		List<Employee> emps = ObslugaCSV.wczytaj("emps.csv");
+		// sposób 1: utworzyć zbiór Stringów
+		// ma to sens, gdy potrzebujemy wykorzystać te dane w dalszej części programu
+		Set<String> miasta = emps.stream()
+			.map(Employee::getCity)
+			.collect(Collectors.toSet());
+		System.out.println(miasta);
+		System.out.println("--------");
+
+		// sposób 2: w łańcuchu poleceń (pipeline) umieścić operację distinct
+		// ma to sens, gdy wykonujemy tylko jedną operację, np, chcemy tylko wypisać te miasta
+		emps.stream()
+			.map(Employee::getCity)
+			.filter(s -> !s.isEmpty())
+			// .filter(((Predicate<String>)String::isEmpty).negate())
+			.distinct()
+			//.sorted()
+			.forEach(System.out::println);
+	}
+
+}

src/main/java/emps/v3_funkcyjnie/F6_MinMax.java

+package emps.v3_funkcyjnie;
+
+import java.util.Comparator;
+import java.util.List;
+
+public class F6_MinMax {
+
+	public static void main(String[] args) {
+		List<Employee> emps = ObslugaCSV.wczytaj("emps.csv");
+		Comparator<Employee> waga = Comparator.comparingInt(Employee::getSalary);
+
+		// uwaga - tu trochę upraszczamy; zakładam, że dane w pliku na pewno są - inne wersje w przykładach Opcjonalne???
+		Employee min = emps.stream().min(waga).orElse(null);
+		Employee max = emps.stream().max(waga).orElse(null);
+		
+		System.out.println("min: " + min);
+		System.out.println("max: " + max);
+	}
+
+}

src/main/java/emps/v3_funkcyjnie/F7_Sortowanie.java

+package emps.v3_funkcyjnie;
+
+import java.util.Comparator;
+import java.util.List;
+
+public class F7_Sortowanie {
+
+	public static void main(String[] args) {
+		List<Employee> emps = ObslugaCSV.wczytaj("emps.csv");
+		emps.stream()
+			.sorted(Comparator.comparingInt(Employee::getSalary).reversed())
+			.map(emp -> emp.getFirstName() + " " + emp.getLastName() + " " + emp.getSalary())
+			.forEach(System.out::println);
+	}
+
+}

src/main/java/emps/v3_funkcyjnie/F7b_Sortowanie_WieleKryteriow.java

+package emps.v3_funkcyjnie;
+
+import java.util.Comparator;
+import java.util.List;
+
+public class F7b_Sortowanie_WieleKryteriow {
+
+	public static void main(String[] args) {
+		List<Employee> emps = ObslugaCSV.wczytaj();
+
+		emps.stream()
+			.sorted(Comparator.comparing(Employee::getCity)
+						.thenComparing(Employee::getLastName)
+						.thenComparing(Employee::getFirstName))
+			.forEach(emp -> System.out.printf("%-15s %-15s %s%n",
+					emp.getFirstName(), emp.getLastName(), emp.getCity()));
+	}
+
+}

src/main/java/emps/v3_funkcyjnie/F8_Partycje.java

+package emps.v3_funkcyjnie;
+
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+
+public class F8_Partycje {
+
+	public static void main(String[] args) {
+		List<Employee> emps = ObslugaCSV.wczytaj("emps.csv");
+		
+		// Podział rekordów na dwie części i zapisanie w słowniku,
+		// w którym kluczem są wartości true/false
+		Map<Boolean, List<Employee>> grupy = emps.stream()
+			.collect(Collectors.partitioningBy(emp -> emp.getSalary() >= 10_000));
+		
+		System.out.println("Bogaci:");
+		grupy.get(true).forEach(emp -> {
+			System.out.printf(" * %s %s (%s), pensja: %s\n", emp.getFirstName(), emp.getLastName(), emp.getJobTitle(), emp.getSalary());
+		});
+
+		System.out.println("\nBiedni:");
+		grupy.get(false).forEach(emp -> {
+			System.out.printf(" * %s %s (%s), pensja: %s\n", emp.getFirstName(), emp.getLastName(), emp.getJobTitle(), emp.getSalary());
+		});
+	}
+
+}

src/main/java/emps/v3_funkcyjnie/F9_Podwyzka.java

+package emps.v3_funkcyjnie;
+
+import java.util.List;
+
+public class F9_Podwyzka {
+	// Generalnie strumienie pozwalają nam na "odczyt", a nie służą modyfikacji listy / zbioru itp.
+	// Jeśli jednak obiekty zawarte w liście są "mutowalne", to za pośrednictwem strumienia MOŻNA zmodyfikować te obiekty.
+
+	public static void main(String[] args) {
+		List<Employee> emps = ObslugaCSV.wczytaj("emps.csv");
+
+		emps.stream()
+			.filter(emp -> "Programmer".equals(emp.getJobTitle()))
+			.forEach(emp -> emp.setSalary(emp.getSalary() + 3333));
+
+		emps.forEach(emp -> System.out.println(emp.getFirstName() + " " + emp.getLastName() + " (" + emp.getJobTitle() + ") : " + emp.getSalary()));
+
+		ObslugaCSV.zapisz(emps, "zmodyfikowany2.csv");
+	}
+
+}

src/main/java/emps/v3_funkcyjnie/Grupowanie7.java

+package emps.v3_funkcyjnie;
+
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+
+public class Grupowanie7 {
+
+    public static void main(String[] args) {
+        List<Employee> emps = ObslugaCSV.wczytaj();
+        Map<String, List<Employee>> grupy = emps.stream().collect(Collectors.groupingBy(Employee::getJobTitle));
+
+        // System.out.println(grupy);
+        grupy.forEach((job, lista) -> {
+            System.out.println("Stanowisko " + job + ":");
+            lista.forEach(emp -> {
+                System.out.println(" * " + emp.getFirstName() + " " + emp.getLastName() + " " + emp.getSalary());
+            });
+            System.out.println();
+        });
+    }
+
+}

src/main/java/emps/v3_funkcyjnie/Grupowanie8.java

+package emps.v3_funkcyjnie;
+
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+
+public class Grupowanie8 {
+
+    public static void main(String[] args) {
+        List<Employee> emps = ObslugaCSV.wczytaj();
+        Map<String, Double> grupy = emps.stream()
+                .collect(Collectors.groupingBy(Employee::getJobTitle,
+                        Collectors.averagingInt(Employee::getSalary)));
+
+        // System.out.println(grupy);
+        grupy.forEach((job, srednia) -> {
+            System.out.printf("%-32s → %8.2f%n", job, srednia);
+        });
+    }
+
+}

src/main/java/emps/v3_funkcyjnie/Grupowanie9.java

+package emps.v3_funkcyjnie;
+
+import java.util.IntSummaryStatistics;
+import java.util.List;
+import java.util.Map;
+import java.util.TreeMap;
+import java.util.stream.Collectors;
+
+// W tej wersji dla każdej grupy od razu obliczymy "statystyki"
+// Podajemy też konstruktor klasy TreeMap, aby został utworzony słownik tego typu
+public class Grupowanie9 {
+
+	public static void main(String[] args) {
+		List<Employee> emps = ObslugaCSV.wczytaj();
+
+		Map<String, IntSummaryStatistics> grupy = emps.stream()
+				.collect(Collectors.groupingBy(
+						Employee::getJobTitle,
+						TreeMap::new,
+						Collectors.summarizingInt(Employee::getSalary)));
+
+		grupy.forEach((job, stats) -> {
+			// System.out.printf("%-32s → %s%n", job, stats);
+			System.out.printf("| %-32s | %2d | %5d | %8.2f | %5d |%n",
+	                job, stats.getCount(), stats.getMin(), stats.getAverage(), stats.getMax());
+		});
+	}
+
+}

src/main/java/emps/v3_funkcyjnie/ObslugaCSV.java

+package emps.v3_funkcyjnie;
+
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.io.PrintWriter;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.time.LocalDate;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Scanner;
+import java.util.stream.Stream;
+
+public class ObslugaCSV {
+	public static List<Employee> wczytaj() {
+		// używa domyślnego pliku
+		return wczytaj("emps.csv");
+	}
+
+	public static List<Employee> wczytaj(String sciezka) {
+		return wczytaj(new File(sciezka));
+	}
+
+	public static List<Employee> wczytaj(File plik) {
+		List<Employee> emps = new ArrayList<>();
+		try(Scanner scanner = new Scanner(plik)) {
+			scanner.nextLine(); // pomijamy pierwszą linię
+			while(scanner.hasNextLine()) {
+				String linia = scanner.nextLine();
+				Employee emp = parsujLinie(linia);
+				emps.add(emp);
+			}
+		} catch (FileNotFoundException e) {
+			e.printStackTrace();
+			// w razie błędu (brak pliku) wypiszemy czerwone teksty na ekran, ale nie przerwiemy programu, tylko zwrócimy pustą listę
+		}
+		return emps;
+	}
+
+    public static Stream<Employee> wczytajStrumieniowo(Path plik) {
+        try {
+            return Files.lines(plik)
+                    .skip(1)
+                    .map(ObslugaCSV::parsujLinie);
+        } catch (IOException e) {
+            e.printStackTrace();
+            return Stream.empty();
+        }
+    }
+
+    private static Employee parsujLinie(String linia) {
+        String[] t = linia.split(";", -1);
+        Employee emp = new Employee(Integer.parseInt(t[0]), t[1], t[2], t[3],
+                Integer.parseInt(t[4]), LocalDate.parse(t[5]),
+                t[6], t[7], t[8], t[9], t[10]);
+        return emp;
+    }
+
+    public static Stream<Employee> wczytajStrumieniowo(File plik) {
+        return wczytajStrumieniowo(plik.toPath());
+    }
+
+    public static Stream<Employee> wczytajStrumieniowo(String sciezka) {
+        return wczytajStrumieniowo(Path.of(sciezka));
+    }
+
+    public static Stream<Employee> wczytajStrumieniowo() {
+        return wczytajStrumieniowo("emps.csv");
+    }
+
+	public static void zapisz(List<Employee> lista, File plik) {
+		try(PrintWriter out = new PrintWriter(plik)) {
+			out.println(
+					"employee_id;first_name;last_name;job_title;salary;hire_date;department_name;address;postal_code;city;country");
+			for(Employee emp : lista) {
+				out.printf("%d;%s;%s;%s;%d;%s;%s;%s;%s;%s;%s\n", emp.getEmployeeId(), emp.getFirstName(),
+						emp.getLastName(), emp.getJobTitle(), emp.getSalary(), emp.getHireDate(),
+						emp.getDepartmentName(), emp.getAddress(), emp.getPostalCode(), emp.getCity(),
+						emp.getCountry());
+			}
+		} catch (FileNotFoundException e) {
+			e.printStackTrace();
+		}
+	}
+
+	public static void zapisz(List<Employee> lista, String sciezka) {
+		zapisz(lista, new File(sciezka));
+	}
+
+	public static void zapisz(List<Employee> lista) {
+		zapisz(lista, "emps.csv");
+	}
+
+    public static void zapiszStrumieniowo(Stream<Employee> stream, File plik) {
+        try(PrintWriter out = new PrintWriter(plik)) {
+            out.println(
+                    "employee_id;first_name;last_name;job_title;salary;hire_date;department_name;address;postal_code;city;country");
+            stream.forEachOrdered(emp -> {
+                out.printf("%d;%s;%s;%s;%d;%s;%s;%s;%s;%s;%s\n", emp.getEmployeeId(), emp.getFirstName(),
+                        emp.getLastName(), emp.getJobTitle(), emp.getSalary(), emp.getHireDate(),
+                        emp.getDepartmentName(), emp.getAddress(), emp.getPostalCode(), emp.getCity(),
+                        emp.getCountry());
+            });
+        } catch (FileNotFoundException e) {
+            e.printStackTrace();
+        }
+    }
+
+}

src/main/java/emps/v3_funkcyjnie/S2_Filtrowanie.java

+package emps.v3_funkcyjnie;
+
+import java.util.Comparator;
+
+public class S2_Filtrowanie {
+    public static void main(String[] args) {
+        ObslugaCSV.wczytajStrumieniowo()
+            .filter(emp -> emp.getSalary() <= 5000)
+            .sorted(Comparator.comparing(Employee::getSalary))
+            .map(emp -> emp.getFirstName() + " " + emp.getLastName() + " z pensją " + emp.getSalary())
+            .map(String::toUpperCase)
+            .forEach(System.out::println);
+    }
+
+}

src/main/java/emps/v3_funkcyjnie/S4_SredniaJedenJob.java

+package emps.v3_funkcyjnie;
+import java.util.OptionalDouble;
+
+import javax.swing.JOptionPane;
+
+public class S4_SredniaJedenJob {
+
+	public static void main(String[] args) {
+		String szukanyJob = JOptionPane.showInputDialog("Podaj szukany job", "Programmer");
+
+		OptionalDouble srednia2 =  ObslugaCSV.wczytajStrumieniowo()
+			.filter(emp -> emp.getJobTitle().equalsIgnoreCase(szukanyJob))
+			.mapToInt(Employee::getSalary)
+			.average();
+
+		if(srednia2.isPresent()) {
+			JOptionPane.showMessageDialog(null, String.format(
+					"Średnia pensja na stanowisku %s wynosi %.2f",
+					szukanyJob, srednia2.getAsDouble()));
+		} else {
+			JOptionPane.showMessageDialog(null, String.format("Nikt nie pracuje na stanowisku %s.", szukanyJob),
+					"Brak danych", JOptionPane.WARNING_MESSAGE);
+		}
+	}
+
+}

src/main/java/emps/v3_funkcyjnie/S_Grupowanie9.java

+package emps.v3_funkcyjnie;
+
+import java.util.IntSummaryStatistics;
+import java.util.Map;
+import java.util.TreeMap;
+import java.util.stream.Collectors;
+
+public class S_Grupowanie9 {
+
+	public static void main(String[] args) {
+	    Map<String, IntSummaryStatistics> grupy = ObslugaCSV.wczytajStrumieniowo()
+				.collect(Collectors.groupingBy(
+						Employee::getJobTitle,
+						TreeMap::new,
+						Collectors.summarizingInt(Employee::getSalary)));
+
+		grupy.forEach((job, stats) -> {
+			// System.out.printf("%-32s → %s%n", job, stats);
+			System.out.printf("| %-32s | %2d | %5d | %8.2f | %5d |%n",
+	                job, stats.getCount(), stats.getMin(), stats.getAverage(), stats.getMax());
+		});
+	}
+
+}

src/main/java/emps/v4_rekord/Employee.java

+package emps.v4_rekord;
+
+import java.time.LocalDate;
+
+public record Employee(int employeeId, String firstName, String lastName, String jobTitle, int salary, LocalDate hireDate,
+		String departmentName, String address, String postalCode, String city, String country) {
+    // Rekord to jest "taka klasa", dla której automatycznie tworzone są:
+    // - deklaracje podanych pól, które wszystkie są "private final"
+    // - konstruktor z wszystkimi parametrami
+    // - gettery do wszystkich pól, ale uwaga, nazwą metody jest po prostu "salary()", a nie "getSalary()"
+    // - toString, equals i hashCode w sposób standardowy dla klas typu "value object"
+
+    // Do rekordu można dodawać własne metody. Rekord może implementować interfejsy.
+    public String danePracownika() {
+        return String.format("%s %s (%s) zarabia %d", firstName, lastName, jobTitle, salary);
+    }
+
+    public static int dodaj(int x, int y) {
+    	return x + y;
+    }
+}

src/main/java/emps/v4_rekord/Grupowanie2.java

+package emps.v4_rekord;
+
+import java.util.List;
+import java.util.Map;
+import java.util.TreeMap;
+
+public class Grupowanie2 {
+	
+	public static void main(String[] args) {
+		List<Employee> emps = ObslugaCSV.wczytaj("emps.csv");
+		
+		Map<String, Integer> sumy = new TreeMap<>();
+		Map<String, Integer> ilosci = new TreeMap<>();
+
+		for(Employee emp : emps) {
+			int suma = sumy.getOrDefault(emp.jobTitle(), 0);
+			sumy.put(emp.jobTitle(), suma + emp.salary());
+			int ile = ilosci.getOrDefault(emp.jobTitle(), 0);
+			ilosci.put(emp.jobTitle(), ile+1);
+		}
+
+		for(String job : sumy.keySet()) {
+			int suma = sumy.get(job);
+			int ile = ilosci.get(job);
+			double srednia = (double)suma / ile;
+			System.out.printf("| %-32s | %2d | %8.2f |%n", job, ile, srednia);
+		}
+	}
+
+}

src/main/java/emps/v4_rekord/Grupowanie8.java

+package emps.v4_rekord;
+
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+
+public class Grupowanie8 {
+
+	public static void main(String[] args) {
+		List<Employee> emps = ObslugaCSV.wczytaj("emps.csv");
+		
+		Map<String, Double> grupy = emps.stream()
+				.collect(Collectors.groupingBy(
+						Employee::jobTitle,
+						Collectors.averagingInt(Employee::salary)));
+		
+		grupy.forEach((job, srednia) -> {
+			System.out.printf("%-32s → %8.2f%n", job, srednia);
+		});
+	}
+
+}

src/main/java/emps/v4_rekord/Grupowanie9.java

+package emps.v4_rekord;
+
+import java.util.IntSummaryStatistics;
+import java.util.Map;
+import java.util.TreeMap;
+import java.util.stream.Collectors;
+
+public class Grupowanie9 {
+
+	public static void main(String[] args) {
+		Map<String, IntSummaryStatistics> grupy = ObslugaCSV.wczytajStrumieniowo("emps.csv")
+				.collect(Collectors.groupingBy(
+						Employee::jobTitle,
+						TreeMap::new,
+						Collectors.summarizingInt(Employee::salary)));
+		
+		grupy.forEach((job, stats) -> {
+			System.out.printf("| %-32s | %2d | %5d | %8.2f | %5d |%n",
+	                job, stats.getCount(), stats.getMin(), stats.getAverage(), stats.getMax());
+		});
+	}
+
+}

src/main/java/emps/v4_rekord/ObslugaCSV.java

+package emps.v4_rekord;
+
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.io.PrintWriter;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.time.LocalDate;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Scanner;
+import java.util.stream.Stream;
+
+public class ObslugaCSV {
+	public static List<Employee> wczytaj() {
+		// używa domyślnego pliku
+		return wczytaj("emps.csv");
+	}
+	
+	public static List<Employee> wczytaj(String sciezka) {
+		return wczytaj(new File(sciezka));
+	}
+	
+	public static List<Employee> wczytaj(File plik) {
+		List<Employee> emps = new ArrayList<>();
+		try(Scanner scanner = new Scanner(plik)) {
+			scanner.nextLine(); // pomijamy pierwszą linię
+			while(scanner.hasNextLine()) {
+				String linia = scanner.nextLine();
+				Employee emp = parsujLinie(linia);
+				emps.add(emp);
+			}
+		} catch (FileNotFoundException e) {
+			e.printStackTrace();
+			// w razie błędu (brak pliku) wypiszemy czerwone teksty na ekran, ale nie przerwiemy programu, tylko zwrócimy pustą listę
+		}
+		return emps;
+	}
+
+	public static Stream<Employee> wczytajStrumieniowo(Path plik) {
+		try {
+			return Files.lines(plik)
+					.skip(1)
+					.map(ObslugaCSV::parsujLinie);
+		} catch (IOException e) {
+			e.printStackTrace();
+			return Stream.empty();
+		}
+	}
+	
+	public static Stream<Employee> wczytajStrumieniowo(File plik) {
+		return wczytajStrumieniowo(plik.toPath());
+	}
+
+	public static Stream<Employee> wczytajStrumieniowo(String sciezka) {
+		return wczytajStrumieniowo(Path.of(sciezka));
+	}
+
+	public static Stream<Employee> wczytajStrumieniowo() {
+		return wczytajStrumieniowo("emps.csv");
+	}
+
+	public static void zapisz(List<Employee> lista, File plik) {
+		try(PrintWriter out = new PrintWriter(plik)) {
+			out.println(
+					"employee_id;first_name;last_name;job_title;salary;hire_date;department_name;address;postal_code;city;country");
+			for (Employee emp : lista) {
+				out.printf("%d;%s;%s;%s;%d;%s;%s;%s;%s;%s;%s\n", emp.employeeId(), emp.firstName(),
+						emp.lastName(), emp.jobTitle(), emp.salary(), emp.hireDate(),
+						emp.departmentName(), emp.address(), emp.postalCode(), emp.city(),
+						emp.country());
+			}
+		} catch (FileNotFoundException e) {
+			e.printStackTrace();
+		}
+	}
+
+	public static void zapisz(List<Employee> lista, String sciezka) {
+		zapisz(lista, new File(sciezka));
+	}
+
+	public static void zapisz(List<Employee> lista) {
+		zapisz(lista, "emps.csv");
+	}
+	
+	private static Employee parsujLinie(String linia) {
+		String[] t = linia.split(";", -1);
+		Employee emp = new Employee(Integer.parseInt(t[0]), t[1], t[2], t[3],
+				Integer.parseInt(t[4]), LocalDate.parse(t[5]),
+				t[6], t[7], t[8], t[9], t[10]);
+		return emp;
+	}
+
+}

src/main/java/emps/v4_rekord/P1_WypiszDane.java

+package emps.v4_rekord;
+
+import java.util.List;
+
+// Program dla każdego pracownika wypisuje tekst postaci
+// Steven King (President) zarabia 24000
+public class P1_WypiszDane {
+
+	public static void main(String[] args) {
+		List<Employee> emps = ObslugaCSV.wczytaj("emps.csv");
+		for(Employee emp : emps) {
+			// System.out.println(emp.getFirstName() + " " + emp.getLastName());
+			System.out.printf("Pracownik %s %s (%s) zarabia %s%n",
+					emp.firstName(), emp.lastName(), emp.jobTitle(), emp.salary());
+		}
+	}
+
+}
+
+// TODO napisać programy P2 P3 P4 działające tak, jak w wersji nieobiektowej,
+// ale w oparciu o listę obiektów Emeployee

src/main/java/emps/v4_rekord/P4_SredniaJedenJob_v3.java

+package emps.v4_rekord;
+
+import java.io.File;
+import java.util.List;
+import java.util.Set;
+import java.util.TreeSet;
+
+import javax.swing.JFileChooser;
+import javax.swing.JOptionPane;
+import javax.swing.filechooser.FileNameExtensionFilter;
+
+public class P4_SredniaJedenJob_v3 {
+
+	public static void main(String[] args) {
+		JFileChooser chooser = new JFileChooser(".");
+		chooser.setFileFilter(new FileNameExtensionFilter("Pliki CSV", "csv", "txt"));
+		int coSieStalo = chooser.showOpenDialog(null);
+		if(coSieStalo != JFileChooser.APPROVE_OPTION)
+			return;
+		
+		File plik = chooser.getSelectedFile();
+		List<Employee> emps = ObslugaCSV.wczytaj(plik);
+		
+		Set<String> jobs = new TreeSet<>();
+		for(Employee emp : emps) {
+			jobs.add(emp.jobTitle());
+		}
+		
+		String szukanyJob = (String)JOptionPane.showInputDialog(null, "Wybierz stanowisko", "Wybór",
+				JOptionPane.QUESTION_MESSAGE, null, jobs.toArray(), "Programmer");
+		if(szukanyJob == null)
+			return;
+		
+		double suma = 0;
+		int ile = 0;
+		for(Employee emp : emps) {
+			if(szukanyJob.equals(emp.jobTitle())) {
+				suma += emp.salary();
+				ile++;
+			}
+		}
+
+		if(ile > 0) {
+			double srednia = suma / ile;
+			JOptionPane.showMessageDialog(null, String.format(
+					"Na stanowisku %s pracuje %d osób.\nŚrednia pensja wynosi %.2f",
+					szukanyJob, ile, srednia));
+		} else {
+			JOptionPane.showMessageDialog(null, String.format("Nikt nie pracuje na stanowisku %s.", szukanyJob),
+					"Brak danych", JOptionPane.WARNING_MESSAGE);
+		}
+	}
+}

src/main/java/emps/v4_rekord/S2_Filtrowanie.java

+package emps.v4_rekord;
+
+public class S2_Filtrowanie {
+
+	public static void main(String[] args) {
+		ObslugaCSV.wczytajStrumieniowo("emps.csv")
+			.filter(emp -> emp.salary() >= 10_000)
+			.map(Employee::danePracownika)
+			.forEach(System.out::println);
+	}
+
+}

src/main/java/p09_switch/IleDniMaMiesiac5.java

@@ -19,13 +19,11 @@ public class IleDniMaMiesiac5 {
                     int rok = Integer.parseInt(JOptionPane.showInputDialog("Podaj rok"));
                     if(rok % 4 == 0 && rok % 100 != 0 || rok % 400 == 0) {
                         yield 29;
-                    } else {
-                        yield 28;
                     }
+                    yield 28;
                 }
                 default -> throw new IllegalArgumentException("Niepoprawny miesiąc");
             };
-            
             JOptionPane.showMessageDialog(null, "Miesiąc " + miesiac + " ma " + ileDni + " dni.");
         } catch (Exception e) {
             JOptionPane.showMessageDialog(null, e.getMessage(), "Błąd", JOptionPane.ERROR_MESSAGE);

src/main/java/p09_switch/SwitchNaObiektach.java

@@ -19,7 +19,7 @@ public class SwitchNaObiektach {
         // jakisObiekt = "";
         // jakisObiekt = new File("sciezka/do/pliku.txt");
         jakisObiekt = LocalDate.of(1997, 8, 19);
-    
+
         switch(jakisObiekt) {
             case String s when s.startsWith("o") -> System.out.println("To jest napis na o:" + s);
             case String s when s.startsWith("k") -> System.out.println("To jest napis na k:" + s);

src/main/java/p15_kolekcje/a_list/DeklaracjeGeneryczne.java

+package p15_kolekcje.a_list;
+
+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/main/java/p15_kolekcje/a_list/ListaLiczb.java

+package p15_kolekcje.a_list;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class ListaLiczb {
+
+	public static void main(String[] args) {
+		//NK List<int> lista = new ArrayList<>();
+		List<Integer> lista = new ArrayList<>();
+		lista.add(5);
+		lista.add(6);
+		lista.add(7);
+		lista.add(8);
+		lista.add(9);
+		lista.add(10);
+		System.out.println(lista);
+		System.out.println("rozmiar: " + lista.size());
+		
+//		if(lista.remove(5)) {			
+//		}
+		
+		Integer element = lista.remove(5); // wg indeksu
+		
+		System.out.println("Usunięty element: " + element);
+		System.out.println(lista);
+		
+		Integer x = 9;
+		if(lista.remove(x)) { // wg wartości
+			System.out.println("usunąłem wartość 9");
+		}
+		
+		boolean b = lista.remove((Integer)5); // OK, wg wartości
+		// boolean b = lista.remove((Object)5); // wg wartości
+		System.out.println("Czy usunięto? " + b);
+		System.out.println(lista);
+	}
+
+}

src/main/java/p15_kolekcje/a_list/Listy.java

+package p15_kolekcje.a_list;
+
+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/p15_kolekcje/a_list/ListyAll.java

+package p15_kolekcje.a_list;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class ListyAll {
+
+	public static void main(String[] args) {
+		List<String> a = new ArrayList<>();
+		a.add("Ala");
+		a.add("Ola");
+		a.add("Ela");
+		a.add("Ula");
+		System.out.println("a = " + a);
+		
+		List<String> b = new ArrayList<>(a);
+		System.out.println("a = " + b);
+		
+		List<String> c = new ArrayList<>();
+		c.add("Ala");
+		c.add("Ula");
+		System.out.println("c = " + c);
+		
+		List<String> d = new ArrayList<>();
+		d.add("Ala");
+		d.add("Gosia");
+		System.out.println("d = " + d);
+		d.addAll(a);		
+		System.out.println("d = " + d);
+		
+		System.out.println(a.containsAll(c)); // T
+		System.out.println(c.containsAll(a)); // F
+
+		c.add("Basia"); // nie ma w a
+		System.out.println("c = " + c);
+
+		boolean czy = a.removeAll(c);
+		System.out.println(czy); // T
+		
+		System.out.println("a = " + a); // usunął Ala i Ula, a nie przejął się Basią
+		System.out.println();
+		
+		a.add("Genowefa");
+		a.add("Hermenegilda");
+		a.add("Genowefa");
+		
+		System.out.println("a = " + a);
+		System.out.println("b = " + b);
+		
+		// zostawia w liście a tylko te elementy, które wystepują w b
+		czy = a.retainAll(b);
+		System.out.println("retainAll " + b);
+		System.out.println("a = " + a);
+		System.out.println("b = " + b);
+		
+	}
+}

src/main/java/p15_kolekcje/a_list/NoweOperacjeList.java

+package p15_kolekcje.a_list;
+
+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/p15_kolekcje/a_list/PorownanieSzybkosciList.java

+package p15_kolekcje.a_list;
+
+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();
+		for(int i=0; i < 10000; i++) {
+			lista.add(0, 333);  // 333 jest elementem (wartością) a nie indeksem
+			// 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/main/java/p15_kolekcje/b_set_map/ListyIZbiory.java

+package p15_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"); 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/p15_kolekcje/b_set_map/NoweOperacjeMap.java

+package p15_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/main/java/p15_kolekcje/b_set_map/Slowniki.java

+package p15_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/main/java/p15_kolekcje/b_set_map/Tree1.java

+package p15_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/main/java/p15_kolekcje/b_set_map/Tree2.java

+package p15_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/main/java/p15_kolekcje/b_set_map/ZbiorDziwnieSortowany.java

+package p15_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/main/java/p15_kolekcje/b_set_map/ZmianaKolejnosciWHaszSecie.java

+package p15_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/main/java/p15_kolekcje/c_queue/KolejkaJakoStos.java

+package p15_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/main/java/p15_kolekcje/c_queue/Kolejki.java

+package p15_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/main/java/p15_kolekcje/c_queue/Kolejki_Operacje.java

+package p15_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/main/java/p15_kolekcje/e_iterator/Iteratory.java

+package p15_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/main/java/p15_kolekcje/e_iterator/IteratoryListowe.java

+package p15_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/main/java/p15_kolekcje/e_iterator/Konkurencja1.java

+package p15_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/main/java/p15_kolekcje/e_iterator/Konkurencja2.java

+package p15_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/main/java/p15_kolekcje/e_iterator/Konkurencja3.java

+package p15_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/main/java/p15_kolekcje/e_iterator/Konkurencja4.java

+package p15_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/main/java/p15_kolekcje/e_iterator/Konkurencja6.java

+package p15_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/main/java/p15_kolekcje/e_iterator/Konkurencja7a.java

+package p15_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/main/java/p15_kolekcje/e_iterator/Konkurencja7b.java

+package p15_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/main/java/p15_kolekcje/s_sortowanie/KomparatorDlugosciNapisow.java

+package p15_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/main/java/p15_kolekcje/s_sortowanie/Sortowanie1.java

+package p15_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/main/java/p15_kolekcje/s_sortowanie/Sortowanie2.java

+package p15_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")));
+		lista.sort(Collator.getInstance(Locale.of("pl", "PL")));
+		// lista.sort(Collator.getInstance(Locale.of("en", "US")));
+		System.out.println(lista);
+	}
+}

src/main/java/p15_kolekcje/s_sortowanie/Sortowanie3.java

+package p15_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/main/java/p15_kolekcje/z_zbierz_dane/P1_Tablica.java

+package p15_kolekcje.z_zbierz_dane;
+
+import java.util.Arrays;
+import java.util.Scanner;
+
+// Program pobiera od użytkownika wiele imion i zapisuje w pamięci, aby później wypisać...
+// W tej wersji imiona zapamiętujemy w tablicy.
+// Tworząc tablicę musimy podać jej rozmiar.
+// Tablice nie są tak elastyczne, jak listy i inne kolekcje,
+
+public class P1_Tablica {
+
+    public static void main(String[] args) {
+        Scanner scanner = new Scanner(System.in);
+        System.out.print("Ile imion podasz? ");
+        int size = scanner.nextInt();
+        scanner.nextLine(); // ignorujemy resztę tej linii, a "kursor przechodzi do następnej"
+        String[] tablica = new String[size];
+
+        for(int i = 0; i < size; i++) {
+            System.out.print("Podaj imię nr " + i + ": ");
+            tablica[i] = scanner.nextLine();
+        }
+
+        System.out.println("Wszystkie imiona:");
+        System.out.println(Arrays.toString(tablica));
+
+        // Tablica i wszystkie typy kolekcji pozwalają na używanie pętli "for-each".
+        for(String imie : tablica) {
+            System.out.print("; witaj " + imie);
+        }
+        System.out.println();
+
+        // Najbardziej oczywistym (i wydajnym) sposobem dostepu do elementów tablicy
+        // jest dostęp po numerze pozycji za pomocą []
+        // 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/p15_kolekcje/z_zbierz_dane/P2_TablicaDynamiczna.java

+package p15_kolekcje.z_zbierz_dane;
+
+import java.util.Arrays;
+import java.util.Scanner;
+
+public class P2_TablicaDynamiczna {
+
+    public static void main(String[] args) {
+        Scanner scanner = new Scanner(System.in);
+
+        // Na początku tworzymy tablicę, która ma 4 miejsca,
+        // ale zanim zaczniemy pobierać imiona, to liczba imion wynosi 0.
+        String[] tablica = new String[4];
+        int n = 0;
+
+        for(;;) {
+            System.out.print("Podaj imię nr " + n + ": ");
+            String imie = scanner.nextLine();
+            if(imie.isEmpty()) break;
+            if(n == tablica.length) {
+                // w tej wersji kopiowanie danych ze starej do nowej tablicy piszemy samodzielnie
+                System.out.println("powiększanie tablicy");
+                String[] nowaTablica = new String[2*n];
+                for(int i=0; i<n; i++) {
+                    nowaTablica[i] = tablica[i];
+                }
+                tablica = nowaTablica;
+            }
+            tablica[n] = imie;
+            n++;
+        }
+
+        System.out.println("Wszystkie imiona:");
+        System.out.println(Arrays.toString(tablica));
+
+        for(String imie : tablica) {
+            System.out.print("; witaj " + imie);
+        }
+        System.out.println();
+
+        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/p15_kolekcje/z_zbierz_dane/P2_TablicaDynamiczna_Copy.java

+package p15_kolekcje.z_zbierz_dane;
+
+import java.util.Arrays;
+import java.util.Scanner;
+
+public class P2_TablicaDynamiczna_Copy {
+
+    public static void main(String[] args) {
+        Scanner scanner = new Scanner(System.in);
+
+        // Na początku tworzymy tablicę, która ma 4 miejsca,
+        // ale zanim zaczniemy pobierać imiona, to liczba imion wynosi 0.
+        String[] tablica = new String[4];
+        int n = 0;
+
+        while(true) {
+            System.out.print("Podaj imię nr " + n + ": ");
+            String imie = scanner.nextLine();
+            if(imie.isEmpty()) break;
+            if(n == tablica.length) {
+                // w tej wersji kopiowanie danych wykonujemy za pomocą metody copy
+                System.out.println("powiększanie tablicy");
+                tablica = Arrays.copyOf(tablica, 2*n);
+            }
+            tablica[n] = imie;
+            n++;
+        }
+
+        System.out.println("Wszystkie imiona:");
+        System.out.println(Arrays.toString(tablica));
+
+        for(String imie : tablica) {
+            System.out.print("; witaj " + imie);
+        }
+        System.out.println();
+
+        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);
+            }
+        }
+    }
+
+}