przykłady AMPS oraz PanTadeusz

src/emps/v1_nieobiektowo/P1_WypiszDane.java

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

src/emps/v1_nieobiektowo/P2_WypiszWybranych.java

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

src/emps/v1_nieobiektowo/P3_SredniaWszystkich.java

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

src/emps/v1_nieobiektowo/P4_SredniaJedenJob.java

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

src/emps/v1_nieobiektowo/SredniaProgramistow.java

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

src/emps/v2_obiektowo/Employee.java

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

src/emps/v2_obiektowo/Grupowanie0.java

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

src/emps/v2_obiektowo/Grupowanie1.java

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

src/emps/v2_obiektowo/Grupowanie1a.java

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

src/emps/v2_obiektowo/Grupowanie2.java

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

src/emps/v2_obiektowo/Grupowanie2a.java

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

src/emps/v2_obiektowo/Grupowanie3.java

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

src/emps/v2_obiektowo/Grupowanie4.java

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

src/emps/v2_obiektowo/Grupowanie5.java

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

src/emps/v2_obiektowo/Grupowanie6.java

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

src/emps/v2_obiektowo/MergeTlumaczenie.java

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

src/emps/v2_obiektowo/ObslugaCSV.java

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

src/emps/v2_obiektowo/P0_WypiszWszystko.java

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

src/emps/v2_obiektowo/P1_WypiszWybranePola.java

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

src/emps/v2_obiektowo/P2_WypiszBogatych.java

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

src/emps/v2_obiektowo/P3_SredniaWszystkich.java

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

src/emps/v2_obiektowo/P4_SredniaJedenJob_v1.java

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

src/emps/v2_obiektowo/P4_SredniaJedenJob_v2.java

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

src/emps/v2_obiektowo/P4_SredniaJedenJob_v3.java

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

src/emps/v2_obiektowo/P5_MiastaBezPowtorzen.java

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

src/emps/v2_obiektowo/P6_MinMax_v1.java

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

src/emps/v2_obiektowo/P6_MinMax_v2.java

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

src/emps/v2_obiektowo/P6_MinMax_v3.java

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

src/emps/v2_obiektowo/P6_MinMax_v4.java

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

src/emps/v2_obiektowo/P7_Sortowanie.java

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

src/emps/v2_obiektowo/P9_Podwyzka.java

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

src/emps/v2_obiektowo/P9_PodwyzkaOkienkowa.java

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

src/emps/v2_obiektowo/zadania.txt

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

src/pan_tadeusz/P01_Wypisz.java

+package pan_tadeusz;
+
+import java.io.BufferedReader;
+import java.io.FileReader;
+import java.io.IOException;
+
+public class P01_Wypisz {
+
+    public static void main(String[] args) {
+        // Wypisz całego Pana Tadeusza na ekran i policz, z ilu linii składał się plik
+        int ile = 0;
+        try(BufferedReader reader = new BufferedReader(new FileReader("pan_tadeusz.txt"))) {
+            while(true) {
+                String line = reader.readLine();
+                if(line == null) break;
+                System.out.println(line);
+                ile++;
+            }
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+        System.out.println("\nWszystkich linii było " + ile);
+    }
+
+}

src/pan_tadeusz/P02_ZnajdzLinie.java

+package pan_tadeusz;
+
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.util.Scanner;
+
+public class P02_ZnajdzLinie {
+
+    // Użytkownik wprowadza jakieś słowo (np. Tadeusz)
+    // Następnie program wypisuje tylko te linie, które zawieraja podane
+    // - na ten moment przyjmijcie, że sprawdzamy czy linia zawiera podany fragment
+    // line.contains(...)
+    // Wypisujemy, ile takich linii było.
+    public static void main(String[] args) {
+        Scanner wejscie = new Scanner(System.in);
+        System.out.println("Podaj szukane słowo: ");
+        String szukaneSlowo = wejscie.nextLine();
+        int ile = 0;
+
+        try(Scanner scanner = new Scanner(new File("pan_tadeusz.txt"))) {
+            while(scanner.hasNextLine()) {
+                String line = scanner.nextLine();
+                if(line.contains(szukaneSlowo)) {
+                    System.out.println(line);
+                    ile++;
+                }
+            }
+        } catch (FileNotFoundException e) {
+            e.printStackTrace();
+        }
+        System.out.println("\nZnalezionych linii: " + ile);
+    }
+}
\ No newline at end of file

src/pan_tadeusz/P03_WypiszWszystkieSlowa.java

+package pan_tadeusz;
+
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.util.Scanner;
+
+public class P03_WypiszWszystkieSlowa {
+
+    public static void main(String[] args) {
+        try(Scanner scanner = new Scanner(new File("pan_tadeusz.txt"))) {
+            // ustawienie "delimitera" jako wyrażenia regularnego,
+            // aby pomijać znaki interpunkcyjne
+            // scanner.useDelimiter(" ");
+            // scanner.useDelimiter("\\s+"); // każdy ciąg "białych znaków" - domyślne ustawienie Scannera
+            // scanner.useDelimiter("[\\s,.\\-—!?()*…«»;:]+"); // ciąg znaków wymienionych w nawiasach kwadratowych (niektóre wymagają poprzedzenia \\)
+            scanner.useDelimiter("[^\\p{L}\\d]+"); // ciąg znaków niebędących literami ani cyframi
+            int ile = 0;
+            while(scanner.hasNext()) {
+                String slowo = scanner.next();
+                System.out.println("["+slowo+"]");
+                ile++;
+            }
+            System.out.println("Lacznie slow: " + ile);            
+        } catch (FileNotFoundException e) {
+            e.printStackTrace();
+        }
+    }
+
+}

src/pan_tadeusz/P04_PoliczJednoSlowo.java

+package pan_tadeusz;
+
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.util.Scanner;
+
+public class P04_PoliczJednoSlowo {
+
+    public static void main(String[] args) {
+        Scanner wejscie = new Scanner(System.in);
+        System.out.println("Podaj szukane słowo: ");
+        String szukaneSlowo = wejscie.nextLine();
+        int ile = 0;
+        
+        try(Scanner scanner = new Scanner(new File("pan_tadeusz.txt"))) {
+            scanner.useDelimiter("[^\\p{L}\\d]+");
+            while(scanner.hasNext()) {
+                String slowo = scanner.next();
+                if(slowo.equalsIgnoreCase(szukaneSlowo)) {
+                    ile++;
+                }
+            }
+            System.out.println("Słowo " + szukaneSlowo + " występuje " + ile + " razy.");            
+        } catch (FileNotFoundException e) {
+            e.printStackTrace();
+        }
+    }
+
+}

src/pan_tadeusz/P05_PoliczSlowaUnikalnie.java

+package pan_tadeusz;
+
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.util.HashSet;
+import java.util.Scanner;
+import java.util.Set;
+
+public class P05_PoliczSlowaUnikalnie {
+
+    public static void main(String[] args) {
+        System.out.println("Startujemy");
+        Set<String> slowa = new HashSet<>();
+        
+        try(Scanner scanner = new Scanner(new File("pan_tadeusz.txt"))) {
+            scanner.useDelimiter("[^\\p{L}\\d]+");
+            while(scanner.hasNext()) {
+                String slowo = scanner.next().toLowerCase();
+                slowa.add(slowo);
+            }
+            System.out.println("Plik zawiera " + slowa.size() + " różnych słów.");            
+        } catch (FileNotFoundException e) {
+            e.printStackTrace();
+        }
+    }
+
+}

src/pan_tadeusz/P06_PoliczKazdeSlowo_v1.java

+package pan_tadeusz;
+
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.text.Collator;
+import java.util.Locale;
+import java.util.Map;
+import java.util.Scanner;
+import java.util.TreeMap;
+
+// Dla każdego słowa oblicz, ile razy ono występuje w pliku
+// Wypisz w takiej postaci:
+// tadeusz - 107
+// telimena - 54
+// ... - ...
+public class P06_PoliczKazdeSlowo_v1 {
+
+    public static void main(String[] args) {
+        System.out.println("Startujemy");
+        // Map<String, Integer> slowa = new HashMap<>();
+        // Map<String, Integer> slowa = new TreeMap<>();
+        // Map<String, Integer> slowa = new TreeMap<>(Collator.getInstance());
+        Map<String, Integer> slowa = new TreeMap<>(Collator.getInstance(Locale.of("pl", "PL")));
+
+        try(Scanner scanner = new Scanner(new File("pan_tadeusz.txt"))) {
+            scanner.useDelimiter("[^\\p{L}\\d]+");
+            while(scanner.hasNext()) {
+                String slowo = scanner.next().toLowerCase();
+                if(slowa.containsKey(slowo)) {
+                    // to jest kolejne wystąpienie tego słowa - trzeba zwiększyć o 1
+                    int ileBylo = slowa.get(slowo);
+                    slowa.put(slowo, ileBylo+1);
+                } else {
+                    // to jest pierwsze wystąpienie tego słowa - trzeba wstawić 1
+                    slowa.put(slowo, 1);
+                }
+            }
+        } catch (FileNotFoundException e) {
+            e.printStackTrace();
+        }
+
+        // System.out.println(slowa);
+        for(var entry : slowa.entrySet()) {
+            System.out.printf("%-20s : %5d\n", entry.getKey(), entry.getValue());
+        }
+
+    }
+
+}

src/pan_tadeusz/P06_PoliczKazdeSlowo_v2.java

+package pan_tadeusz;
+
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.text.Collator;
+import java.util.Locale;
+import java.util.Map;
+import java.util.Scanner;
+import java.util.TreeMap;
+
+public class P06_PoliczKazdeSlowo_v2 {
+
+    public static void main(String[] args) {
+        System.out.println("Startujemy");
+        // Map<String, Integer> slowa = new HashMap<>();
+        Map<String, Integer> slowa = new TreeMap<>(Collator.getInstance(Locale.of("pl", "PL")));
+
+        try(Scanner scanner = new Scanner(new File("pan_tadeusz.txt"))) {
+            scanner.useDelimiter("[^\\p{L}\\d]+");
+            while(scanner.hasNext()) {
+                String slowo = scanner.next().toLowerCase();
+                int ileBylo = slowa.getOrDefault(slowo, 0);
+                slowa.put(slowo, ileBylo+1);
+            }
+        } catch (FileNotFoundException e) {
+            e.printStackTrace();
+        }
+
+        // System.out.println(slowa);
+        for(var entry : slowa.entrySet()) {
+            System.out.printf("%-20s : %5d\n", entry.getKey(), entry.getValue());
+        }
+    }
+
+}

src/pan_tadeusz/P06_PoliczKazdeSlowo_v3.java

+package pan_tadeusz;
+
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.text.Collator;
+import java.util.Locale;
+import java.util.Map;
+import java.util.Scanner;
+import java.util.TreeMap;
+
+public class P06_PoliczKazdeSlowo_v3 {
+
+    public static void main(String[] args) {
+        System.out.println("Startujemy");
+        // Map<String, Integer> slowa = new HashMap<>();
+        Map<String, Integer> slowa = new TreeMap<>(Collator.getInstance(Locale.of("pl", "PL")));
+
+        try(Scanner scanner = new Scanner(new File("pan_tadeusz.txt"))) {
+            scanner.useDelimiter("[^\\p{L}\\d]+");
+            while(scanner.hasNext()) {
+                String slowo = scanner.next().toLowerCase();
+                slowa.merge(slowo, 1, Integer::sum); // method reference
+                // zaktualizuj slownik pod kluczem słowo:
+                // jeśli jeszcze nie było, to wpisz 1
+                // jeśli już było, to dodaj 1
+            }
+        } catch (FileNotFoundException e) {
+            e.printStackTrace();
+        }
+
+//         System.out.println(slowa);
+//        for(var entry : slowa.entrySet()) {
+//            System.out.printf("%-20s : %5d\n", entry.getKey(), entry.getValue());
+//        }
+        // inny sposób wypisania (od Java 8):
+        slowa.forEach((slowo, ile) -> {
+            System.out.printf("%-20s : %5d\n", slowo, ile);
+        });
+
+    }
+
+}

src/pan_tadeusz/P11_PosortujLinie.java

+package pan_tadeusz;
+
+import java.io.IOException;
+import java.nio.charset.Charset;
+import java.nio.file.Files;
+import java.nio.file.Paths;
+import java.util.List;
+
+public class P11_PosortujLinie {
+
+    public static void main(String[] args) {
+        try {
+            System.out.println("Czytanie...");
+            List<String> lines = Files.readAllLines(Paths.get("pan_tadeusz.txt"), Charset.forName("UTF-8"));
+            System.out.println("Wczytałem " + lines.size() + " linii");
+            System.out.println("Sortowanie...");
+            lines.sort(null);
+            System.out.println("Zapisywanie...");
+            Files.write(Paths.get("posortowany1.txt"), lines);
+            System.out.println("Gotowe.");
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+    }
+
+}

src/pan_tadeusz/P12_PosortujLiniePL.java

+package pan_tadeusz;
+
+import java.io.IOException;
+import java.nio.charset.Charset;
+import java.nio.file.Files;
+import java.nio.file.Paths;
+import java.text.Collator;
+import java.util.List;
+import java.util.Locale;
+
+public class P12_PosortujLiniePL {
+
+    public static void main(String[] args) {
+        try {
+            System.out.println("Czytanie...");
+            List<String> lines = Files.readAllLines(Paths.get("pan_tadeusz.txt"), Charset.forName("UTF-8"));
+            System.out.println("Wczytałem " + lines.size() + " linii");
+            System.out.println("Sortowanie...");
+            // lines.sort(null); // wg kodów Unicode
+            // lines.sort(Collator.getInstance()); // wg bieżących ustawień językowych
+            // lines.sort(Collator.getInstance(Locale.FRANCE)); // wg alfabetu konkretnego języka
+            lines.sort(Collator.getInstance(Locale.of("pl", "PL")));
+            // lines.sort(Collator.getInstance(Locale.of("en", "GB")));
+            System.out.println("Zapisywanie...");
+            Files.write(Paths.get("posortowany2.txt"), lines);
+            System.out.println("Gotowe.");
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+    }
+
+}

src/pan_tadeusz/P13_PosortujLinieZFiltrowaniem.java

+package pan_tadeusz;
+
+import java.io.IOException;
+import java.nio.charset.Charset;
+import java.nio.file.Files;
+import java.nio.file.Paths;
+import java.text.Collator;
+import java.util.List;
+import java.util.Locale;
+
+public class P13_PosortujLinieZFiltrowaniem {
+
+    public static void main(String[] args) {
+        try {
+            System.out.println("Czytanie...");
+            List<String> lines = Files.readAllLines(Paths.get("pan_tadeusz.txt"), Charset.forName("UTF-8"));
+            System.out.println("Wczytałem linii: " + lines.size());
+
+            System.out.println("Filtrowanie...");
+            lines.removeIf(String::isBlank);
+            lines.replaceAll(String::strip);
+            System.out.println("Po przefiltorowaniu linii jest: " + lines.size());
+
+            System.out.println("Sortowanie...");
+            // lines.sort(Collator.getInstance());
+            lines.sort(Collator.getInstance(Locale.of("pl", "PL")));
+            System.out.println("Zapisywanie...");
+            Files.write(Paths.get("posortowany3.txt"), lines);
+            System.out.println("Gotowe.");
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+    }
+
+}

src/pan_tadeusz/P14_PosortujLinieStream.java

+package pan_tadeusz;
+
+import java.io.IOException;
+import java.nio.charset.Charset;
+import java.nio.file.Files;
+import java.nio.file.Paths;
+import java.text.Collator;
+import java.util.List;
+
+public class P14_PosortujLinieStream {
+
+    public static void main(String[] args) {
+        try {
+            System.out.println("Startujemy...");
+            List<String> sorted = Files.lines(Paths.get("pan_tadeusz.txt"), Charset.forName("UTF-8"))
+                .filter(line -> !line.isBlank())
+                .map(String::strip)
+                .sorted(Collator.getInstance())
+                .toList(); // od Java 16; w starszych trzeba .collect(Collectors.toList())
+
+            System.out.println("Zapisywanie...");
+            Files.write(Paths.get("posortowany4.txt"), sorted);
+            System.out.println("Gotowe.");
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+    }
+
+}

src/pan_tadeusz/Ponumeruj1.java

+package pan_tadeusz;
+
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.util.Scanner;
+
+// Program wypisuje na ekran wszystkie linie Pana Tadeusza numerując je
+public class Ponumeruj1 {
+
+	public static void main(String[] args) {
+		try(Scanner in = new Scanner(new File("pan_tadeusz.txt"))) {
+			int nr = 0;
+			while(in.hasNextLine()) {
+				System.out.println(++nr + ": " + in.nextLine());
+			}
+			System.out.println("Liczba wszystkich linii: " + nr);
+		} catch (FileNotFoundException e) {
+			e.printStackTrace();
+		}
+	}
+
+}

src/pan_tadeusz/Ponumeruj2.java

+package pan_tadeusz;
+
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.PrintWriter;
+import java.util.Scanner;
+
+// W drugiej wersji niech ponumerowane linie zostaną zapisane do nowego pliku, np "ponumerowany.txt"
+// W tej drugiej wersji możecie też pomijać puste linie.
+public class Ponumeruj2 {
+
+	public static void main(String[] args) {
+		try(Scanner in = new Scanner(new File("pan_tadeusz.txt"));
+			PrintWriter out = new PrintWriter("pan_tadeusz_num.txt")) {
+			int nr = 0;
+			while(in.hasNextLine()) {
+				String linia = in.nextLine();
+				if(!linia.isBlank()) {
+					++nr;
+					out.println(nr + ": " + linia);
+				}
+			}
+			System.out.println("Gotowe. Liczba wszystkich linii: " + nr);
+		} catch (FileNotFoundException e) {
+			e.printStackTrace();
+		}
+	}
+
+}