Dorzucam dodatkowe przykłady chociaż nie są w pełni uporządkowane

P01-JavaSE/src/main/java/pcz/emps/v1_nieobiektowo/P1_WypiszDane.java

+package pcz.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();
+		}
+	}
+
+}

P01-JavaSE/src/main/java/pcz/emps/v1_nieobiektowo/P2_WypiszWybranych.java

+package pcz.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();
+		}
+	}
+
+}

P01-JavaSE/src/main/java/pcz/emps/v1_nieobiektowo/P3_SredniaWszystkich.java

+package pcz.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();
+		}
+	}
+
+}

P01-JavaSE/src/main/java/pcz/emps/v1_nieobiektowo/P4_SredniaJedenJob.java

+package pcz.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();
+		}
+	}
+
+}

P01-JavaSE/src/main/java/pcz/emps/v1_nieobiektowo/SredniaProgramistow.java

+package pcz.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();
+		}
+	}
+
+}

P01-JavaSE/src/main/java/pcz/emps/v2_obiektowo/Employee.java

+package pcz.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;
+    }
+
+}

P01-JavaSE/src/main/java/pcz/emps/v2_obiektowo/Grupowanie0.java

+package pcz.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);
+        }
+
+    }
+
+}

P01-JavaSE/src/main/java/pcz/emps/v2_obiektowo/Grupowanie1.java

+package pcz.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);
+        }
+
+    }
+
+}

P01-JavaSE/src/main/java/pcz/emps/v2_obiektowo/Grupowanie1a.java

+package pcz.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);
+        }
+    }
+
+}

P01-JavaSE/src/main/java/pcz/emps/v2_obiektowo/Grupowanie2.java

+package pcz.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);
+		}
+	}
+
+}

P01-JavaSE/src/main/java/pcz/emps/v2_obiektowo/Grupowanie2a.java

+package pcz.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);
+		}
+	}
+
+}

P01-JavaSE/src/main/java/pcz/emps/v2_obiektowo/Grupowanie3.java

+package pcz.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);
+		});
+	}
+
+}

P01-JavaSE/src/main/java/pcz/emps/v2_obiektowo/Grupowanie4.java

+package pcz.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);
+		}
+	}
+
+}

P01-JavaSE/src/main/java/pcz/emps/v2_obiektowo/Grupowanie5.java

+package pcz.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);
+		}
+	}
+
+}

P01-JavaSE/src/main/java/pcz/emps/v2_obiektowo/Grupowanie6.java

+package pcz.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();
+		}
+	}
+}

P01-JavaSE/src/main/java/pcz/emps/v2_obiektowo/MergeTlumaczenie.java

+package pcz.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));
+    }
+
+}

P01-JavaSE/src/main/java/pcz/emps/v2_obiektowo/ObslugaCSV.java

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

P01-JavaSE/src/main/java/pcz/emps/v2_obiektowo/P0_WypiszWszystko.java

+package pcz.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);
+        }
+    }
+
+}

P01-JavaSE/src/main/java/pcz/emps/v2_obiektowo/P1_WypiszWybranePola.java

+package pcz.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());
+        }
+    }
+
+}

P01-JavaSE/src/main/java/pcz/emps/v2_obiektowo/P2_WypiszBogatych.java

+package pcz.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());
+			}
+		}
+	}
+
+}

P01-JavaSE/src/main/java/pcz/emps/v2_obiektowo/P3_SredniaWszystkich.java

+package pcz.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);
+	}
+
+}

P01-JavaSE/src/main/java/pcz/emps/v2_obiektowo/P4_SredniaJedenJob_v1.java

+package pcz.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);
+		}
+	}
+}

P01-JavaSE/src/main/java/pcz/emps/v2_obiektowo/P4_SredniaJedenJob_v2.java

+package pcz.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);
+		}
+	}
+}

P01-JavaSE/src/main/java/pcz/emps/v2_obiektowo/P4_SredniaJedenJob_v3.java

+package pcz.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);
+		}
+	}
+}

P01-JavaSE/src/main/java/pcz/emps/v2_obiektowo/P5_MiastaBezPowtorzen.java

+package pcz.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);
+		}
+	}
+
+}

P01-JavaSE/src/main/java/pcz/emps/v2_obiektowo/P6_MinMax_v1.java

+package pcz.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);
+			}
+		}
+	}
+
+}

P01-JavaSE/src/main/java/pcz/emps/v2_obiektowo/P6_MinMax_v2.java

+package pcz.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);
+	}
+
+}

P01-JavaSE/src/main/java/pcz/emps/v2_obiektowo/P6_MinMax_v3.java

+package pcz.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());
+	}
+
+}

P01-JavaSE/src/main/java/pcz/emps/v2_obiektowo/P6_MinMax_v4.java

+package pcz.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());
+	}
+
+}

P01-JavaSE/src/main/java/pcz/emps/v2_obiektowo/P7_Sortowanie.java

+package pcz.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());
+	}
+
+}
+

P01-JavaSE/src/main/java/pcz/emps/v2_obiektowo/P9_Podwyzka.java

+package pcz.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.
+

P01-JavaSE/src/main/java/pcz/emps/v2_obiektowo/P9_PodwyzkaOkienkowa.java

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

P01-JavaSE/src/main/java/pcz/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;
+ */

P01-JavaSE/src/main/java/pcz/emps/v3_funkcyjnie/CzegoSieNieDaWLambdach.java

+package pcz.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);
+	}
+}

P01-JavaSE/src/main/java/pcz/emps/v3_funkcyjnie/DaneOpcjonalne.java

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

P01-JavaSE/src/main/java/pcz/emps/v3_funkcyjnie/Employee.java

+package pcz.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;
+    }
+
+}

P01-JavaSE/src/main/java/pcz/emps/v3_funkcyjnie/F0_WypiszWszystko.java

+package pcz.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);
+	}
+
+}

P01-JavaSE/src/main/java/pcz/emps/v3_funkcyjnie/F1_WypiszDane.java

+package pcz.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);
+	}
+
+}

P01-JavaSE/src/main/java/pcz/emps/v3_funkcyjnie/F2_Filtrowanie.java

+package pcz.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ół".
+
+    }
+
+}

P01-JavaSE/src/main/java/pcz/emps/v3_funkcyjnie/F3_SredniaWszystkich.java

+package pcz.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);
+	}
+
+}

P01-JavaSE/src/main/java/pcz/emps/v3_funkcyjnie/F4_SredniaJedenJob.java

+package pcz.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);
+		}
+	}
+
+}

P01-JavaSE/src/main/java/pcz/emps/v3_funkcyjnie/F5_MiastaBezPowtorzen.java

+package pcz.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);
+	}
+
+}

P01-JavaSE/src/main/java/pcz/emps/v3_funkcyjnie/F6_MinMax.java

+package pcz.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);
+	}
+
+}

P01-JavaSE/src/main/java/pcz/emps/v3_funkcyjnie/F7_Sortowanie.java

+package pcz.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);
+	}
+
+}

P01-JavaSE/src/main/java/pcz/emps/v3_funkcyjnie/F7b_Sortowanie_WieleKryteriow.java

+package pcz.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()));
+	}
+
+}

P01-JavaSE/src/main/java/pcz/emps/v3_funkcyjnie/F8_Partycje.java

+package pcz.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());
+		});
+	}
+
+}

P01-JavaSE/src/main/java/pcz/emps/v3_funkcyjnie/F9_Podwyzka.java

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

P01-JavaSE/src/main/java/pcz/emps/v3_funkcyjnie/Grupowanie7.java

+package pcz.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();
+        });
+    }
+
+}

P01-JavaSE/src/main/java/pcz/emps/v3_funkcyjnie/Grupowanie8.java

+package pcz.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);
+        });
+    }
+
+}

P01-JavaSE/src/main/java/pcz/emps/v3_funkcyjnie/Grupowanie9.java

+package pcz.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());
+		});
+	}
+
+}

P01-JavaSE/src/main/java/pcz/emps/v3_funkcyjnie/ObslugaCSV.java

+package pcz.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();
+        }
+    }
+
+}

P01-JavaSE/src/main/java/pcz/emps/v3_funkcyjnie/S2_Filtrowanie.java

+package pcz.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);
+    }
+
+}

P01-JavaSE/src/main/java/pcz/emps/v3_funkcyjnie/S4_SredniaJedenJob.java

+package pcz.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);
+		}
+	}
+
+}

P01-JavaSE/src/main/java/pcz/emps/v3_funkcyjnie/S_Grupowanie9.java

+package pcz.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());
+		});
+	}
+
+}

P01-JavaSE/src/main/java/pcz/p02_zmienne/Typy.java → P01-JavaSE/src/main/java/pcz/p02_zmienne/E_Typy.java

@@ -2,7 +2,7 @@ package pcz.p02_zmienne;
 
 import java.time.LocalDate;
 
-public class Typy {
+public class E_Typy {
 
     public static void main(String[] args) {
         // Typy dzielą się na dwie kategorie:

P01-JavaSE/src/main/java/pcz/p02_zmienne/SlowoVar.java → P01-JavaSE/src/main/java/pcz/p02_zmienne/F_SlowoVar.java

@@ -2,7 +2,7 @@ package pcz.p02_zmienne;
 
 import java.time.LocalTime;
 
-public class SlowoVar {
+public class F_SlowoVar {
 
     public static void main(String[] args) {
         // Przykład kompiluje się od Javy 10.

P01-JavaSE/src/main/java/pcz/p02_zmienne/M_BlokiTekstowe.java

+package pcz.p02_zmienne;
+
+public class M_BlokiTekstowe {
+    public static void main(String[] args) {
+        // od Java 17 dostępne są wieloliniowe Stringi
+        String napis = """
+                 Ala ma kota.
+                    Ola ma psa.
+                Ela ma "chomika", \ttak tak.
+                """;
+        System.out.println(napis.length());
+        System.out.println(napis);
+    }
+}

P01-JavaSE/src/main/java/pcz/p02_zmienne/PolaFinal.java

-package pcz.p02_zmienne;
-
-public class PolaFinal {
-    // pola które są final muszą być jawnie zainicjalizowane
-    // albo w tym miejscu, albo w bloku inicjalizacyjnym, albo w konstruktorze
-    final int numer;
-
-    public PolaFinal() {
-        numer = 0;
-    }
-
-    public PolaFinal(int nr) {
-        numer = nr;
-    }
-}

P01-JavaSE/src/main/java/pcz/p02_zmienne/Nazwy.java → P01-JavaSE/src/main/java/pcz/p02_zmienne/Z_Nazwy.java

 package pcz.p02_zmienne;
 
-public class Nazwy {
+public class Z_Nazwy {
 
     public static void main(String[] args) {
         // Nazwa nie może zaczynać się od cyfry

P01-JavaSE/src/main/java/pcz/p03_instrukcje/a_if/Losowanie.java

+package pcz.p03_instrukcje.a_if;
+
+import java.util.Random;
+import java.util.concurrent.ThreadLocalRandom;
+
+public class Losowanie {
+
+    public static void main(String[] args) {
+        // tworzymy obiekt Random - "generator liczb pseudolosowych"
+        Random random = new Random();
+        
+        double d = random.nextDouble();
+        // liczba z zakresu [0.0 , 1.0)
+        System.out.println("double: " + d);
+
+        // losowy int z całego zakresu intów (orientacyjnie od -2mld do +2mld)
+        int x = random.nextInt();
+        
+        // int z zakresu od 0 do limit-1, czyli tu od 0 do 99
+        int y = random.nextInt(100);
+        
+        // int z zakresu od 500 włącznie do 1000 wyłączając, czyli od 500 do 999
+        // nie było to dostępne od początku
+        int z = random.nextInt(500, 1000);
+
+        System.out.println(x + " " + y + " " + z);
+        
+        // alternatywnie, bez tworzenia obiektu Random - każdy wątek ma swojego prywatnego randoma
+        // Od Java 7
+        int r = ThreadLocalRandom.current().nextInt();
+        System.out.println(r);
+        
+        char losowaLitera1 = (char)(65 + random.nextInt(26));
+        char losowaLitera2 = (char)('A' + random.nextInt('Z' - 'A' + 1));
+        System.out.print(losowaLitera1);
+        System.out.print(losowaLitera2);
+    }
+
+}
+

P01-JavaSE/src/main/java/pcz/p03_instrukcje/c_switch/DniTygodnia0.java

+package pcz.p03_instrukcje.c_switch;
+
+import javax.swing.JOptionPane;
+
+public class DniTygodnia0 {
+
+    public static void main(String[] args) {
+        int numer = Integer.parseInt(JOptionPane.showInputDialog("Podaj numer dnia tygodnia"));
+        if(numer == 1) {
+            JOptionPane.showMessageDialog(null, "To jest poniedziałek");
+        } else if (numer == 2) {
+            JOptionPane.showMessageDialog(null, "To jest wtorek");
+        } else if (numer == 3) {
+            JOptionPane.showMessageDialog(null, "To jest środa");
+        } else if (numer == 4) {
+            JOptionPane.showMessageDialog(null, "To jest czwartek");
+        } else if (numer == 5) {
+            JOptionPane.showMessageDialog(null, "To jest piątek");
+            JOptionPane.showMessageDialog(null, "weekendu początek");
+        } else if (numer == 6) {
+            JOptionPane.showMessageDialog(null, "To jest sobota");
+        } else if (numer == 7) {
+            JOptionPane.showMessageDialog(null, "To jest niedziela");
+        } else {
+            JOptionPane.showMessageDialog(null, "Niepoprawny numer", "Błąd", JOptionPane.ERROR_MESSAGE);
+        }
+        JOptionPane.showMessageDialog(null, "Koniec programu");
+    }
+
+}

P01-JavaSE/src/main/java/pcz/p03_instrukcje/c_switch/DniTygodnia1.java

+package pcz.p03_instrukcje.c_switch;
+
+import javax.swing.JOptionPane;
+
+public class DniTygodnia1 {
+    // switch w takiej wersji, jaka w Javie jest dostępna od samego początku i działa też w języku C
+    // Jeśli mamy case'y z dwukropkami, a brakuje instrukcji break,
+    // to program przechodzi do kolejnych case'ów
+
+    public static void main(String[] args) {
+        int numer = Integer.parseInt(JOptionPane.showInputDialog("Podaj numer dnia tygodnia"));
+        switch(numer) {
+        case 1:
+            JOptionPane.showMessageDialog(null, "To jest poniedziałek");
+        case 2:
+            JOptionPane.showMessageDialog(null, "To jest wtorek");
+        case 3:
+            JOptionPane.showMessageDialog(null, "To jest środa");
+        case 4:
+            JOptionPane.showMessageDialog(null, "To jest czwartek");
+        case 5:
+            JOptionPane.showMessageDialog(null, "To jest piątek");
+            JOptionPane.showMessageDialog(null, "weekendu początek");
+        case 6:
+            JOptionPane.showMessageDialog(null, "To jest sobota");
+        case 7:
+            JOptionPane.showMessageDialog(null, "To jest niedziela");
+        default:
+            JOptionPane.showMessageDialog(null, "Niepoprawny numer", "Błąd", JOptionPane.ERROR_MESSAGE);            
+        }
+        JOptionPane.showMessageDialog(null, "Koniec programu");
+
+    }
+
+}

P01-JavaSE/src/main/java/pcz/p03_instrukcje/c_switch/Switch2.java → P01-JavaSE/src/main/java/pcz/p03_instrukcje/c_switch/DniTygodnia2.java

@@ -2,40 +2,38 @@ package pcz.p03_instrukcje.c_switch;
 
 import javax.swing.JOptionPane;
 
-public class Switch2 {
-
+public class DniTygodnia2 {
+    // switch w takiej wersji, jaka w Javie jest dostępna od samego początku i działa też w języku C
+    // Aby przerwać wykonanie po jednym case, trzeba użyć break
     public static void main(String[] args) {
-        String tekst = JOptionPane.showInputDialog("Podaj numer dnia tygodnia");
-        int numer = Integer.parseInt(tekst);
-
+        int numer = Integer.parseInt(JOptionPane.showInputDialog("Podaj numer dnia tygodnia"));
         switch(numer) {
         case 1:
-            System.out.println("poniedziałek");
+            JOptionPane.showMessageDialog(null, "To jest poniedziałek");
             break;
         case 2:
-            System.out.println("wtorek");
+            JOptionPane.showMessageDialog(null, "To jest wtorek");
             break;
         case 3:
-            System.out.println("środa");
+            JOptionPane.showMessageDialog(null, "To jest środa");
             break;
         case 4:
-            System.out.println("czwartek");
+            JOptionPane.showMessageDialog(null, "To jest czwartek");
             break;
         case 5:
-            System.out.println("piątek");
-            System.out.println("czyli weekendu początek");
+            JOptionPane.showMessageDialog(null, "To jest piątek");
+            JOptionPane.showMessageDialog(null, "weekendu początek");
             break;
         case 6:
-            System.out.println("sobota");
+            JOptionPane.showMessageDialog(null, "To jest sobota");
             break;
         case 7:
-            System.out.println("niedziela");
+            JOptionPane.showMessageDialog(null, "To jest niedziela");
             break;
         default:
-            System.out.println("niepoprawny numer dnia tygodnia");
+            JOptionPane.showMessageDialog(null, "Niepoprawny numer", "Błąd", JOptionPane.ERROR_MESSAGE);            
         }
-
-        System.out.println("Koniec programu");
+        JOptionPane.showMessageDialog(null, "Koniec programu");
     }
 
 }

P01-JavaSE/src/main/java/pcz/p03_instrukcje/c_switch/DniTygodnia3.java

+package pcz.p03_instrukcje.c_switch;
+
+import javax.swing.JOptionPane;
+
+public class DniTygodnia3 {
+    // switch w takiej wersji ze -> strzałkami, jaka w Javie jest dostępna od wersji 14
+    // Tutaj na pewno wykona się tylko jeden case; nie pisze się już break
+    public static void main(String[] args) {
+        int numer = Integer.parseInt(JOptionPane.showInputDialog("Podaj numer dnia tygodnia"));
+        switch(numer) {
+        case 1 ->
+            JOptionPane.showMessageDialog(null, "To jest poniedziałek");
+        case 2 ->
+            JOptionPane.showMessageDialog(null, "To jest wtorek");
+        case 3 ->
+            JOptionPane.showMessageDialog(null, "To jest środa");
+        case 4 ->
+            JOptionPane.showMessageDialog(null, "To jest czwartek");
+        case 5 -> {
+            JOptionPane.showMessageDialog(null, "To jest piątek");
+            JOptionPane.showMessageDialog(null, "weekendu początek");
+        }
+        case 6 ->
+            JOptionPane.showMessageDialog(null, "To jest sobota");
+        case 7 ->
+            JOptionPane.showMessageDialog(null, "To jest niedziela");
+        default ->
+            JOptionPane.showMessageDialog(null, "Niepoprawny numer", "Błąd", JOptionPane.ERROR_MESSAGE);
+        }
+        JOptionPane.showMessageDialog(null, "Koniec programu");
+    }
+
+}

P01-JavaSE/src/main/java/pcz/p03_instrukcje/c_switch/DniTygodnia4.java

+package pcz.p03_instrukcje.c_switch;
+
+import javax.swing.JOptionPane;
+
+public class DniTygodnia4 {
+    // Nawet w oparciu o "stary styl" switchów możemy zdefiniować oddzielną funkcję,
+    // która mapuje numery dni tygodnia na ich nazwy.
+    // switch umieszczony w oddzielnej funkcji zaczyna wyglądać całkiem "zgrabnie".
+    
+    static String nazwaDniaTygodnia(int numer) {
+        switch(numer) {
+        case 1: return "poniedziałek";
+        case 2: return "wtorek";
+        case 3: return "środa";
+        case 4: return "czwartek";
+        case 5: return "piątek";
+        case 6: return "sobota";
+        case 7: return "niedziela";
+        default: throw new IllegalArgumentException("Niepoprawny numer " + numer);
+        }
+    }
+    
+    public static void main(String[] args) {
+        try {
+            int numer = Integer.parseInt(JOptionPane.showInputDialog("Podaj numer dnia tygodnia"));
+            String nazwa = nazwaDniaTygodnia(numer);
+            JOptionPane.showMessageDialog(null, "To jest " + nazwa);
+        } catch (IllegalArgumentException e) {
+            JOptionPane.showMessageDialog(null, e.getMessage(), "Błąd", JOptionPane.ERROR_MESSAGE);            
+        }
+    }
+
+}

P01-JavaSE/src/main/java/pcz/p03_instrukcje/c_switch/DniTygodnia5.java

+package pcz.p03_instrukcje.c_switch;
+
+import javax.swing.JOptionPane;
+
+public class DniTygodnia5 {
+    // Od Java 14 istnieje też konstrukcja "switch expression".
+    // Taki switch "daje wynik", który możemy np. wpisać do zmiennej.
+    // Przypomina to wywołanie funkcji, ale nie jest to oddzielna funkcja, tylko wyrażneie wpisane w miejscu użycia.
+    
+    public static void main(String[] args) {
+        try {
+            int numer = Integer.parseInt(JOptionPane.showInputDialog("Podaj numer dnia tygodnia"));
+            
+            String nazwa = switch(numer) {
+                case 1 -> "poniedziałek";
+                case 2 -> "wtorek";
+                case 3 -> "środa";
+                case 4 -> "czwartek";
+                case 5 -> "piątek";
+                case 6 -> "sobota";
+                case 7 -> "niedziela";
+                default-> throw new IllegalArgumentException("Niepoprawny numer " + numer);
+            };
+            JOptionPane.showMessageDialog(null, "To jest " + nazwa);
+        } catch (IllegalArgumentException e) {
+            JOptionPane.showMessageDialog(null, e.getMessage(), "Błąd", JOptionPane.ERROR_MESSAGE);            
+        }
+    }
+
+}

P01-JavaSE/src/main/java/pcz/p03_instrukcje/c_switch/IleDniMaMiesiac1.java

+package pcz.p03_instrukcje.c_switch;
+
+import javax.swing.JOptionPane;
+
+public class IleDniMaMiesiac1 {
+
+    public static void main(String[] args) {
+        String miesiac = JOptionPane.showInputDialog("Podaj nazwę miesiąca");
+        
+        // używając switcha (najlepiej jakoś "sprytnie" ;-) )
+        // wypisz ile dni ma ten miesiąc
+        // DLA CHĘTNYCH - w przypadku lutego zapytaj o rok i stosując zasady kalendarza gregoriańskiego
+        // ustal, czy rok jest przestępny
+        // rok jest przestępny, jeśli jest podzielny przez 4, ale nie jest podzielny przez 100, chyba że jest podzielny przez 400
+        
+        // wersja mało sprytna - po prostu 12 oddzielnych przypadków
+        switch(miesiac) {
+            case "styczeń" -> JOptionPane.showMessageDialog(null, "Ten miesiąc ma 31 dni");
+            case "luty" -> JOptionPane.showMessageDialog(null, "Ten miesiąc ma 28/29 dni");
+            case "marzec" -> JOptionPane.showMessageDialog(null, "Ten miesiąc ma 31 dni");
+            case "kwiecień" -> JOptionPane.showMessageDialog(null, "Ten miesiąc ma 30 dni");
+            case "maj" -> JOptionPane.showMessageDialog(null, "Ten miesiąc ma 31 dni");
+            case "czerwiec" -> JOptionPane.showMessageDialog(null, "Ten miesiąc ma 30 dni");
+            case "lipiec" -> JOptionPane.showMessageDialog(null, "Ten miesiąc ma 31 dni");
+            case "sierpień" -> JOptionPane.showMessageDialog(null, "Ten miesiąc ma 31 dni");
+            case "wrzesień" -> JOptionPane.showMessageDialog(null, "Ten miesiąc ma 30 dni");
+            case "październik" -> JOptionPane.showMessageDialog(null, "Ten miesiąc ma 31 dni");
+            case "listopad" -> JOptionPane.showMessageDialog(null, "Ten miesiąc ma 30 dni");
+            case "grudzień" -> JOptionPane.showMessageDialog(null, "Ten miesiąc ma 31 dni");
+            default -> JOptionPane.showMessageDialog(null, "Niepoprawny miesiąc", "Błąd", JOptionPane.ERROR_MESSAGE);
+        }
+    }
+
+}

P01-JavaSE/src/main/java/pcz/p03_instrukcje/c_switch/IleDniMaMiesiac2.java

+package pcz.p03_instrukcje.c_switch;
+
+import javax.swing.JOptionPane;
+
+public class IleDniMaMiesiac2 {
+
+    public static void main(String[] args) {
+        String miesiac = JOptionPane.showInputDialog("Podaj nazwę miesiąca");
+        // jeśli stosujemy switch / case w starym stylu z dwukropkiem,
+        // to można zgrupować case'y dla których jest jednakowa odpowiedź
+        // i nie pisać między nimi break
+        switch(miesiac) {
+           case "styczeń":
+           case "marzec":
+           case "maj":
+           case "lipiec":
+           case "sierpień":
+           case "październik":
+           case "grudzień":
+               JOptionPane.showMessageDialog(null,"Ten miesiąc ma 31 dni");
+               break;
+           case "luty":
+               JOptionPane.showMessageDialog(null,"Ten miesiąc ma 28/29 dni");
+               break;
+           case "kwiecień":
+           case "czerwiec":
+           case "wrzesień":
+           case "listopad":
+               JOptionPane.showMessageDialog(null,"Ten miesiąc ma 30 dni");
+               break;
+           default:
+               JOptionPane.showMessageDialog(null, "Niepoprawny miesiąc", "Błąd", JOptionPane.ERROR_MESSAGE);
+        }
+    }
+
+}

P01-JavaSE/src/main/java/pcz/p03_instrukcje/c_switch/IleDniMaMiesiac3.java

+package pcz.p03_instrukcje.c_switch;
+
+import javax.swing.JOptionPane;
+
+public class IleDniMaMiesiac3 {
+
+    public static void main(String[] args) {
+        String miesiac = JOptionPane.showInputDialog("Podaj nazwę miesiąca");
+
+        // Od Java 14 w jednym case można podać wiele wartości po przecinku
+        switch(miesiac) {
+        case "styczeń", "marzec", "maj", "lipiec", "sierpień", "październik", "grudzień" ->
+            JOptionPane.showMessageDialog(null, "Ten miesiąc ma 31 dni");
+        case "kwiecień", "czerwiec", "wrzesień", "listopad" ->
+            JOptionPane.showMessageDialog(null, "Ten miesiąc ma 30 dni");
+        case "luty" -> {
+            int rok = Integer.parseInt(JOptionPane.showInputDialog("Podaj rok"));
+            if (rok % 4 == 0 && rok % 100 != 0 || rok % 400 == 0) {
+                JOptionPane.showMessageDialog(null, "Ten miesiąc ma 29 dni");
+            } else {
+                JOptionPane.showMessageDialog(null, "Ten miesiąc ma 28 dni");
+            }
+        }
+        default -> JOptionPane.showMessageDialog(null, "Niepoprawny miesiąc", "Błąd", JOptionPane.ERROR_MESSAGE);
+        }
+    }
+
+}

P01-JavaSE/src/main/java/pcz/p03_instrukcje/c_switch/IleDniMaMiesiac5.java

+package pcz.p03_instrukcje.c_switch;
+
+import javax.swing.JOptionPane;
+
+public class IleDniMaMiesiac5 {
+
+    public static void main(String[] args) {
+        try {
+            String miesiac = JOptionPane.showInputDialog("Podaj nazwę miesiąca");
+    
+            int ileDni = switch(miesiac) {
+                // w ramach switch expression, jeśli po wybraniu case'a wiemy od razu, jaki ma być wynik,
+                // to po prostu piszemy go za -> strzałką
+                case "styczeń", "marzec", "maj", "lipiec", "sierpień", "październik", "grudzień" -> 31;
+                case "kwiecień", "czerwiec", "wrzesień", "listopad" -> 30;
+                // ale jeśli w danym case jest więkcej kroków do wykonania,
+                // to wynik switcha zwracamy za pomocą słowa yield
+                case "luty" -> {
+                    int rok = Integer.parseInt(JOptionPane.showInputDialog("Podaj rok"));
+                    if(rok % 4 == 0 && rok % 100 != 0 || rok % 400 == 0) {
+                        yield 29;
+                    } else {
+                        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);
+        }
+        
+        // przy okazji - nowe instrukcje Javy mają status "identyfikatora o specjalym znaczeniu" a nie "słowa kluczowego"
+        // to znaczy, że w innych miejscach działają jak zwykłe nazwy; mogą być używane np. dla zmiennych
+        boolean yield = true;
+        var var = 15;
+        if(yield) {
+            JOptionPane.showMessageDialog(null, var);
+        }
+    }
+
+}

P01-JavaSE/src/main/java/pcz/p03_instrukcje/c_switch/Switch1.java

-package pcz.p03_instrukcje.c_switch;
-
-import javax.swing.JOptionPane;
-
-public class Switch1 {
-
-    public static void main(String[] args) {
-        String tekst = JOptionPane.showInputDialog("Podaj numer dnia tygodnia");
-        int numer = Integer.parseInt(tekst);
-
-        switch(numer) {
-        case 1:
-            System.out.println("poniedziałek");
-        case 2:
-            System.out.println("wtorek");
-        case 3:
-            System.out.println("środa");
-        case 4:
-            System.out.println("czwartek");
-        case 5:
-            System.out.println("piątek");
-            System.out.println("czyli weekendu początek");
-        case 6:
-            System.out.println("sobota");
-        case 7:
-            System.out.println("niedziela");
-        default:
-            System.out.println("niepoprawny numer dnia tygodnia");
-        }
-
-        System.out.println("Koniec programu");
-    }
-
-}

P01-JavaSE/src/main/java/pcz/p03_instrukcje/c_switch/Switch3.java

-package pcz.p03_instrukcje.c_switch;
-
-import java.util.Random;
-
-import javax.swing.JOptionPane;
-
-public class Switch3 {
-
-    public static void main(String[] args) {
-        String tekst = JOptionPane.showInputDialog("Podaj numer dnia tygodnia");
-        int numer = Integer.parseInt(tekst);
-
-        final int SOBOTA = 6; // stała
-        // final int SOBOTA = new Random().nextInt(10);
-
-        switch(numer) {
-        case 3:
-            System.out.println("środa");
-            break;
-        case 1:
-            System.out.println("poniedziałek");
-            break;
-        case 2:
-            System.out.println("wtorek");
-            break;
-        default:
-            System.out.println("niepoprawny numer dnia tygodnia");
-            break;
-        case 4:
-            System.out.println("czwartek");
-            break;
-        case 2 + 3:
-            System.out.println("piątek");
-            break;
-        case SOBOTA:
-            System.out.println("sobota");
-            // tu nie ma break i wypisze się sobota niedziela
-        case 7:
-            System.out.println("niedziela");
-        }
-
-        System.out.println("Koniec programu");
-    }
-
-}

P01-JavaSE/src/main/java/pcz/p03_instrukcje/c_switch/Switch4.java

-package pcz.p03_instrukcje.c_switch;
-
-import javax.swing.JOptionPane;
-
-public class Switch4 {
-
-    static String nazwaDniaTygodnia(int numer) {
-        switch(numer) {
-        case 1:
-            return "poniedziałek";
-        case 2:
-            return "wtorek";
-        case 3:
-            return "środa";
-        case 4:
-            return "czwartek";
-        case 5:
-            return "piątek";
-        case 6:
-            return "sobota";
-        case 7:
-            return "niedziela";
-        default:
-            throw new IllegalArgumentException("Niepoprawny numer dnia tygodnia");
-        }
-    }
-
-    public static void main(String[] args) {
-        String tekst = JOptionPane.showInputDialog("Podaj numer dnia tygodnia");
-
-        try {
-            int numer = Integer.parseInt(tekst);
-            String nazwa = nazwaDniaTygodnia(numer);
-            System.out.println("Ten dzień to " + nazwa);
-        } catch(Exception wylapanyWyjatek) {
-            System.out.println("Wystąpił wyjątek " + wylapanyWyjatek);
-        }
-
-        System.out.println("Koniec programu");
-    }
-
-}

P01-JavaSE/src/main/java/pcz/p03_instrukcje/c_switch/Switch5.java

-package pcz.p03_instrukcje.c_switch;
-
-public class Switch5 {
-
-    static int ileDniMaMiesiac(String nazwa) {
-        switch(nazwa) {
-        case "styczeń":
-        case "marzec":
-        case "maj":
-        case "lipiec":
-        case "sierpień":
-        case "październik":
-        case "grudzień":
-            return 31;
-
-        case "kwiecień":
-        case "czerwiec":
-        case "wrzesień":
-        case "listopad":
-            return 30;
-
-        case "luty":
-            return 28;
-
-        //		case null się nie skompiluje
-        //		case null:
-        //			return 0;
-
-        default:
-            return 0;
-        }
-    }
-
-    public static void main(String[] args) {
-        System.out.println(ileDniMaMiesiac("styczeń"));
-        System.out.println(ileDniMaMiesiac("luty"));
-        System.out.println(ileDniMaMiesiac("listopad"));
-        System.out.println();
-
-        // takie bajery nie działają:
-        System.out.println(ileDniMaMiesiac("Lipiec"));
-        System.out.println(ileDniMaMiesiac(" lipiec "));
-        System.out.println(ileDniMaMiesiac("*ec"));
-        System.out.println(ileDniMaMiesiac("%ec"));
-
-        System.out.println(ileDniMaMiesiac(""));
-        System.out.println(ileDniMaMiesiac(null)); // NPE
-
-    }
-
-}

P01-JavaSE/src/main/java/pcz/p03_instrukcje/c_switch/Switch8.java

-package pcz.p03_instrukcje.c_switch;
-
-public class Switch8 {
-
-    public static void main(String[] args) {
-        int x = 2;
-
-        switch(x) {
-        // to jest po prostu operacja arytmetyczna (dokładnie "suma bitowa")
-        // nie ma to żadnego szczególnego znaczenia dla switch-a
-        // w tym konkretnym miejscu to wylicza się do wartości 3
-        case 2 | 3:
-            System.out.println("2 | 3");
-            break;
-        //NK		case 3:
-        //			System.out.println("3");
-        case 2: // bo to nie jest naruszenie unikalności
-            System.out.println("2");
-            break;
-        default:
-            System.out.println("default");
-        }
-
-    }
-
-}

P01-JavaSE/src/main/java/pcz/p03_instrukcje/c_switch/Switch6.java → P01-JavaSE/src/main/java/pcz/p03_instrukcje/c_switch/Switch_TypyLiczbowe.java

 package pcz.p03_instrukcje.c_switch;
 
-public class Switch6 {
+public class Switch_TypyLiczbowe {
 
     public static void main(String[] args) {
         byte bb = 100;

P01-JavaSE/src/main/java/pcz/p12_dziedziczenie/sealed/Circle.java

+package pcz.p12_dziedziczenie.sealed;
+
+// Klasa finalna: nie może być rozszerzana
+public final class Circle extends Shape {
+    private final double radius;
+
+    public Circle(double radius) {
+        this.radius = radius;
+    }
+
+    public double getRadius() {
+        return radius;
+    }
+}
\ No newline at end of file

P01-JavaSE/src/main/java/pcz/p12_dziedziczenie/sealed/FilledRectangle.java

+package pcz.p12_dziedziczenie.sealed;
+
+public final class FilledRectangle extends Rectangle {
+    public FilledRectangle(double width, double height) {
+        super(width, height);
+    }
+}

P01-JavaSE/src/main/java/pcz/p12_dziedziczenie/sealed/Rectangle.java

+package pcz.p12_dziedziczenie.sealed;
+
+// Klasa sealed: nadal kontroluje dziedziczenie
+public sealed class Rectangle extends Shape permits FilledRectangle {
+    private final double width;
+    private final double height;
+
+    public Rectangle(double width, double height) {
+        this.width = width;
+        this.height = height;
+    }
+}
\ No newline at end of file

P01-JavaSE/src/main/java/pcz/p12_dziedziczenie/sealed/Shape.java

+package pcz.p12_dziedziczenie.sealed;
+
+public sealed class Shape permits Circle, Rectangle, Square {
+    // Wspólna logika dla wszystkich kształtów
+}
\ No newline at end of file

P01-JavaSE/src/main/java/pcz/p12_dziedziczenie/sealed/Square.java

+package pcz.p12_dziedziczenie.sealed;
+
+// Klasa non-sealed: otwarta na dowolne dziedziczenie
+public non-sealed class Square extends Shape {
+    private final double side;
+
+    public Square(double side) {
+        this.side = side;
+    }
+
+    public double getSide() {
+        return side;
+    }
+}

P01-JavaSE/src/main/java/pcz/p13_abstrakcyjne/Figura.java

+package pcz.p13_abstrakcyjne;
+
+import java.util.Locale;
+
+public abstract class Figura {
+    private String kolor;
+
+    protected Figura(String kolor) {
+        this.kolor = kolor;
+    }
+
+    public abstract double pole();
+
+    public abstract double obwod();
+
+    public String getKolor() {
+        return kolor;
+    }
+
+    /* Dodatkowa rzecz, którą dopisałem po zajęciach.
+     * Przy okazji:
+     * 1) To jest przykład zastosowania wzroca "template method", który polega na tym,
+     *    że w klasie abstrakcyjnej definiuje się metodę M, w której treści wywoływana
+     *    jest metoda abstrakcyjna A. Podklasy tej klasy anstrakcyjnej definiują brakującą metodę A.
+     *    W nadklasie zdefiniowane jest jakieś działanie na poziomie ogólnym,
+     *    a podklasy uzupełniają szczegóły w odpowiedni dla siebie sposób.
+     * 2) Od Java 17 istnieją Stringi blokowe, które zapisuje się w potrójnych cudzysłowach.
+     *    Poziom wcięcia "zero" jest określany poprzez cudzysłowy zamykające.
+     */
+    public void wypiszInfo() {
+        System.out.printf(Locale.US, """
+                To jest figura klasy %s, jej kolor jest %s.
+                Pole wynosi %s cm², a obwód %s cm.
+                """, this.getClass().getSimpleName(), this.getKolor(),
+                this.pole(), this.obwod());
+    }
+}

P01-JavaSE/src/main/java/pcz/p13_abstrakcyjne/Kolo.java

+package pcz.p13_abstrakcyjne;
+
+public class Kolo extends Figura {
+    private double promien;
+
+    public Kolo(String kolor, double promien) {
+        super(kolor);
+        this.promien = promien;
+    }
+
+    public double getPromien() {
+        return promien;
+    }
+    
+    @Override
+    public double pole() {
+        return Math.PI * promien * promien;
+    }
+
+    @Override
+    public double obwod() {
+        return Math.PI * 2 * promien;
+    }
+
+}

P01-JavaSE/src/main/java/pcz/p13_abstrakcyjne/Program.java

+package pcz.p13_abstrakcyjne;
+
+public class Program {
+
+    public static void main(String[] args) {
+        // Można deklarować zmienne typu "klasa abstrakcyjna".
+        Figura f1 = null;
+
+        // Ale nie można tworzyć obiektów klasy abstrakcyjnej.
+//        Figura f2 = new Figura("blue");
+//        System.out.println(f2);
+
+        Kolo kolo = new Kolo("green", 5);
+        System.out.println(kolo);
+        System.out.println(kolo.getPromien() + " " + kolo.getKolor());
+        System.out.println(kolo.pole() + " " + kolo.obwod());
+
+        // Obiekt podklasy mogę wpisać do zmiennej typu nadklasa
+        f1 = kolo;
+        // teraz dostępne są te metody, które były zadklarowane w nadklasie
+        // każda figura ma kolor, pole i obwód, ale nie każda ma promień
+        // System.out.println(f1.getPromien());
+        System.out.println(f1.getKolor());
+        System.out.println(f1.pole() + " " + f1.obwod());
+
+        Figura f3 = new Prostokat("red", 3, 4);
+        System.out.println(f3.pole() + " " + f3.obwod());
+        // System.out.println(f3.liczbaWierzcholkow());
+        System.out.println();
+
+        kolo.wypiszInfo();
+        f1.wypiszInfo();
+        f3.wypiszInfo();
+    }
+
+}

P01-JavaSE/src/main/java/pcz/p13_abstrakcyjne/Prostokat.java

+package pcz.p13_abstrakcyjne;
+
+public class Prostokat extends Wielokat {
+    private double a, b;
+
+    public Prostokat(String kolor, double a, double b) {
+        super(kolor);
+        this.a = a;
+        this.b = b;
+    }
+
+    @Override
+    public int liczbaWierzcholkow() {
+        return 4;
+    }
+
+    @Override
+    public double pole() {
+        return this.a*this.b;
+    }
+
+    @Override
+    public double obwod() {
+        return 2*this.a + 2*this.b;
+    }
+
+    public double getA() {
+        return this.a;
+    }
+
+    public double getB() {
+        return this.b;
+    }
+
+}

P01-JavaSE/src/main/java/pcz/p13_abstrakcyjne/Wielokat.java

+package pcz.p13_abstrakcyjne;
+
+// Można na kolejnym poziomie tworzyć klasę abstrakcyjną,
+// teoretycznie jej podklasami mogą być trójkąt, czworokąt / prostokąt, itd...
+public abstract class Wielokat extends Figura {    
+    protected Wielokat(String kolor) {
+        super(kolor);
+    }
+
+    public abstract int liczbaWierzcholkow();
+    
+    // nie mam obowiązku implementowaia pole i obwód, bo jestem w klasie abstrakcyjnej
+}

P01-JavaSE/src/main/java/pcz/p27_generyki/kolekcje/DeklaracjeGeneryczne.java

+package pcz.p27_generyki.kolekcje;
+
+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
+		List l6a = new ArrayList<String>();
+
+		//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<Object> l12 = new ArrayList<String>();
+		//NK List<String> l13 = new ArrayList<Object>();
+
+		List<? extends Object> l14 = new ArrayList<String>();
+		List<?> l15 = new ArrayList<String>(); // sam ? jest równoważny ? extends Object
+		
+		//NK List<?> foo1 = new ArrayList<? extends Number>();
+		//NK List<?> foo2 = new ArrayList<? super Number>();
+		//NK List<?> foo3 = new ArrayList<?>();
+	}
+
+}

P01-JavaSE/src/main/java/pcz/p27_generyki/kolekcje/OszukiwanieGenerykow.java

+package pcz.p27_generyki.kolekcje;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class OszukiwanieGenerykow {
+
+	public static void main(String[] args) {
+		List<String> lista = new ArrayList<String>();
+		
+		Integer i = 99;
+		
+		lista.add("Ala");
+		//NK lista.add(7);
+		//NK lista.add(i);
+		
+		List oszust = lista;
+		
+		oszust.add("Ola");
+		oszust.add(i);  // tu nie jeszcze błędu
+		oszust.add(8);
+		
+		System.out.println(lista.size());
+		System.out.println(lista);
+		
+		for(Object o : lista) {
+			System.out.println(o + " obiekt klasy " + o.getClass().getSimpleName());
+		}
+		System.out.println();
+		
+		for(String s : lista) {  // dopiero tu jest błąd CCE gdy dojdziemy do Integera
+			System.out.println(s);
+		}
+	}
+}

P01-JavaSE/src/main/java/pcz/p27_generyki/kolekcje/OszukiwanieGenerykow2.java

+package pcz.p27_generyki.kolekcje;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+public class OszukiwanieGenerykow2 {
+	
+	static void metodaOszukujaca(List<String> lista) {
+		List oszust = lista;
+		oszust.add(Integer.valueOf(113));
+	}
+
+	public static void main(String[] args) {
+		List<String> lista1 = new ArrayList<String>();
+		lista1.add("Ala");
+		lista1.add("Ola");
+		System.out.println(lista1);
+		metodaOszukujaca(lista1);
+		System.out.println(lista1);
+		System.out.println();
+
+		List<String> lista2 = new ArrayList<String>();
+		List<String> listaZabezpieczona = Collections.checkedList(lista2, String.class);
+		
+		// checkedList daje zachowanie typu "fail-fast" - od razu w momencie wykonanie niepoprawnej operacji następuje wyjątek
+		
+		lista2.add("Ela");
+		listaZabezpieczona.add("Ula");
+		
+		// listaZabezpieczona jest "widokiem" listy oryginalnej
+		// zmiany dokonywane poprzez jedną zmienną są widziane przez drugą
+		System.out.println(lista2);
+		System.out.println(listaZabezpieczona);
+		
+		metodaOszukujaca(listaZabezpieczona); // teraz będzie wyjątek już przy próbie dodania niezgodnego elementu
+		System.out.println(lista2);
+	}
+}

P01-JavaSE/src/main/java/pcz/p27_generyki/kolekcje/Polimorfizm1.java

+package pcz.p27_generyki.kolekcje;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class Polimorfizm1 {
+	
+	static double testPojedynczego(Number arg) {
+		return arg.doubleValue();
+	}
+
+	static double suma1(List<Number> lista) {
+		double wynik = 0.0;
+		for (Number number : lista) {
+			wynik += number.doubleValue();
+		}
+		return wynik;
+	}
+	
+	static void modyfikuj1(List<Number> lista) {
+		lista.add(Long.valueOf(10_000_000_000L));
+	}
+	
+	static double suma2(List<? extends Number> lista) {
+		//NK lista.add(Long.valueOf(10_000_000_000L));
+		double wynik = 0.0;
+		for (Number number : lista) {
+			wynik += number.doubleValue();
+		}
+		return wynik;
+	}
+
+	static double suma2a(Iterable<? extends Number> lista) {
+		//NK lista.add(Long.valueOf(10_000_000_000L));
+		double wynik = 0.0;
+		for (Number number : lista) {
+			wynik += number.doubleValue();
+		}
+		return wynik;
+	}
+
+	static void modyfikuj2(List<? super Long> lista) {
+		lista.add(Long.valueOf(10_000_000_000L));
+	}
+
+	
+	/** Zamienia pierwszy element z ostatnim i zwraca ich średnią */	
+	static <T extends Number> double sredniaZZamiana(List<T> lista) {
+		T pierwszy = lista.get(0);
+		T ostatni = lista.get(lista.size()-1);
+		
+		lista.set(0, ostatni);
+		lista.set(lista.size()-1, pierwszy);
+		
+		return (pierwszy.doubleValue() + ostatni.doubleValue()) / 2.0;
+	}
+
+	/* to się nie kompilowało, bo wewnątrz funkcji o elementach listy było wiadomo tlyko,
+	 * że są to jakieś Numbery - a to za mało aby wpisać do listy niewiadomoczego
+	 * Lista mogłaby być listą Integerów, a zmienne pierwszy i ostatni sa typu Number. */
+	/*
+ 	static double sredniaZZamiana2(List<? extends Number> lista) {
+		
+		Number pierwszy = lista.get(0);
+		Number ostatni = lista.get(lista.size()-1);
+		
+		lista.set(0, ostatni);
+		lista.set(lista.size()-1, pierwszy);
+		
+		return (pierwszy.doubleValue() + ostatni.doubleValue()) / 2.0;
+	}
+	*/
+
+	/*
+	static double sredniaZZamiana3(List<? super Number> lista) {
+		Number pierwszy = lista.get(0);
+		Number ostatni = lista.get(lista.size()-1);
+		
+		lista.set(0, ostatni);
+		lista.set(lista.size()-1, pierwszy);
+		
+		return (pierwszy.doubleValue() + ostatni.doubleValue()) / 2.0;
+	}
+	*/
+	
+	/* //Takiej składni nie ma:
+	static <T super Number> void metoda3(List<T> lista) {
+	}
+	*/
+	
+	// Sam znak zapytania jest równoważny <? extends Object> - co nie wnosi żadnej wiedzy
+	// "lista czegokolwiek"
+	// To nie jest to samo co List<Object> !!!
+	// bo wtedy nie dałoby się przekazać np. List<Integer>
+	
+	// To też nie jest to samo co po prostu List.
+	
+	static int metoda4a(List<Object> lista) {
+		return lista == null ? 0 : lista.size();
+	}
+
+	static int metoda4(List<?> lista) {
+		return lista == null ? 0 : lista.size();
+	}
+	
+	
+	static void metoda5(List<?> lista) {
+		// z takiej listy można odczytywać elementy - są dla nas Objectami
+		Object o = lista.get(0);
+		
+		// do takiej listy nie możemy wstawić niczego innego niż null
+		
+		// być może jest to lista Integerów? albo Stringów? nie wiadomo - na wszelki wypadek kompilator zabrania wstawiać czegokolwiek-
+		//NK lista.add(new Object());
+		
+		// null pasuje do każdego typu
+		lista.add(null);
+	}
+	
+	public static void main(String[] args) {
+		double wynik;
+
+		Number nn = new Long(123L);
+		Integer ii = new Integer(321);
+		
+		wynik = testPojedynczego(nn);
+		System.out.println(wynik);
+		wynik = testPojedynczego(ii);
+		System.out.println(wynik);
+		System.out.println();
+		
+		List<Number> numbers = new ArrayList<>();
+		numbers.add(10);
+		numbers.add(20);
+		numbers.add(30);
+		numbers.add(40);
+		System.out.println(numbers);
+		
+		
+		List<Integer> ints = new ArrayList<>();
+		ints.add(11);
+		ints.add(21);
+		ints.add(31);
+		ints.add(41);
+		System.out.println(ints);
+		
+		wynik = suma1(numbers);
+		System.out.println(wynik);
+		System.out.println();
+		
+		// Gdy metoda oczekuje listy Numberów, nie można przekazać listy Integerów
+//		wynik = suma1(ints);
+//		System.out.println(wynik);
+//		System.out.println();
+		
+
+		// Do listy Numberów można dodać Longa - OK
+		modyfikuj1(numbers);
+		System.out.println(numbers);
+		
+		// Gdyby można było przekazywać, to to wywołanie zepsułoby listę Integerów
+		// - na takiej liście znalazłby się Long
+//		modyfikuj1(ints);
+//		System.out.println(ints);		
+		System.out.println();
+
+		// Nie wolno też przypisać List<Integer> na zmienną List<Number>
+		//NK List<Integer> ints2 = numbers;
+		
+		wynik = suma2(numbers);
+		System.out.println(wynik);
+		System.out.println();
+
+		wynik = suma2(ints);
+		System.out.println(wynik);
+		System.out.println();
+
+		modyfikuj2(numbers);
+		System.out.println(numbers);
+
+//		modyfikuj2(ints);
+//		System.out.println(ints);
+		
+		//NK metoda4a(ints); // List<Object>
+		
+		metoda4(ints); // List<?>
+
+	}
+	
+}

P01-JavaSE/src/main/java/pcz/p27_generyki/kolekcje/Polimorfizm2.java

+package pcz.p27_generyki.kolekcje;
+
+import java.time.LocalDate;
+import java.util.ArrayList;
+import java.util.List;
+
+public class Polimorfizm2 {
+	
+	// Przykład funkcji, która zadziała dla dowolnej listy - typ elementu w ogóle nieistotny
+	static void usunOstatni(List<?> lista) {
+		int size = lista.size();
+		if(size > 0) {
+			lista.remove(size-1);
+		}
+	}
+	
+	// Do tak zadeklarowanej funkcji będzie można przekazać tylko listę Objectów
+	// (konkretnie List<Object>, nic innego)
+	static void usunOstatniZle(List<Object> lista) {
+		int size = lista.size();
+		if(size > 0) {
+			lista.remove(size-1);
+		}
+	}
+	
+	public static void main(String[] args) {
+		List<String> listaStringow = new ArrayList<>();
+		List<Integer> listaIntow = new ArrayList<>();
+		List<LocalDate> listaDat = new ArrayList<>();
+		
+		List<?> lista1 = new ArrayList<>();
+		// do tak zadeklarowanej listy nie można dodać niczego
+		// lista1.add("ala");
+		
+		// OK, można dodać nulla
+		lista1.add(null);
+		
+		// Dlaczego?
+		// List<?> jest równoważna takiej:
+		List<? extends Object> lista2 = new ArrayList<>();
+		// lista2.add("ala");
+		lista2.add(null);
+		
+		// To znaczy, że na taką zmienną można wpisać dowolną listę:
+		lista2 = listaDat;
+		// czy można wpisać Stringa na taką listę?
+		// kompilator zabrania wstawiać czegokolwiek - chodzi o tym zmiennej, a nie listy w pamięci
+
+		// lista2.add("ala");
+		lista2 = listaIntow;
+		
+		lista1 = listaDat;
+		lista1 = listaIntow;
+		
+		for (Object object : lista1) {
+			// podczas czytania elementy widzimy jako Objecty
+		}
+		
+		
+		Class<Polimorfizm2> klasa1 = Polimorfizm2.class;
+		//NK Class<Polimorfizm2> klasa2 = String.class;
+		
+		Class<?> klasa3 = Polimorfizm2.class;
+		Class<?> klasa4 = String.class;
+		
+		Class<? extends Number> klasa5;
+		klasa5 = Integer.class;
+		klasa5 = Long.class;
+		klasa5 = Number.class;
+		//NK klasa5 = String.class;
+	}
+
+}

P01-JavaSE/src/main/java/pcz/p27_generyki/kolekcje/Polimorfizm3_Tablice.java

+package pcz.p27_generyki.kolekcje;
+
+import java.util.Arrays;
+
+public class Polimorfizm3_Tablice {
+	
+	static double suma(Number[] t) {
+		double suma = 0.0;
+		for (Number number : t) {
+			suma += number.doubleValue();
+		}
+		return suma;
+	}
+	
+	static void modyfikuj(Number[] t) {
+		t[0] = new Long(10_000_000_000L);
+	}
+
+	public static void main(String[] args) {
+		Number[] numbers = new Number[] {10, 20, 30, 40, 50};
+		Integer[] ints = new Integer[] {11, 21, 31, 41};
+
+		Number[] numbers2 = ints;
+		//NK Integer[] ints2 = numbers2;
+		
+		
+		double wynik;
+		wynik = suma(numbers);
+		System.out.println(wynik);
+
+		// jesli chodzi o tablicę, to tablica podklas jest traktowana jak podklasa tablicy nadklas
+		wynik = suma(ints);
+		System.out.println(wynik);
+		System.out.println();
+		
+		modyfikuj(numbers);
+		System.out.println(Arrays.toString(numbers));
+		
+		modyfikuj(ints);
+		System.out.println(Arrays.toString(ints));
+	}
+
+}

P01-JavaSE/src/main/java/pcz/p27_generyki/kolekcje/StaraJava.java

+package pcz.p27_generyki.kolekcje;
+
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+
+public class StaraJava {
+
+	public static void main(String[] args) {
+		// Tak się używało list i innych kolekcji w wersjach Javy < 5
+		List lista = new ArrayList();
+		lista.add("Ala");
+		lista.add("Ola");
+		lista.add("Ela");
+		// lista.add(new Integer(133));
+		System.out.println(lista);
+		
+		Iterator it = lista.iterator();
+		while(it.hasNext()) {
+			String elt = (String)it.next();
+			System.out.println(elt);
+		}
+		
+		String imie = (String)lista.get(1);
+		System.out.println(imie);
+	}
+
+}

P01-JavaSE/src/main/java/pcz/p27_generyki/techniczne/GdzieMoznaUzywacGenerykow.java

+package pcz.p27_generyki.techniczne;
+
+public class GdzieMoznaUzywacGenerykow {
+	
+	private static class Box<T> {
+		// Parametru generycznego można używać:
+		// typ zmiennej instanyjnej
+		
+		T x, y;
+		
+		// typ paraterów i wyniku metod instancyjnych:
+		T metoda(T parametr, String innyParametr) {
+			// typ zmiennej lokalnej wewnątrz metody instancyjnej:
+			
+			T zmienna = parametr;
+			if(zmienna == null) {
+				zmienna = x;
+			}
+			
+			return zmienna;
+		}
+		
+		
+		// Parametru generycznego nie można używać:
+		// w kontekście statycznym
+		// static T statyczna;
+		
+		// static T metodaStatyczna(T arg) {
+		// 	return arg;
+		// }
+		
+		static void normalnaMetodaStatyczna() {
+			// T zmienna = null;
+		}
+		
+		void test(T arg1, Object arg2) {
+			
+			// Parametru generycznego nie można używać również w poleceniach,
+			// które wymagałyby znajomości tego typu w runtajmie:
+			
+			// System.out.println(T.class);
+			
+			System.out.println(x.getClass());
+			
+//			if(arg1 instanceof T) {
+//				
+//			}
+//
+//			if(arg2 instanceof T) {
+//				
+//			}
+
+			// rzutowanie można zapisać, ale nie ma jak sprawdzić w instaceof czy to bezpieczne
+			T t = (T)arg2;
+			System.out.println(t);
+		}
+		
+	}
+
+}

P01-JavaSE/src/main/java/pcz/p27_generyki/techniczne/MetodyInstancyjne.java

+package pcz.p27_generyki.techniczne;
+
+import java.time.LocalDate;
+
+public class MetodyInstancyjne<A> {
+	// Metody mogą być parametryzowane typami generycznymi - każda niezależnie.
+	// Te parametry nie mają nic wspólnego z parametreami na poziomie klasy, w której jesteśmy (gdyby takie były).
+
+	A aaa(A a) {
+		System.out.println("a = " + a);
+		return a;
+	}
+
+	// A jest parametrem ustalonym na poziomie klasy, a B na poziomie metody
+	<B> B bbb(A a, B b) {
+		System.out.println("a = " + a + " , b = " + b);
+		return b;
+	}
+	
+	// Parametr podany na poziomie metody może przesłonić parametr podany na poziomie klasy
+	<A> A ccc(A a) {
+		System.out.println("a = " + a);
+		return a;
+	}
+	
+
+	public static void main(String[] args) {
+		MetodyInstancyjne<String> instancjaString = new MetodyInstancyjne<>();
+
+		MetodyInstancyjne<Integer> instancjaInteger = new MetodyInstancyjne<>();
+		
+		String s1 = instancjaString.aaa("Ala");
+		System.out.println(s1);
+		// LocalDate s2 = instancjaString.aaa(LocalDate.now());
+		
+		// Na pierwszym parametrze musi być String,
+		// na drugim może być cokolwiek. Typ metody mówi, że wynik jest tego samego typu, co drugi argument.
+		String s3 = instancjaString.bbb("Ala", "Ola");
+		System.out.println(s3);
+		
+		LocalDate s4 = instancjaString.bbb("Ala", LocalDate.now());
+		System.out.println(s4);
+		
+		LocalDate s5 = instancjaInteger.bbb(123, LocalDate.now());
+		System.out.println(s5);
+		
+		LocalDate s6 = instancjaString.ccc(LocalDate.now());
+		System.out.println(s6);
+		
+		
+	}
+
+}

P01-JavaSE/src/main/java/pcz/p27_generyki/techniczne/MetodyStatyczne.java

+package pcz.p27_generyki.techniczne;
+
+import java.util.Optional;
+
+import pcz.p27_generyki.v2_generics.Para;
+
+public class MetodyStatyczne {
+	// Metody mogą być parametryzowane typami generycznymi - każda niezależnie.
+	// Te parametry nie mają nic wspólnego z parametreami na poziomie klasy, w której jesteśmy (gdyby takie były).
+	// Można to robić zarówno dla metod statycznych (w praktyce znacznie częściej),
+	// jak i dla instancyjnych.
+
+	static <T> T ident(T arg) {
+		return arg;
+	}
+
+	static <T> Optional<T> opakuj(T arg) {
+		if (arg == null) {
+			return Optional.empty();
+		} else {
+			return Optional.of(arg);
+		}
+	}
+	
+	static <T> T dajNulla() {
+		return null;
+	}
+
+	static <L, R> void wypisz(Para<L,R> para) {
+		System.out.println(para);
+	}
+
+	static <L, R> Para<R,L> zamien(Para<L,R> para) {
+		return new Para<>(para.getPrawy(), para.getLewy());
+	}
+
+	static Para<?,?> toSamo(Para<?,?> para) {
+		return para;
+	}
+
+	public static void main(String[] args) {
+		String s, z;
+		s = "Ala";
+		
+		z = ident(s);
+		System.out.println(z);
+		
+		System.out.println(opakuj(s));
+		System.out.println(opakuj(null));
+	}
+
+}

P01-JavaSE/src/main/java/pcz/p27_generyki/v1_object/KolekcjeBezGenerykow.java

+package pcz.p27_generyki.v1_object;
+
+import java.util.ArrayList;
+
+public class KolekcjeBezGenerykow {
+
+	public static void main(String[] args) {
+		ArrayList lista = new ArrayList();
+		lista.add("Ala");
+		lista.add("Ola");
+		lista.add(new Integer(50));
+		System.out.println(lista);
+		
+		// W momencie wyjęcia obiektu z kolekcji, trzeba było dokonać rzutowania.
+		String imie = (String)lista.get(1);
+		System.out.println(imie);
+		
+		//EXN CCE imie = (String) lista.get(2);
+		// System.out.println(imie);
+	}
+
+}

P01-JavaSE/src/main/java/pcz/p27_generyki/v1_object/Para.java

+package pcz.p27_generyki.v1_object;
+
+import java.util.Objects;
+
+/* Wersja bez typów generycznych - programowanie jak w Javie <= 1.4 */
+public class Para {
+	private Object lewy;
+	private Object prawy;
+	
+	public Para() {
+	}
+
+	public Para(Object lewy, Object prawy) {
+		this.lewy = lewy;
+		this.prawy = prawy;
+	}
+
+	public Object getLewy() {
+		return lewy;
+	}
+
+	public void setLewy(Object lewy) {
+		this.lewy = lewy;
+	}
+
+	public Object getPrawy() {
+		return prawy;
+	}
+
+	public void setPrawy(Object prawy) {
+		this.prawy = prawy;
+	}
+
+	@Override
+	public String toString() {
+		return "<" + lewy + ", " + prawy + ">";
+	}
+
+	@Override
+	public int hashCode() {
+		return Objects.hash(lewy, prawy);
+	}
+
+	@Override
+	public boolean equals(Object obj) {
+		if (this == obj)
+			return true;
+		if (obj == null)
+			return false;
+		if (getClass() != obj.getClass())
+			return false;
+		Para other = (Para) obj;
+		return Objects.equals(lewy, other.lewy) && Objects.equals(prawy, other.prawy);
+	}
+	
+}