Paczka gotowych przykładów

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

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

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

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

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

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

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

+package emps.v1_nieobiektowo;
+
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.util.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(t[3].equals(szukanyJob)) { // ew. Objects.equals(t[3], szukanyJob), gdybyśmy się bali nulla
+					suma += Integer.parseInt(t[4]);
+					ile++;
+				}
+			}
+			if(ile > 0) {
+				double srednia = suma / ile;
+				JOptionPane.showMessageDialog(null, String.format(
+						"Na stanowisku %s pracuje %d osób.\nŚrednia pensja wynosi %.2f",
+						szukanyJob, ile, srednia));
+			} else {
+				JOptionPane.showMessageDialog(null, String.format("Nikt nie pracuje na stanowisku %s.", szukanyJob),
+						"Brak danych", JOptionPane.WARNING_MESSAGE);
+			}
+		} catch (FileNotFoundException e) {
+			e.printStackTrace();
+		}
+	}
+
+}

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

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

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

+package emps.v2_obiektowo;
+
+import java.util.List;
+import java.util.Set;
+import java.util.TreeSet;
+
+// Dla każdego jobTitle występującego w pliku,
+// program oblicza średnią pensję pracowników na tym stanowisku.
+
+// Ta wersja ma gorszą złożoność obliczeniową od pozostałych. Tutaj dla każdego joba ponownie przeglądana jest cała lista proacowników.
+public class Grupowanie0 {
+
+	public static void main(String[] args) {
+		List<Employee> emps = ObslugaCSV.wczytaj("emps.csv");
+		// etap 1: ustalenie zbioru jobów bez powtórzeń
+		Set<String> jobs = new TreeSet<>();
+		for(Employee emp : emps) {
+			jobs.add(emp.getJobTitle());
+		}
+		// etap 2: dla każdego joba obliczamy średnią przeglądając wszystkoich pracowników i sprawdzając ifem
+		for(String job : jobs) {
+			double suma = 0;
+			int ile = 0;
+			
+			for(Employee emp : emps) {
+				if(job.equals(emp.getJobTitle())) {
+					suma += emp.getSalary();
+					ile++;
+				}
+			}
+			double srednia = suma / ile;
+			System.out.printf("%-32s | %2d | %8.2f%n", job, ile, srednia);
+		}
+	}
+
+}

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

+package emps.v2_obiektowo;
+
+import java.util.List;
+import java.util.Map;
+import java.util.TreeMap;
+
+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("emps.csv");
+		
+		Map<String, Integer> sumy = new TreeMap<>();
+		Map<String, Integer> ilosci = new TreeMap<>();
+
+		for(Employee emp : emps) {
+			if(sumy.containsKey(emp.getJobTitle())) {
+				// to jest kolejny pracownik → jego pensję trzeba dodać do tego, co jest w słowniku
+				int suma = sumy.get(emp.getJobTitle());
+				sumy.put(emp.getJobTitle(), suma + emp.getSalary());
+				int ile = ilosci.get(emp.getJobTitle());
+				ilosci.put(emp.getJobTitle(), ile+1);
+			} else {
+				// to jest pierwszy pracownik z takim jobem → do słownika trzeba wpisać początkową wartość
+				sumy.put(emp.getJobTitle(), emp.getSalary());
+				ilosci.put(emp.getJobTitle(), 1);
+			}
+		}
+
+		for(String job : sumy.keySet()) {
+			int suma = sumy.get(job);
+			int ile = ilosci.get(job);
+			double srednia = (double)suma / ile;
+			System.out.printf("| %-32s | %2d | %8.2f |%n", job, ile, srednia);
+		}
+	}
+}

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

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

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

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

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

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

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

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

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

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

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

+package emps.v2_obiektowo;
+
+import java.util.List;
+import java.util.Map;
+import java.util.TreeMap;
+
+// Podejście obiektowe do grupowania.
+
+public class Grupowanie6 {
+
+	public static void main(String[] args) {
+		final List<Employee> emps = ObslugaCSV.wczytaj("emps.csv");
+		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);
+		}
+		
+		for (JobInfo jobInfo : mapa.values()) {
+			System.out.println(jobInfo);
+		}
+	}
+
+	// Klasa zgnieżdżona - tylko dla przykładu.
+	// Równie dobrze mógłbym tę klase zdefiniować w osobnym pliku.
+	
+	// Obiekt tej klasy przechowuje statystyki job
+	private static class JobInfo {
+		final String jobTitle;
+		int count = 0;
+		int sum = 0;
+		int min = Integer.MAX_VALUE;
+		int max = Integer.MIN_VALUE;
+		
+		JobInfo(String jobTitle) {
+			this.jobTitle = jobTitle;
+		}
+
+		void update(Employee emp) {
+			int salary = emp.getSalary();
+			count++;
+			sum += salary;
+			if(salary < min) {
+				min = salary;
+			}
+			if(salary > max) {
+				max = salary;
+			}
+		}
+		
+		double avg() {
+			return (double)sum / count;
+		}
+
+		@Override
+		public String toString() {
+			return "jobTitle=" + jobTitle + ", count=" + count + ", sum=" + sum + ", min=" + min + ", max="
+					+ max + ", avg=" + avg();
+		}
+	}
+}

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

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

src/main/java/emps/v2_obiektowo/P0_WypiszObiekty.java

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

src/main/java/emps/v2_obiektowo/P1_WypiszDane.java

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

src/main/java/emps/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("emps.csv");
+		System.out.printf("Co najmniej %d zarbiają pracownicy:%n", limit);
+		for(Employee emp : emps) {
+			if(emp.getSalary() >= limit) {
+				System.out.printf(" * %s %s (%s) z pensją %s%n",
+					emp.getFirstName(), emp.getLastName(), emp.getJobTitle(), emp.getSalary());
+			}
+		}
+	}
+
+}

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

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

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

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

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

+package emps.v2_obiektowo;
+
+import java.util.List;
+import 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
+// 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("emps.csv");
+		double suma = 0;
+		int ile = 0;
+		for(Employee emp : emps) {
+			if(szukanyJob.equalsIgnoreCase(emp.getJobTitle())) {
+				suma += emp.getSalary();
+				ile++;
+			}
+		}
+
+		if(ile > 0) {
+			double srednia = suma / ile;
+			JOptionPane.showMessageDialog(null, String.format(
+					"Na stanowisku %s pracuje %d osób.\nŚrednia pensja wynosi %.2f",
+					szukanyJob, ile, srednia));
+		} else {
+			JOptionPane.showMessageDialog(null, String.format("Nikt nie pracuje na stanowisku %s.", szukanyJob),
+					"Brak danych", JOptionPane.WARNING_MESSAGE);
+		}
+	}
+}

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

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

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

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

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

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

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

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

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

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

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

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

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

+package emps.v2_obiektowo;
+
+import java.util.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");
+
+// tutaj comparator zdefiniuję za pomocą wyrażenia lambda. więcej wersji zobaczymy w pakiecie v3_funkcyjnie
+//		emps.sort((emp1, emp2) -> emp1.getSalary() - emp2.getSalary());
+		emps.sort((emp1, emp2) -> Integer.compare(emp1.getSalary(), emp2.getSalary()));
+		
+		for(Employee emp : emps) {
+			System.out.println(emp);
+		}
+		System.out.println();
+		
+		System.out.println("Najbiednieszy: " + emps.getFirst());
+		System.out.println("Najbogatszy: " + emps.getLast());
+	}
+
+}
+

src/main/java/emps/v2_obiektowo/Podwyzka.java

+package emps.v2_obiektowo;
+
+import java.util.List;
+
+import javax.swing.JOptionPane;
+
+public class Podwyzka {
+
+	public static void main(String[] args) {
+		List<Employee> emps = ObslugaCSV.wczytaj("emps.csv");
+		String szukanyJob = JOptionPane.showInputDialog("Podaj nazwę stanowiska");
+		int podwyzka = Integer.parseInt(JOptionPane.showInputDialog("Podaj kwotę podwyżki"));
+		int ile = 0;
+		
+		for(Employee emp : emps) {
+			if(emp.getJobTitle().equalsIgnoreCase(szukanyJob)) {
+				emp.setSalary(emp.getSalary() + podwyzka);
+				ile++;
+			}
+		}
+		ObslugaCSV.zapisz(emps, "zmieniony.csv");
+		JOptionPane.showMessageDialog(null, "Zmieniono " + ile + " rekordów");
+	}
+
+}

src/main/java/emps/v2_obiektowo/PodwyzkaInteraktywna.java

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

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

+package emps.v3_funkcyjnie;
+
+import java.util.List;
+
+public class CzegoSieNieDaWLambdach {
+	static int sumaStatyczna = 0;
+
+	public static void main(String[] args) {
+		List<Employee> emps = ObslugaCSV.wczytaj("emps.csv");
+
+		// czy damy radę obliczyć sumę pensji za pomocą tego nowego forEach?
+		int sumaLokalna = 0;
+		int[] tablica = {0};
+
+		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();
+		});
+
+		System.out.println(sumaLokalna);
+		System.out.println(sumaStatyczna);
+		System.out.println(tablica[0]);
+		System.out.println();
+
+		// właściwe podejście:
+		int suma = emps.stream().mapToInt(Employee::getSalary).sum();
+		System.out.println(suma);
+	}
+}

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

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

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

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

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

+package emps.v3_funkcyjnie;
+
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+
+// W tej wersji kolektor groupingBy zbiera rekordy w grupy, ale nie wylicza żadnych statystyk.
+// Inne znaczenie słowa "grupowanie", niż w SQL.
+public class Grupowanie7 {
+
+	public static void main(String[] args) {
+		List<Employee> emps = ObslugaCSV.wczytaj("emps.csv");
+		
+		Map<String, List<Employee>> grupy = emps.stream().collect(Collectors.groupingBy(Employee::getJobTitle));
+		// w tym słowniku dla danego jobTitle znajduje się lista wszystkich pracowników, którzy mają takie jobTitle
+		// System.out.println(grupy);
+		
+		grupy.forEach((job, lista) -> {
+			System.out.printf("Stanowisko %s (%d osób):%n", job, lista.size());
+			lista.forEach(emp -> {
+				System.out.printf(" * %s %s ($%d)%n", emp.getFirstName(), emp.getLastName(), emp.getSalary());
+			});
+			System.out.println();
+		});
+	}
+
+}

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

+package emps.v3_funkcyjnie;
+
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+
+// W tej wersji dla każdej grupy od razu obliczymy funkcję agregującą "average".
+// Takie znaczenie słowa "grupowanie", jak w SQL.
+public class Grupowanie8 {
+
+	public static void main(String[] args) {
+		List<Employee> emps = ObslugaCSV.wczytaj("emps.csv");
+		
+		Map<String, Double> grupy = emps.stream()
+				.collect(Collectors.groupingBy(
+						Employee::getJobTitle,
+						Collectors.averagingInt(Employee::getSalary)));
+		
+		grupy.forEach((job, srednia) -> {
+			System.out.printf("%-32s → %8.2f%n", job, srednia);
+		});
+	}
+
+}

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

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

src/main/java/emps/v3_funkcyjnie/Grupowanie99.java

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

src/main/java/emps/v3_funkcyjnie/Modyfikacja.java

+package emps.v3_funkcyjnie;
+
+import java.util.List;
+
+public class Modyfikacja {
+	// 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()));
+	}
+
+}

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

+package emps.v3_funkcyjnie;
+
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.io.PrintWriter;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.time.LocalDate;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Scanner;
+import java.util.stream.Stream;
+
+public class ObslugaCSV {
+	public static List<Employee> wczytaj() {
+		// używa domyślnego pliku
+		return wczytaj("emps.csv");
+	}
+	
+	public static List<Employee> wczytaj(String sciezka) {
+		return wczytaj(new File(sciezka));
+	}
+	
+	public static List<Employee> wczytaj(File plik) {
+		List<Employee> emps = new ArrayList<>();
+		try(Scanner scanner = new Scanner(plik)) {
+			scanner.nextLine(); // pomijamy pierwszą linię
+			while(scanner.hasNextLine()) {
+				String linia = scanner.nextLine();
+				Employee emp = parsujLinie(linia);
+				emps.add(emp);
+			}
+		} catch (FileNotFoundException e) {
+			e.printStackTrace();
+			// w razie błędu (brak pliku) wypiszemy czerwone teksty na ekran, ale nie przerwiemy programu, tylko zwrócimy pustą listę
+		}
+		return emps;
+	}
+
+	public static Stream<Employee> wczytajStrumieniowo(Path plik) {
+		try {
+			return Files.lines(plik)
+					.skip(1)
+					.map(ObslugaCSV::parsujLinie);
+		} catch (IOException e) {
+			e.printStackTrace();
+			return Stream.empty();
+		}
+	}
+	
+	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");
+	}
+	
+	private static Employee parsujLinie(String linia) {
+		String[] t = linia.split(";", -1);
+		Employee emp = new Employee(Integer.parseInt(t[0]), t[1], t[2], t[3],
+				Integer.parseInt(t[4]), LocalDate.parse(t[5]),
+				t[6], t[7], t[8], t[9], t[10]);
+		return emp;
+	}
+
+}

src/main/java/emps/v3_funkcyjnie/P0_WypiszWszystko.java

+package emps.v3_funkcyjnie;
+
+import java.util.List;
+
+public class P0_WypiszWszystko {
+
+	public static void main(String[] args) {
+		List<Employee> emps = ObslugaCSV.wczytaj("emps.csv");
+		
+		// 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 uzyć notacji "method reference".
+		emps.forEach(System.out::println);
+		
+		// Można też najpierw pobrać "strumień" i dopiero na strumienia wywołać forEach, ale tu nie jest to konieczne.
+		// emps.stream().forEach(System.out::println);
+	}
+
+}

src/main/java/emps/v3_funkcyjnie/P1_WypiszDane.java

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

src/main/java/emps/v3_funkcyjnie/P2_Filtrowanie.java

+package emps.v3_funkcyjnie;
+
+import java.util.List;
+
+public class P2_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.csv");
+		
+		emps.stream()
+			.filter(emp -> emp.getSalary() >= 10_000)
+			.map(emp -> emp.getFirstName() + " " + emp.getLastName() + " " + emp.getSalary())
+			.map(String::toUpperCase) // ew.  .map(s -> s.toUpperCase())
+			.forEach(System.out::println);
+		
+		// Cały ten ↑ zapis jest określany "pipeline", który składa się z:
+		// - źródła danych
+		// - dowolnej liczby operacji pośrednich (intermediate, tutaj są to filter i map)
+		// - operacji końcowej (terminal, tutaj jest to forEach)
+		// Każdy obiekt przechodzi przez kolejne etapy przetwarzania, "schodzi z góry w dół".
+	}
+
+}

src/main/java/emps/v3_funkcyjnie/P3_SredniaWszystkich.java

+package emps.v3_funkcyjnie;
+
+import java.util.List;
+import java.util.OptionalDouble;
+import java.util.stream.Collectors;
+
+public class P3_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
+		OptionalDouble srednia1 = emps.stream()
+			.mapToInt(Employee::getSalary)
+			.average();
+		System.out.println(srednia1);
+		// Gdyby strumień był pusty, to wynikiem byłby pusty Optional.
+		// Aby dostać się do samej liczby, najelepiej zrobić to tak (w razie braku danych podstawi 0):
+		
+		double srednia2 = emps.stream()
+			.mapToInt(Employee::getSalary)
+			.average()
+			.orElse(0);
+		System.out.println(srednia2);
+		
+		// 2) odpowiedni Collector, czyli taka maszynka, która zbiera dane i na końcu zwraca wynik
+		Double srednia3 = emps.stream().collect(Collectors.averagingInt(Employee::getSalary));
+		System.out.println(srednia3);
+	}
+
+}

src/main/java/emps/v3_funkcyjnie/P4_SredniaJedenJob.java

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

src/main/java/emps/v3_funkcyjnie/P5_MiastaBezPowtorzen.java

+package emps.v3_funkcyjnie;
+
+import java.util.List;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+public class P5_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())
+			.distinct()
+			.sorted()
+			.forEach(System.out::println);
+	}
+
+}

src/main/java/emps/v3_funkcyjnie/P6_MinMax.java

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

src/main/java/emps/v3_funkcyjnie/P7_Sortowanie.java

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

src/main/java/emps/v3_funkcyjnie/P8_Partycje.java

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

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

+package emps.v3_funkcyjnie;
+
+public class S2_Filtrowanie {
+
+	// Program wypisuje tylko zarabiających >= 10 tys,
+	// realizujemy to filtrowaniem, ale przy okazji pokazuję Wam schemat "filter / map" - podstawowe operacje na strumieniach.
+	// W tej wersji wczytujemy dane strumieniowo prosto z pliku, bez tworzenia listy.
+	public static void main(String[] args) {
+		ObslugaCSV.wczytajStrumieniowo("emps.csv")
+			.filter(emp -> emp.getSalary() >= 10_000)
+			.map(emp -> emp.getFirstName() + " " + emp.getLastName() + " " + emp.getSalary())
+			.map(String::toUpperCase) // ew.  .map(s -> s.toUpperCase())
+			.forEach(System.out::println);
+	}
+
+}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

src/main/java/gotowe/p01_interakcja/argumenty/Argumenty.java

+package gotowe.p01_interakcja.argumenty;
+
+/*
+Gdy uruchamiamy jakiś program w systemowym wierszu poleceń,
+możemy po jego nazwie podać dowolne napisy – argumenty programu.
+
+java pcz.p01_interakcja.argumenty.Argumenty Jeden Dwa "Ala ma kota" Cztery
+*/
+
+public class Argumenty {
+    public static void main(String[] args) {
+        System.out.println("Liczba argumentów: " + args.length);
+        // System.out.println("Argument nr 1: " + args[1]);
+
+        for(String arg: args) {
+            System.out.println(arg);
+        }
+    }
+}

src/main/java/gotowe/p01_interakcja/konsola/A_Print.java

+package gotowe.p01_interakcja.konsola;
+
+import java.util.Locale;
+
+public class A_Print {
+
+    public static void main(String[] args) {
+
+        // println wypisuje coś i potem przechodzi do nast. linii
+        System.out.println("Wypisuję pierwszą linię");
+        System.out.println("Wypisuję drugą linię");
+
+        System.err.println("To jest niby błąd");
+
+        // pusty println - pusta linia
+        System.out.println();
+
+        // print - wypisuje coś i nie przechodzi do nowej linii
+        System.out.print("Ala");
+        System.out.print("Ola");
+        System.out.print("Ela");
+        System.out.println("Koniec");
+
+        int x = 50;
+        String s = "Ala";
+
+        // print, println przyjmują dowolne parametry
+        System.out.println(x);
+
+        // ale przyjmują tylko jeden parametr
+        //System.out.println("Liczba:", x);
+
+        // Jeśli chcemy wypisać kilka rzeczy, to najczęściej łączy się je znakiem +
+        // Do napisu można dodać także inne wartoścu (liczby, obiekty...)
+        System.out.println("Liczba: " + x);
+        System.out.println();
+
+        // W Javie dostępne jest też printf, prawie takie samo jak w C i podobne jak % w Pythonie.
+        // Pierwszym parametrem jest wzorzec (pattern), w którym są normalne fragmenty tekstu oraz znaczniki %X,
+        // na które są wstawiane wartości podane później po przecinku.
+        // %s - string lub dowolna wartość przekonwertowana na tekst tak, jakbyśmy wypisali ją printem
+        // %d - liczba całkowita
+        // %f - liczba z ułamkiem
+        // %x - liczba szesnastkowo
+        System.out.printf("Osoba %s ma %d lat.\n", s, x);
+        double pi = Math.PI;
+        // Zostaną użyte "lokale" z ustawień systemu, u mnie polskie - liczba wypisuje się z przecinkiem
+        System.out.printf("|%10s|%4d|%-4d|%04d|%6.3f|%n", s, x, x, x, pi);
+
+        // Wskazuję lokale amerykańskie - liczba wypisze się z kropką
+        System.out.printf(Locale.US, "|%10s|%4d|%-4d|%04d|%6.3f|%n", s, x, x, x, pi);
+        System.out.println();
+
+        // Jeśli bardzo potrzebujemy, to na standadowe wyjście można wypisywać też dane binarne.
+        System.out.write(65);
+        System.out.write(66);
+        System.out.write(67);
+        System.out.write(10);
+    }
+
+}

src/main/java/gotowe/p01_interakcja/konsola/B_SuroweWejscie1.java

+package gotowe.p01_interakcja.konsola;
+
+import java.io.IOException;
+
+public class B_SuroweWejscie1 {
+    public static void main(String[] args) throws IOException {
+        System.out.println("Napisz coś");
+
+        // Wczytanie jednego bajtu z wejścia - w praktyce to co odczytamy, jest kodem pierwszej litery.
+        int x = System.in.read();
+        System.out.println("wartość x: " + x);
+    }
+}

src/main/java/gotowe/p01_interakcja/konsola/B_SuroweWejscie2.java

+package gotowe.p01_interakcja.konsola;
+
+import java.io.IOException;
+import java.nio.charset.Charset;
+import java.util.Arrays;
+
+public class B_SuroweWejscie2 {
+    public static void main(String[] args) throws IOException {
+        System.out.println("Napisz coś");
+
+        // Można też wczytać całą porcję bajtów do tablicy
+        byte[] bajty = new byte[100];
+        int ile = System.in.read(bajty);
+
+        System.out.println("Odczytano " + ile + " bajtów.");
+        System.out.println(Arrays.toString(bajty));
+
+        // Można utworzyć napis na podstawie ciągu bajtów:
+
+        String napis = new String(bajty, 0, ile);
+        // String napis = new String(bajty, 0, ile, "UTF-8");
+        System.out.println("Napisałeś: " + napis);
+    }
+}

src/main/java/gotowe/p01_interakcja/konsola/C_Skaner1.java

+package gotowe.p01_interakcja.konsola;
+
+import java.util.Scanner;
+
+public class C_Skaner1 {
+    public static void main(String[] args) {
+        // Tworzymy obiekt klasy Scanner. Ten skaner będzie czytał dane ze standardowego wejścia.
+        Scanner sc = new Scanner(System.in);
+
+        System.out.println("Napisz linię tekstu:");
+        String linia = sc.nextLine();
+        System.out.println("Napisałeś: " + linia);
+
+        System.out.println("Wpisz liczbę całkowitą:");
+        int x = sc.nextInt();
+
+        System.out.println("Wpisz liczbę z przecinkiem (!):");
+        double d = sc.nextDouble();
+
+        System.out.println("Liczby: " +x + " , " + d);
+
+        System.out.print("Wpisz dwa słowa: ");
+        String slowo1 = sc.next();
+        String slowo2 = sc.next();
+
+        System.out.println("Pierwsze: " + slowo1);
+        System.out.println("Drugie  : " + slowo2);
+
+        // Gdy teraz wczytam "linię" co tam będzie? Reszta linii wpisana za tymi ↑ dwoma słowami
+        linia = sc.nextLine();
+        System.out.println("Linia zawiera: " + linia);
+
+        System.out.println("KONIEC");
+    }
+}

src/main/java/gotowe/p01_interakcja/konsola/C_Skaner2_LiczbaCzyNieLiczba.java

+package gotowe.p01_interakcja.konsola;
+
+import java.util.Scanner;
+
+public class C_Skaner2_LiczbaCzyNieLiczba {
+
+    public static void main(String[] args) {
+        Scanner sc = new Scanner(System.in);
+
+        System.out.println("Napisz coś:");
+
+        if(sc.hasNextInt()) {
+            int liczba = sc.nextInt();
+            System.out.println("Wpisałeś int: " + liczba);
+        } else if(sc.hasNextDouble()) {
+            double liczba = sc.nextDouble();
+            System.out.println("Wpisałeś double: " + liczba);
+        } else {
+            String slowo = sc.next();
+            System.out.println("Wpisałeś tekst: " + slowo);
+        }
+        String reszta = sc.nextLine();
+        System.out.println("Reszta linii: " + reszta);
+        System.out.println("Reszta miała znaków: " + reszta.length());
+
+    }
+
+}

src/main/java/gotowe/p01_interakcja/konsola/D_BufRead.java

+package gotowe.p01_interakcja.konsola;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+
+// Aby czytać wejście linia po linii, można użyć klas Scanner (inny przykład) lub BufferedReader (tutaj).
+// Pośrednio potrzebna jest klasa InputStreamReader.
+
+// Gdybyśmy chcieli podać własne kodowane znaków (inne niż systemowe), to wtedy:
+// InputStreamReader isr = new InputStreamReader(System.in, "UTF-8");
+
+public class D_BufRead {
+    public static void main(String[] args) {
+        try {
+            InputStreamReader isr = new InputStreamReader(System.in);
+            BufferedReader br = new BufferedReader(isr);
+            String wiersz;
+            while((wiersz = br.readLine()) != null) {
+                System.out.println("Napisałeś " + wiersz);
+                if("koniec".equalsIgnoreCase(wiersz))
+                    break;
+            }
+
+            System.out.println("KONIEC");
+        } catch(IOException e) {
+            e.printStackTrace();
+        }
+    }
+}

src/main/java/gotowe/p01_interakcja/konsola/E_KlasaConsole.java

+package gotowe.p01_interakcja.konsola;
+
+import java.io.Console;
+import java.util.Arrays;
+
+public class E_KlasaConsole {
+
+    public static void main(String[] args) {
+        System.out.println("Początek");
+
+        Console konsola = System.console();
+        System.out.println("System.console() = " + konsola);
+
+        if(konsola == null) {
+            System.out.println("Brak możliwości utworzenia konsoli.");
+            return;
+        }
+
+        String wiersz;
+        while((wiersz = konsola.readLine("> ")) != null) {
+            konsola.printf("Napisałeś %s %n", wiersz);
+            if("koniec".equals(wiersz))
+                break;
+        }
+
+        System.out.println("KONIEC");
+
+        char[] hasło = konsola.readPassword("Podaj tajne hasło: ");
+        konsola.printf("Hasło ma długość %d %n", hasło.length);
+
+        // "zamazuję" hasło w pamięci, żeby inne programy nie mogły go odczytać
+        Arrays.fill(hasło, 'X');
+    }
+}

src/main/java/gotowe/p01_interakcja/okna/OknoDialogowe1.java

+package gotowe.p01_interakcja.okna;
+
+import javax.swing.JOptionPane;
+
+/* Jednym ze sposobów komunikacji z użytkownikiem są okna dialogowe.
+   W Javie są one łatwe w użyciu (łatwiejsze niż pełnowartościowe aplikacje okienkowe),
+   korzysta się poprzez klasę JOptionPane.
+   Najważniejsze są trzy rodzaje okien dialogowych:
+   * showMessageDialog - tylko komunikat
+   * showInputDialog - pytanie i mozliwośc podania tekstowej odpowiedzi
+   * showConfirmDialog - pytanie i odpowiedź Yes/No/Cancel
+*/
+
+public class OknoDialogowe1 {
+
+    public static void main(String[] args) {
+        String imie = JOptionPane.showInputDialog("Jak masz na imię?");
+        JOptionPane.showMessageDialog(null, "Witaj " + imie);
+    }
+
+}

src/main/java/gotowe/p01_interakcja/okna/OknoDialogowe2.java

+package gotowe.p01_interakcja.okna;
+
+import javax.swing.JOptionPane;
+
+public class OknoDialogowe2 {
+
+    public static void main(String[] args) {
+        String imie = JOptionPane.showInputDialog("Jak masz na imię?");
+        String wiekTekstowo = JOptionPane.showInputDialog("Ile masz lat, " + imie + "?");
+
+        int wiek = Integer.parseInt(wiekTekstowo);
+
+        if(wiek >= 18) {
+            JOptionPane.showMessageDialog(null, "Witaj " + imie + ", możesz kupić piwo :)");
+        } else {
+            JOptionPane.showMessageDialog(null, "Witaj " + imie + ", dla niepełnoletnich tylko cukierki...");
+        }
+    }
+
+}

src/main/java/gotowe/p01_interakcja/okna/OknoDialogowe3.java

+package gotowe.p01_interakcja.okna;
+
+import java.awt.HeadlessException;
+
+import javax.swing.JOptionPane;
+
+public class OknoDialogowe3 {
+
+    public static void main(String[] args) {
+        try {
+            String imie = JOptionPane.showInputDialog("Jak masz na imię?");
+            String wiekTekstowo = JOptionPane.showInputDialog("Ile masz lat, " + imie + "?");
+
+            int wiek = Integer.parseInt(wiekTekstowo);
+
+            if(wiek >= 18) {
+                JOptionPane.showMessageDialog(null, "Witaj " + imie + ", możesz kupić piwo :)");
+            } else {
+                JOptionPane.showMessageDialog(null, "Witaj " + imie + ", dla niepełnoletnich tylko cukierki...");
+            }
+        } catch(HeadlessException e) {
+            System.out.println("Brak interfejsu graficznego - nie pogadamy...");
+        } catch(NumberFormatException e) {
+            JOptionPane.showMessageDialog(null, "Nieprawidłowy format liczby", "Błąd", JOptionPane.ERROR_MESSAGE);
+        } catch(Exception e) {
+            JOptionPane.showMessageDialog(null, "Inny błąd " + e, "Błąd", JOptionPane.ERROR_MESSAGE);
+        }
+    }
+
+}

src/main/java/gotowe/p01_interakcja/okna/RodzajeOkien.java

+package gotowe.p01_interakcja.okna;
+
+import java.time.LocalDateTime;
+
+import javax.swing.JOptionPane;
+
+public class RodzajeOkien {
+
+	public static void main(String[] args) {
+		JOptionPane.showMessageDialog(null, "To jest zwykły MessageDialog");
+		JOptionPane.showMessageDialog(null, "To jest MessageDialog typu WARNING", "Uwaga", JOptionPane.WARNING_MESSAGE);
+		// są też inne typy: PLAIN_MESSAGE, INFORMATION_MESSAGE, QUESTION_MESSAGE, WARNING_MESSAGE, ERROR_MESSAGE
+
+		String cos = JOptionPane.showInputDialog("To jest inputDialog.\nNapisz coś:");
+		String data = JOptionPane.showInputDialog("To jest inputDialog z początkową wartością.", LocalDateTime.now());
+		// Rozbudowana wersja showInputDialog pozwala wybrać wartość z rozwijanej listy
+		// Należy przekazać tablicę wartości do wyboru
+		String[] opcje = { "wiosna", "lato", "jesień", "zima" };
+		String poraRoku = (String) JOptionPane.showInputDialog(null, "Którą porę roku lubisz najbardziej?", "Pytanie",
+				JOptionPane.QUESTION_MESSAGE, null, opcje, "jesień");
+
+		int pora2 = JOptionPane.showOptionDialog(null, "A której pory nie lubisz?", "Pytanie 2", 0,
+				JOptionPane.QUESTION_MESSAGE, null, opcje, "zima");
+		// dostajemy numer wybranej opcji, od 0
+
+		int wybor = JOptionPane.showConfirmDialog(null, "Czy chcesz " + cos + " o godzinie " + data + "?");
+		switch (wybor) {
+		case JOptionPane.YES_OPTION -> JOptionPane.showMessageDialog(null, "TAK");
+		case JOptionPane.NO_OPTION -> JOptionPane.showMessageDialog(null, "NO");
+		case JOptionPane.CANCEL_OPTION -> JOptionPane.showMessageDialog(null, "Cancel");
+		default -> JOptionPane.showMessageDialog(null, "Inna wartość: " + wybor);
+		// zamknięcie okna daje wynik -1 czyli CLOSED_OPTION
+		}
+	}
+
+}

src/main/java/gotowe/p02_zmienne/A_TeoriaZmiennych.java

+package gotowe.p02_zmienne;
+
+public class A_TeoriaZmiennych {
+
+    public static void main(String[] args) {
+        System.out.println("Początek programu");
+
+        // Aby użyć zmiennej, trzeba ją zadeklarować.
+        //NK x = 15;
+        //NK System.out.println(x);
+
+        // Deklaracja zmiennej:
+        String txt;
+        int x, innaZmienna;
+
+        // Zmienne lokalne (czyli deklarowane wewnątrz metod)
+        // nie są automatycznie inicjowane na żadną wartość.
+        // Niezainicjowanych zmiennych lokalnych nie wolno odczytywać (błąd kompilacji).
+
+        //NK System.out.println(txt);
+        //NK System.out.println(x);
+        //NK x = 2 * x;
+        //NK x += 5;
+
+        // Instrukcja przypisania (assignment)
+        txt = "Ala";
+        x = 25;
+
+        System.out.println(x); // OK
+        System.out.println(txt); // OK
+
+        // ponowne przypisanie = zmiana wartości zmiennej
+
+        txt = "Ola";
+        x = x + 1;
+        System.out.println(x);
+
+        // Rozszerzone operatory przypisania:
+        x += 4; // równoważne x = x + 4
+        System.out.println(x);
+        // dostępne także dla innych operatorów
+        x *= 2;
+        System.out.println(x);
+        System.out.println();
+
+        // Zazwyczaj wartość zmiennej podaje się od razu w miejscu deklaracji (deklaracja z inicjalizacją):
+        int y = 100, z = 200;
+        String miasto = "Warszawa";
+
+        System.out.println(y + z);
+        System.out.println(miasto);
+
+        // Typowe podejście Javy:
+        // Zmienne lokalne deklaruje się dopiero kiedy są potrzebne
+        // i od razu podaje się ich początkową wartość.
+    }
+
+}

src/main/java/gotowe/p02_zmienne/B_RodzajeZmiennych.java

+package gotowe.p02_zmienne;
+
+//NK int globalna;
+
+public class B_RodzajeZmiennych {
+    // zmienna statyczna - istnieje jeden egzemplarz w pamięci
+    static int statyczna = 10;
+
+    // zmienna instancyjna (inaczej: pole, atrybut) należy do obiektu
+    // Każdy obiekt tej klasy, w której jesteśmy, będzie posiadał taką zmienną
+    int instancyjna = 20;
+
+    public static void main(String[] args) {
+        // zmienna lokalna, czyli deklarowana w obrębie metody
+        int lokalna = 30;
+
+        metodaStatyczna(40);
+
+        // metody instancyjnej nie da się wywołać w kontekście statycznym (np. w main)
+        // metodaInstancyjna(50);
+
+        // Trzeba utworzyć obiekt i wywołać tę metodę na obiekcie.
+        // Tworzę obiekt, czyli "instancję"
+        B_RodzajeZmiennych obiekt = new B_RodzajeZmiennych();
+        obiekt.metodaInstancyjna(50);
+
+        System.out.println(statyczna);
+        System.out.println(obiekt.instancyjna);
+
+        B_RodzajeZmiennych innyObiekt = new B_RodzajeZmiennych();
+        innyObiekt.instancyjna = 123;
+        innyObiekt.metodaInstancyjna(33);
+    }
+
+    static void metodaStatyczna(int parametr) {
+        int lokalna = 60;
+
+        System.out.println("metodaStatyczna:");
+        System.out.println("statyczna: " + statyczna);
+        // m "kontekście statycznym", czyli w metodzie statycznej nie ma dostępu do zmiennych instancyjnych,
+        // bo "nie wiemy w jakim obiekcie"
+        //NK System.out.println("instancyjna: " + instancyjna);
+        System.out.println("lokalna: " + lokalna);
+        System.out.println("parametr: " + parametr);
+        System.out.println();
+    }
+
+    void metodaInstancyjna(int parametr) {
+        int lokalna = 70;
+
+        System.out.println("metodaInstancyjna:");
+        System.out.println("statyczna: " + statyczna);
+        System.out.println("instancyjna: " + instancyjna);
+        System.out.println("lokalna: " + lokalna);
+        System.out.println("parametr: " + parametr);
+        System.out.println();
+    }
+
+}

src/main/java/gotowe/p02_zmienne/C_Inicjalizacja.java

+package gotowe.p02_zmienne;
+
+public class C_Inicjalizacja {
+    // zmienne statyczne - inicjowane domyślnie na 0, false lub null
+    static int st;
+
+    // zmienne instancyjne - inicjowane domyślnie na 0, false lub null
+    int inst;
+
+    public static void main(String[] args) {
+        // zmienne lokalne - nie są automatyczne inicjowane
+        int lokalna;
+
+        System.out.println(st); // 0
+        //NK System.out.println(inst); // próba dostępu do zmiennej niestatycznej w kontekście statycznym
+
+        C_Inicjalizacja obiekt = new C_Inicjalizacja();
+        System.out.println(obiekt.inst); // 0
+
+        // błąd kompilacji - aby odczytać zmienną lokalną, musi zostać wcześniej zainicjalizowana (w taki sposób, żeby kompilator miał pewność)
+        //NK System.out.println(lokalna);
+
+        if(st >= 0) {
+            lokalna = 13;
+            System.out.println(lokalna); // OK - tu zmienna "na pewno jest zainicjowana"
+        }
+        //NK System.out.println(lokalna); // tutaj wg kompilatora "może być niezainicjowana"
+
+        if(st >= 0) {
+            lokalna = 10;
+        } else {
+            lokalna = 20;
+        }
+        System.out.println(lokalna); // OK
+    }
+
+}

src/main/java/gotowe/p02_zmienne/D_Zasieg.java

+package gotowe.p02_zmienne;
+
+public class D_Zasieg {
+    static int x;
+
+    public static void main(String[] args) {
+        System.out.println("A: " + x);
+        x = 100;
+        System.out.println("B: " + x);
+
+        int x = 500;
+        System.out.println("C: " + x);
+        metoda();
+        System.out.println("I: " + x);
+
+    }
+
+    static void metoda() {
+        // w tym miejscu nie widać lokalnych zmiennych z innych metod (np. main)
+        // a widać zmienne z poziomu klasy ("globalne")
+        System.out.println("D: " + x);
+
+        if(x > 0) {
+            String x = "700";
+            System.out.println("E: " + x);
+        }
+
+        System.out.println("F: " + x);
+
+        {
+            // wolno przesłaniać zmienne klasowe za pomocą zmiennych lokalnych
+            int x = 300;
+            System.out.println("G: " + x);
+            if(true) {
+                // nie wolno przesłaniać zmiennych lokalnych
+                //NK int x = 400;	
+                // System.out.println("H: " + x);
+            }
+        }
+
+        System.out.println("K: " + x);
+    }
+
+}

src/main/java/gotowe/p02_zmienne/Nazwy.java

+package gotowe.p02_zmienne;
+
+public class Nazwy {
+
+    public static void main(String[] args) {
+        // Nazwa nie może zaczynać się od cyfry
+        //NK String 1rstElement = "pierwszy";
+
+        // Nazwa może zaczynać się od litery, znaku _ lub znaku $
+        String abc123 = "abc123";
+        String _123 = "qwerty";
+        String $123 = "qwertz";
+
+        // wielkość liter ma znaczenie, to są dwie różne zmienne
+        int x = 10, X = 20;
+
+        System.out.println(x);
+        System.out.println(X);
+
+        // Można używać liter z różnych alfabetów
+        int żółć = 333;
+        System.out.println(żółć);
+
+        String 李 = "李";
+        System.out.println(李);
+
+        \u674e = "babajaga"; // podaję kod Unicode chińskiego znaczka
+        System.out.println(李); // babajaga
+
+        int $a, a; // to są różne zmienne
+
+        int $ = 444, $3 = 33, __ = 44;
+        System.out.println($);
+        System.out.println($3);
+        System.out.println(__);
+
+        // Nazwami nie mogą być słowa kluczowe ani pojedynczy znak podkreślenia
+        // String int = "pomyłka";
+        // String _ = "aaa";
+        // System.out.println(_);
+        String var = "okej, nawet w Javie 11";
+        System.out.println(var);
+    }
+
+}

src/main/java/gotowe/p02_zmienne/PolaFinal.java

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

src/main/java/gotowe/p02_zmienne/SlowoVar.java

+package gotowe.p02_zmienne;
+
+import java.time.LocalTime;
+
+public class SlowoVar {
+
+    public static void main(String[] args) {
+        // Przykład kompiluje się od Javy 10.
+
+        // Deklaracja zmiennej lokalnej bez podawania typu.
+        // Kompilator domyśla się typu na podstawie tego, co wpisujemy
+        var y = 100;
+        System.out.println(y);
+        y = 101; // OK
+        System.out.println(y);
+
+        // Zmienna ma jednak typ int i nie wolno wpisać wartości niezgodnego typu
+        // y = 3.14; // źle
+        // y = "Ala ma kota"; // źle
+        // System.out.println(y);
+
+        // Konstrukcja dostępna tylka dla zmiennych lokalnych, gdy początkową wartość wpisuje się od razu w miejscu deklaracji.
+        // var z;
+
+        // var nie jest słowem kluczowym i w niekolidujących miejscach można go używać jako nazwy:
+        String var = "tajemnicza zmienna";
+        System.out.println(var);
+
+        // BTW, odpowiednikiem takich zmiennych jak w Pythonie i PHP, na które można wpisać "wszystko",
+        // w Javie jest raczej zmienna typu Object.
+
+        Object o;
+        o = "Ala ma kota";
+        System.out.println(o.getClass().getSimpleName() + " : " + o);
+
+        o = 100 + 15;
+        System.out.println(o.getClass().getSimpleName() + " : " + o);
+
+        o = LocalTime.now();
+        System.out.println(o.getClass().getSimpleName() + " : " + o);
+    }
+
+}

src/main/java/gotowe/p02_zmienne/Typy.java

+package gotowe.p02_zmienne;
+
+import java.time.LocalDate;
+
+public class Typy {
+
+    public static void main(String[] args) {
+        // Typy dzielą się na dwie kategorie:
+        // 1) typy proste
+        byte b = 15;
+        short s = 1000;
+        int i = 100000;
+        long l1 = 10, l2 = 5000000000L;
+
+        float f = 3.14F;
+        double d = 3.14;
+
+        // char to pojedynczy znak, ale jednocześnie może być traktowany jak liczba z zakresu 0-64k
+        char znak = 'A';
+
+        boolean falsz = false, prawda = true, niewiem = d > 3.0;
+
+        // typów byte i short nie opłaca sie używać, chyba że w dużych tablicach
+
+        // 2) typy obiektowe
+        Object o = new Object();
+        System.out.println(o);
+
+        // klasa String - napisy
+        String imie = "Ala";
+
+        // platforma Java SE definiuje ok 4 tys. klas
+        LocalDate data = LocalDate.now();
+        System.out.println(data);
+        System.out.println(data.getDayOfMonth());
+        System.out.println(data.getDayOfYear());
+        System.out.println();
+
+        // programiści mogą tworzyć własne klasy
+
+        // w Javie również tablice są obiektami:
+        int[] liczby = { 1, 2, 3, 4 };
+        System.out.println(liczby.length);
+
+        System.out.println(liczby[1]); // 2
+    }
+
+}

src/main/java/gotowe/p03_instrukcje/a_if/A_TeoriaIf.java

+package gotowe.p03_instrukcje.a_if;
+
+import java.util.Random;
+
+public class A_TeoriaIf {
+
+    public static void main(String[] args) {
+        Random random = new Random();
+        int x = random.nextInt(100); // liczba od 0 do 99 włącznie
+        int y = random.nextInt(100);
+
+        System.out.println("Wylosowane liczby:");
+        System.out.printf("x = %d , y = %d\n", x, y);
+
+        // Wzorcowa wersja if:
+        // if(WARUNEK) { INSTRUKCJE1 } else { INSTRUKCJE2 }
+        // Gdy WARUNEK jest prawdą, wykonają się INSTRUKCJE1, a jeśli nieprawdą to INSTRUKCJE2
+        if(x % 2 == 0) {
+            System.out.println("x jest parzysty");
+            System.out.println("Ala ma kota");
+        } else {
+            System.out.println("x jest nieparzysty");
+            System.out.println("Ola ma psa");
+        }
+        System.out.println("a kuku");
+        System.out.println();
+
+        // Jeśli za ifem lub elsem do wykonania jest tylko jedna instrukcja, to można pominąć nawiasy klamrowe.
+        if(x >= 50)
+            System.out.println(">= 50");
+        else
+            System.out.println("<  50");
+        // Używajmy tego jednak z umiarem, tylko w bardzo prostych przypadkach, np. break, throw, return...
+        // W większości przypadków zalecane jest wzięcie wykonywanego kodu w {nawiasy klamrowe},
+        // gdyż łatwiej dokonać późniejszych zmian, np. dodać kolejną linię itp...
+
+        /* Za instrukcją strukturalną (if, while, for...) w praktyce nigdy nie stawia się średnika
+        if(x == y); {
+            System.out.println("Obie liczby są równe!");
+        }
+           Powyższy kod zawsze wyświetliłby podany napis, bo struktiura jest taka:
+           "jeśli x == y, nie rób nic; a później ZAWSZE wypisuj ten tekst"
+        */
+
+        // Można użyć samego if, bez else:
+
+        if(x + y >= 100) {
+            System.out.println("suma x i y jest trzycyfrowa");
+        }
+
+        // ify (i inne instrukcje blokowe) można zagnieżdżać. Tutaj tym bardziej zalecamy pisanie nawiasów {}
+
+        if(x % 2 == 0) {
+            if(y % 2 == 0) {
+                System.out.println("obie liczby są parzyste");
+            } else {
+                System.out.println("x parzysty, y nieparzysty");
+            }
+        } else {
+            if(y % 2 == 0) {
+                System.out.println("x nieparzysty, y parzysty");
+            } else {
+                System.out.println("obie liczby nieparzyste");
+            }
+        }
+        System.out.println();
+
+        // Jeśli rozpatrywanych sytuacji jest więcej niż 2, to typowym sposobem zapisu jest ciąg
+        // if - else if - ... - else
+        if(x > y) {
+            System.out.println("x > y");
+        } else if(x < y) {
+            System.out.println("x < y");
+        } else {
+            System.out.println("x = y");
+        }
+
+        // W Javie nie ma automatycznej konwersji liczb (ani innych rzeczy) na boolean
+        //  if(liczba) {
+        //      System.out.println("Nie zero");
+        //  }
+        //
+        //  if(liczba = 0) {
+        //      System.out.println("Nie zero");
+        //  }
+
+        // Warunkiem najczęściej jest porównanie, ale może też być wywołanie metody typu boolean
+        String str = "Ala ma kota";
+        if(str.isEmpty()) {
+            System.out.println("puste");
+        }
+
+        // może też być bezpośrednie użycie zmiennej typu boolean
+        boolean logika = x > 10 && y % 3 == 0;
+        if(logika) {
+            System.out.println("Dziwny warunek jest prawdą");
+        } else {
+            System.out.println("Nieprawda");
+        }
+
+        System.out.println("Koniec programu");
+    }
+
+}

src/main/java/gotowe/p03_instrukcje/b_petle/A_RodzajePetli.java

+package gotowe.p03_instrukcje.b_petle;
+
+public class A_RodzajePetli {
+
+    public static void petlaWhile() {
+        int i = 1;
+        while(i <= 5) {
+            System.out.println("w pętli: " + i);
+            i++;
+        }
+        System.out.println("za pętlą: " + i);
+    }
+
+    public static void doWhile() {
+        int i = 1;
+        do {
+            System.out.println("w pętli: " + i);
+            i++;
+        } while(i <= 5);
+        System.out.println("za pętlą: " + i);
+    }
+
+    // ominięte w main
+    public static void petlaFor() {
+        for(int i = 1; i <= 5; i++) {
+            System.out.println("w pętli " + i);
+        }
+
+        // NK System.out.println("za pętlą: " + i);
+        int i; // OK
+    }
+
+    public static void petlaFor2() {
+        int i;
+
+        for(i = 1; i <= 5; i++) {
+            System.out.println("w pętli " + i);
+        }
+
+        System.out.println("za pętlą: " + i); // 6
+        // NK int i;
+    }
+
+    // ominięte w main
+    public static void petlaFor3() {
+        // int i;
+
+        for(int i = 1, j = 10; i <= 5 && j < 3; i++, j = i / 10, System.out.println("z pętli " + j)) {
+            System.out.println("w pętli " + i);
+        }
+
+        // System.out.println("za pętlą: " + i);
+    }
+
+    // ominięte w main
+    // w for moga byc dowolne instrukcje
+    public static void petlaFor4(org.w3c.dom.Node node) {
+        for(org.w3c.dom.Node child = node.getFirstChild(); child != null; child = child.getNextSibling()) {
+            System.out.println(child.getTextContent());
+        }
+    }
+
+    public static void losowanie() {
+        for(;;) {
+            double x = Math.random();
+            System.out.println("Wylosowałem " + x);
+            if(x > 0.8)
+                break;
+        }
+        System.out.println("za pętlą");
+    }
+
+    public static void forEach() {
+        String[] imiona = { "Ala", "Ola", "Ela", "Ula" };
+
+        // pozwala przeglądać zawartość tablicy, albo obiekty, które są Iterable 
+        // tzw. "for-each" albo "enhanced for loop", od Javy 5
+        for(String imie: imiona) {
+            System.out.println("Kolejna osoba to " + imie);
+        }
+
+        // Od Javy 10 można tak:
+        //		for(var imie : imiona) {
+        //			System.out.println("Kolejna osoba to " + imie);
+        //		}
+    }
+
+    public static void forEachEgzamin() {
+        // typowa zmyłka z egzaminu
+        int[] t = { 1, 2, 3 };
+        for(int i: t) {
+            // i oznacza WARTOŚĆ z tablicy, a nie indeks
+            // więc tu dojdzie do wyjścia poza zakres tablicy
+            System.out.println(t[i]);
+        }
+    }
+
+    public static void przerwanie() {
+        for(int i = 1; i <= 10; i++) {
+            System.out.println("i = " + i);
+            if(i % 2 == 1) {
+                System.out.println("  nieparzysta, continue");
+                continue;
+            }
+            System.out.println("  nie było continue");
+            if(i % 3 == 0) {
+                System.out.println("  podzielna przed 3, break");
+                break;
+            }
+            System.out.println("  nie było break");
+        }
+        System.out.println("za pętlą");
+    }
+
+    public static int etykiety() {
+        int suma = 0;
+        duza: while(true) {
+            for(int i = 1; i < 10; i++) {
+                suma += i;
+                if(suma > 100)
+                    break duza;
+            }
+        }
+        return suma;
+    }
+
+    public static void main(String[] args) {
+        etykieta: // kompiluje się, ale nie ma jak tego użyć
+        System.out.println("while");
+        petlaWhile();
+
+        //NK goto etykieta;
+
+        System.out.println("\ndo-while");
+        doWhile();
+
+        System.out.println("\nfor");
+        petlaFor2();
+
+        System.out.println("\nLosowanie:");
+        losowanie();
+
+        System.out.println("\nfor-each");
+        forEach();
+
+        System.out.println();
+        przerwanie();
+
+        System.out.println();
+
+        int x = etykiety();
+        System.out.println(x);
+    }
+}

src/main/java/gotowe/p03_instrukcje/b_petle/BreakContinue_Prezentacja.java

+package gotowe.p03_instrukcje.b_petle;
+
+import javax.swing.JOptionPane;
+
+public class BreakContinue_Prezentacja {
+
+    public static void main(String[] args) {
+        int licznik = 0;
+
+        while(true) {
+            licznik++;
+            JOptionPane.showMessageDialog(null, "Początek pętli, licznik = " + licznik);
+            int odp1 = JOptionPane.showConfirmDialog(null, "Czy zrobić break?");
+            if(odp1 == JOptionPane.YES_OPTION) {
+                break;
+                // break w pętli powoduje natychmiastowe zakończenie tej pętli i przejście do następnej instrukcji za pętlą
+            }
+            JOptionPane.showMessageDialog(null, "Środek pętli. Nie było break.");
+
+            int odp2 = JOptionPane.showConfirmDialog(null, "Czy zrobić continue?");
+            if(odp2 == JOptionPane.YES_OPTION) {
+                continue;
+                // continue powoduje pominięcie reszty instrukcji w bieżącym obrocie pętli
+                // i przejście od razu na początek następnego obrotu
+            }
+            JOptionPane.showMessageDialog(null, "Koniec pętli, nie było break ani continue");
+        }
+
+        JOptionPane.showMessageDialog(null, "Koniec programu");
+    }
+
+}

src/main/java/gotowe/p03_instrukcje/b_petle/DziwnyWhile.java

+package gotowe.p03_instrukcje.b_petle;
+
+public class DziwnyWhile {
+
+    public static void main(String[] args) {
+
+        int x = 1;
+        {
+            System.out.println("Ala ma kota " + x);
+            x++;
+        }
+        while(x <= 10)
+            ;
+        // To jest zwykły blok a potem pętla nieskończona
+
+        System.out.println("Koniec");
+    }
+
+}

src/main/java/gotowe/p03_instrukcje/b_petle/Label.java

+package gotowe.p03_instrukcje.b_petle;
+
+public class Label {
+    public static void main(String[] args) {
+        label1: System.out.println("Cokolwiek");
+        label2: while(true) {
+            double x = Math.random();
+            if(x > 0.5)
+                break label2;
+        }
+
+        // goto label1;
+        // const int n = 10;
+    }
+}

src/main/java/gotowe/p03_instrukcje/b_petle/MartwyKod.java

+package gotowe.p03_instrukcje.b_petle;
+
+public class MartwyKod {
+
+    void metoda1() {
+        System.out.println("OK");
+        return;
+        //		System.out.println("błąd");
+        //		System.out.println("kolejna linia");
+    }
+
+    void metoda2() throws Exception {
+        System.out.println("OK");
+        throw new Exception("katastrofa");
+        //		System.out.println("błąd");
+
+    }
+
+    public static void main(String[] args) {
+        // if(true) / if(false) NIE są traktowane jako martwy kod
+        if(false) {
+            System.out.println("Ala ma kota");
+        }
+
+        if(true) {
+            System.out.println("AAAA");
+        } else {
+            System.out.println("BBBB");
+        }
+
+        //		while(false) {
+        //			System.out.println("błąd");
+        //		}
+
+        while(true) {
+            System.out.println("lkdfjg");
+        }
+
+        //		System.out.println("błąd");
+    }
+}

src/main/java/gotowe/p03_instrukcje/b_petle/PetlaNieskonczona.java

+package gotowe.p03_instrukcje.b_petle;
+
+import java.time.LocalTime;
+
+public class PetlaNieskonczona {
+
+    public static void main(String[] args) {
+        int licznik = 0;
+
+        while(true) {
+            System.out.printf("%12d : %s%n", ++licznik, LocalTime.now());
+        }
+
+        // Kod w tym miejscu jest niepoprawny (Java go nie skompiluje), bo to jest "martwy kod".
+        // System.out.println("Koniec świata");
+    }
+
+}

src/main/java/gotowe/p03_instrukcje/b_petle/Przerwania.java

+package gotowe.p03_instrukcje.b_petle;
+
+public class Przerwania {
+    static void tabliczka(int n) {
+        for(int i = 1; i <= n; i++) {
+            for(int j = 1; j <= n; j++) {
+                System.out.printf("%3d", i * j);
+
+                System.out.print(",");
+            }
+            System.out.println("#");
+        }
+        System.out.println("\n----------------\n");
+    }
+
+    static void tabliczkaBreak(int n) {
+        for(int i = 1; i <= n; i++) {
+            for(int j = 1; j <= n; j++) {
+                System.out.printf("%3d", i * j);
+                if(i + j > n)
+                    break;
+                System.out.print(",");
+            }
+            System.out.println("#");
+        }
+        System.out.println("\n----------------\n");
+    }
+
+    static void tabliczkaBreakEtykieta(int n) {
+        pierwsza: for(int i = 1; i <= n; i++) {
+            for(int j = 1; j <= n; j++) {
+                System.out.printf("%3d", i * j);
+                if(i + j > n)
+                    break pierwsza;
+                System.out.print(",");
+            }
+            System.out.println("#");
+        }
+        System.out.println("\n----------------\n");
+    }
+
+    static void tabliczkaContinue(int n) {
+        for(int i = 1; i <= n; i++) {
+            for(int j = 1; j <= n; j++) {
+                System.out.printf("%3d", i * j);
+                if(i + j > n)
+                    continue;
+                System.out.print(",");
+            }
+            System.out.println("#");
+        }
+        System.out.println("\n----------------\n");
+    }
+
+    static void tabliczkaContinueEtykieta(int n) {
+        pierwsza: for(int i = 1; i <= n; i++) {
+            System.out.println(); // dodane
+            for(int j = 1; j <= n; j++) {
+                System.out.printf("%3d", i * j);
+                if(i + j > n)
+                    continue pierwsza;
+                System.out.print(",");
+            }
+            System.out.println("#");
+        }
+        System.out.println("\n----------------\n");
+    }
+
+    public static void main(String[] args) {
+        tabliczka(9);
+        tabliczkaBreak(9);
+        tabliczkaBreakEtykieta(9);
+        tabliczkaContinue(9);
+        tabliczkaContinueEtykieta(9);
+    }
+}

src/main/java/gotowe/p03_instrukcje/c_switch/Switch1.java

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

src/main/java/gotowe/p03_instrukcje/c_switch/Switch2.java

+package gotowe.p03_instrukcje.c_switch;
+
+import javax.swing.JOptionPane;
+
+public class Switch2 {
+
+    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");
+            break;
+        case 2:
+            System.out.println("wtorek");
+            break;
+        case 3:
+            System.out.println("środa");
+            break;
+        case 4:
+            System.out.println("czwartek");
+            break;
+        case 5:
+            System.out.println("piątek");
+            System.out.println("czyli weekendu początek");
+            break;
+        case 6:
+            System.out.println("sobota");
+            break;
+        case 7:
+            System.out.println("niedziela");
+            break;
+        default:
+            System.out.println("niepoprawny numer dnia tygodnia");
+        }
+
+        System.out.println("Koniec programu");
+    }
+
+}

src/main/java/gotowe/p03_instrukcje/c_switch/Switch3.java

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

src/main/java/gotowe/p03_instrukcje/c_switch/Switch4.java

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

src/main/java/gotowe/p03_instrukcje/c_switch/Switch5.java

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

src/main/java/gotowe/p03_instrukcje/c_switch/Switch6.java

+package gotowe.p03_instrukcje.c_switch;
+
+public class Switch6 {
+
+    public static void main(String[] args) {
+        byte bb = 100;
+        // Wartości podawane w case muszą być zgodne z typem parametru switch-a.
+        // W przypadku liczb oznacza to także, że liczba musi mieścić się w zakresie,
+        switch(bb) {
+        case 100:
+            System.out.println("100");
+            break;
+        //NK case 200: System.out.println("200"); break;
+        }
+
+        short ss = 100;
+        switch(ss) {
+        case 100:
+            System.out.println("100");
+            break;
+        case 200:
+            System.out.println("200");
+            break;
+        case 4000:
+            System.out.println("4000");
+            break;
+        //NK case 33000: System.out.println("100"); break;
+        }
+
+        char cc = 'A';
+        switch(cc) {
+        case 'A':
+            System.out.println("AAA");
+            break;
+        case 120:
+            System.out.println("BBB");
+            break;
+        //		case 10 : System.out.println("10"); break;
+        case 0xA:
+            System.out.println("0xA");
+            break;
+        //NK case 65 : System.out.println("CCC"); break;
+        //NK case -1 : System.out.println("DDD"); break;
+        case 64000:
+            System.out.println("EEE");
+            break;
+        //NK case 66000: System.out.println("FFF"); break;
+        }
+
+        /*
+        long l = 27L;
+        // nie ma switch na typach long, float, double
+        switch(l) {
+        case 27L : System.out.println("long 27");
+        }
+        */
+
+    }
+}

src/main/java/gotowe/p03_instrukcje/c_switch/Switch8.java

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

src/main/java/gotowe/p03_instrukcje/c_switch/SwitchNull_Pusty.java

+package gotowe.p03_instrukcje.c_switch;
+
+import javax.swing.JOptionPane;
+
+public class SwitchNull_Pusty {
+
+    public static void main(String[] args) {
+        String s = JOptionPane.showInputDialog("Wpisz napis");
+        System.out.println("Jestem przed switchem, napis = " + s);
+        switch(s) {}
+
+        System.out.println("Jestem za switchem");
+        // morał: przekazanie wartości null do switcha (na napisach lub na enumach)
+        // skutkuje wyjątkiem NPE
+
+    }
+
+}

src/main/java/gotowe/p03_instrukcje/c_switch/SwitchString_Interaktywnie.java

+package gotowe.p03_instrukcje.c_switch;
+
+import javax.swing.JOptionPane;
+
+public class SwitchString_Interaktywnie {
+
+    public static void main(String[] args) {
+        String s = JOptionPane.showInputDialog("Wpisz napis");
+        System.out.println("Jestem przed switchem, napis = " + s);
+
+        // Wielkość liter, spacje itp.: mają znaczenie.
+        // Nie są przeprowadzane żadne "normalizacje".
+        // Nie działają żadne "wildcardy" typu * % itp.
+
+        // Jeśli do switch przekażemy wartość null dojdzie d wyjątku NullPointerException
+        switch(s) {
+        case "Ala":
+            System.out.println("Ala ma kota");
+            break;
+        case "Ola":
+            System.out.println("Ola ma psa");
+            break;
+        //NK case null: System.out.println("NULL");
+        default:
+            System.out.println("Nieznana osoba");
+        }
+    }
+
+}

src/main/java/gotowe/p04_operatory/Bitowe1.java

+package gotowe.p04_operatory;
+
+public class Bitowe1 {
+
+    public static void main(String[] args) {
+        byte x = 25;
+        byte y = -25;
+        byte shift = 2;
+
+        System.out.printf("x = %d  y = %d %n", x, y);
+        System.out.println("Bez przycinania (w zakresie int):");
+        System.out.printf("x << %d = %d %n", shift, x << shift);
+        System.out.printf("y << %d = %d %n", shift, y << shift);
+        System.out.printf("x >> %d = %d %n", shift, x >> shift);
+        System.out.printf("y >> %d = %d %n", shift, y >> shift);
+        System.out.printf("x >>> %d = %d %n", shift, x >>> shift);
+        System.out.printf("y >>> %d = %d %n", shift, y >>> shift);
+        System.out.println();
+        System.out.println("Przycięte do byte: ");
+        System.out.printf("x << %d = %d %n", shift, (byte)(x << shift));
+        System.out.printf("y << %d = %d %n", shift, (byte)(y << shift));
+        System.out.printf("x >> %d = %d %n", shift, (byte)(x >> shift));
+        System.out.printf("y >> %d = %d %n", shift, (byte)(y >> shift));
+        System.out.printf("x >>> %d = %d %n", shift, (byte)(x >>> shift));
+        System.out.printf("y >>> %d = %d %n", shift, (byte)(y >>> shift));
+
+    }
+
+}

src/main/java/gotowe/p04_operatory/Bitowe2.java

+package gotowe.p04_operatory;
+
+public class Bitowe2 {
+
+    public static void main(String[] args) {
+        int x = 0b00000000000000000000000000011001;
+        int y = -x;
+        int z = 0b11111111111111111111111111100111;
+        System.out.println(x);
+        System.out.println(y);
+        System.out.println(z);
+        System.out.println();
+
+        System.out.println("<<");
+        System.out.println(x << 2);
+        System.out.println(y << 2);
+        System.out.println(z << 2);
+        System.out.println(0b11111111111111111111111110011100); // -100
+        System.out.println();
+
+        System.out.println(">>");
+        System.out.println(x >> 2);
+        System.out.println(y >> 2);
+        System.out.println(0b11111111111111111111111111111001);
+        System.out.println();
+
+        System.out.println(">>>");
+        System.out.println(x >>> 2);
+        System.out.println(y >>> 2);
+        System.out.println(0b00111111111111111111111111111001);
+        System.out.println();
+    }
+
+}

src/main/java/gotowe/p04_operatory/Leniwosc1.java

+package gotowe.p04_operatory;
+
+public class Leniwosc1 {
+    public static void gorliwa() {
+        // opertor "gorliwy"
+        // zawsze oblicza obie strony wyrażenia logicznego, a dopiero potem daje wynik false / true
+        if(lewy() & prawy()) {
+            System.out.println("prawda");
+        } else {
+            System.out.println("fałsz");
+        }
+    }
+
+    public static void leniwa() {
+        // operator "leniwy"
+        // jeśli lewa strona rozstrzyga o ostatecznym wyniku, to prawa strona nie jest sprawdzana
+        if(lewy() && prawy()) {
+            System.out.println("prawda");
+        } else {
+            System.out.println("fałsz");
+        }
+    }
+
+    private static boolean lewy() {
+        System.out.print("lewy ");
+        return false;
+    }
+
+    private static boolean prawy() {
+        System.out.print("prawy ");
+        return true;
+    }
+
+    public static void main(String[] args) {
+        System.out.println("wersja gorliwa");
+        gorliwa();
+
+        System.out.println("\nwersja leniwa:");
+        leniwa();
+    }
+}

src/main/java/gotowe/p04_operatory/Leniwosc2.java

+package gotowe.p04_operatory;
+
+public class Leniwosc2 {
+    public static void main(String[] args) {
+        int x = 0, y = 0;
+
+        if(++x > 0 | y++ > 0) {
+            System.out.println("prawda");
+        } else {
+            System.out.println("fałsz");
+        }
+        System.out.println("x == " + x);
+        System.out.println("y == " + y);
+        System.out.println();
+
+        x = y = 0;
+        if(++x > 0 || y++ > 0) {
+            System.out.println("prawda");
+        } else {
+            System.out.println("fałsz");
+        }
+        System.out.println("x == " + x);
+        System.out.println("y == " + y);
+        System.out.println();
+
+        x = y = 0;
+        if(x++ > 0 || ++y > 0) {
+            System.out.println("prawda");
+        } else {
+            System.out.println("fałsz");
+        }
+        System.out.println("x == " + x);
+        System.out.println("y == " + y);
+
+    }
+
+}

src/main/java/gotowe/p04_operatory/Leniwosc3.java

+package gotowe.p04_operatory;
+
+public class Leniwosc3 {
+    public static void main(String[] args) {
+        int x = 0, y = 0;
+
+        if(x++ > 0 || y++ > 0) {
+            System.out.println("prawda");
+        } else {
+            System.out.println("fałsz");
+        }
+        System.out.println("x == " + x);
+        System.out.println("y == " + y);
+        System.out.println();
+
+        x = y = 0;
+        if(++x > 0 || ++y > 0) {
+            System.out.println("prawda");
+        } else {
+            System.out.println("fałsz");
+        }
+        System.out.println("x == " + x);
+        System.out.println("y == " + y);
+
+    }
+
+}