emps - funkcyjne

src/main/java/emps/F0_WypiszWszystko.java

+package emps;
+
+import java.util.List;
+
+public class F0_WypiszWszystko {
+
+    public static void main(String[] args) {
+        List<Employee> emps = ObslugaCSV.wczytaj();
+        emps.forEach(System.out::println);
+    }
+}

src/main/java/emps/F1_WypiszWybranePola.java

+package emps;
+
+import java.util.List;
+
+public class F1_WypiszWybranePola {
+
+    public static void main(String[] args) {
+        List<Employee> emps = ObslugaCSV.wczytaj();
+        emps.forEach(emp -> System.out.printf("Pracownik %s %s (%s), pensja %d%n",
+                emp.getFirstName(), emp.getLastName(), emp.getJobTitle(), emp.getSalary()));
+        System.out.println();
+
+        emps.stream()
+                .map(emp -> String.format("Pracownik %s %s (%s), pensja %d",
+                        emp.getFirstName(), emp.getLastName(), emp.getJobTitle(), emp.getSalary()))
+                // .map(String::toUpperCase)
+                .forEachOrdered(System.out::println);
+    }
+}

src/main/java/emps/F2_Filtrowanie.java

+package emps;
+
+import java.util.Comparator;
+import java.util.List;
+import java.util.function.Predicate;
+import java.util.stream.Collectors;
+
+public class F2_Filtrowanie {
+    // Program wypisuje tylko zarabiających >= 10 tys,
+    // realizujemy to filtrowaniem, ale przy okazji pokazuję Wam schemat "filter / map" - podstawowe operacje na strumieniach.
+
+    public static void main(String[] args) {
+        List<Employee> emps = ObslugaCSV.wczytaj();
+
+        emps.stream()
+            .filter(emp -> emp.getSalary() >= 10_000)
+            .forEach(emp -> System.out.println(emp.getFirstName() + " " + emp.getLastName()));
+
+        System.out.println("\n-----------------------\n");
+
+        emps.stream()
+            .filter(emp -> emp.getSalary() <= 5000)
+            .sorted(Comparator.comparing(Employee::getSalary))
+            .map(emp -> emp.getFirstName() + " " + emp.getLastName() + " z pensją " + emp.getSalary())
+            .map(String::toUpperCase) // ew.  .map(s -> s.toUpperCase())
+            .forEach(System.out::println);
+        System.out.println("\n-----------------------\n");
+
+        // 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ół".
+
+        String wynik1 = emps.stream()
+                .filter(F2_Filtrowanie::czyJestBogaty)
+                .map(Employee::getLastName)
+                .collect(Collectors.joining(", "));
+        System.out.println(wynik1);
+
+        String wynik2 = emps.stream()
+                .filter(F2_Filtrowanie.sprawdzJob("Programmer"))
+                .map(Employee::getLastName)
+                .collect(Collectors.joining(", "));
+        System.out.println(wynik2);
+    }
+
+    // tutaj sama ta metoda jest predykatem, dlatego w miejscu użycia
+    // stosujemy method::reference
+    private static boolean czyJestBogaty(Employee emp) {
+        return emp.getSalary() >= 15_000;
+    }
+
+    // tutaj metoda ZWRACA w wyniku predykat,
+    // dlatego w miejscu użycia w strumieniu trzeba ją wywołać() , aby uzyskać predykat
+    private static Predicate<Employee> sprawdzJob(String expectedJob) {
+        return emp -> emp.getJobTitle().equalsIgnoreCase(expectedJob);
+    }
+
+    private static Predicate<Employee> sprawdzJob2(String expectedJob) {
+        return emp -> {
+            String jobTitle = emp.getJobTitle();
+            return jobTitle != null && jobTitle.equalsIgnoreCase(expectedJob);
+        };
+    }
+}

src/main/java/emps/F3_SredniaWszystkich.java

+package emps;
+
+import java.util.List;
+import java.util.stream.Collectors;
+
+public class F3_SredniaWszystkich {
+    public static void main(String[] args) {
+        List<Employee> emps = ObslugaCSV.wczytaj();
+
+        double srednia1 = emps.stream()
+                .mapToInt(Employee::getSalary)
+                .average()
+                .orElse(0);
+        System.out.println(srednia1);
+
+        // ewentalnie można też użyć gotowego "collectora"
+        Double srednia2 = emps.stream()
+                .collect(Collectors.averagingInt(Employee::getSalary));
+        System.out.println(srednia2);
+    }
+}

src/main/java/emps/F4_SredniaJedenJob.java

+package emps;
+
+import javax.swing.*;
+import java.util.List;
+import java.util.Objects;
+import java.util.OptionalDouble;
+import java.util.stream.Collectors;
+
+public class F4_SredniaJedenJob {
+    public static void main(String[] args) {
+        List<Employee> emps = ObslugaCSV.wczytaj();
+
+        String szukanyJob = JOptionPane.showInputDialog("Podaj job", "Programmer");
+        // w tej wersji w razie braku danych (czyli błędnie podanego joba)
+        // średnia jest wyliczana jako 0
+        double srednia = emps.stream()
+                .filter(emp -> Objects.equals(emp.getJobTitle(), szukanyJob))
+                .mapToInt(Employee::getSalary)
+                .average()
+                .orElse(0);
+        System.out.println(srednia);
+
+        // wersje, w których wynik zapisujemy do zmiennej "Optional" i sprawdzamy jak jest
+        OptionalDouble avg = emps.stream()
+                .filter(emp -> Objects.equals(emp.getJobTitle(), szukanyJob))
+                .mapToInt(Employee::getSalary)
+                .average();
+
+        // zapis tradycyjny - if
+        if(avg.isPresent()) {
+            System.out.println("Średnia jest równa " + avg.getAsDouble());
+        } else {
+            System.out.println("Nikt nie ma takiego joba");
+        }
+
+        // zapisy "funkcyjne"
+        // if bez else:
+        avg.ifPresent(x -> System.out.println("Jest średnia " + x));
+
+        // if z else:
+        avg.ifPresentOrElse(x -> System.out.println("Taka średnia " + x),
+                () -> System.out.println("Nie ma takiego kogoś"));
+    }
+}

src/main/java/emps/F5_MiastaBezPowtorzen.java

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

src/main/java/emps/F6_MinMax.java

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

src/main/java/emps/F7_Sortowanie.java

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

src/main/java/emps/F7b_Sortowanie_WieleKryteriow.java

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

src/main/java/emps/F9_Podwyzka.java

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

src/main/java/emps/P5_MiastaBezPowtorzen.java

 package emps;
 
-import java.util.List;
-import java.util.Set;
-import java.util.TreeSet;
+import java.util.*;
 
 // Wypisz bez powtórzeń nazwy miast pojawiające się w pliku
 

src/main/java/emps/P7_Sortowanie.java

@@ -3,7 +3,7 @@ package emps;
 import java.util.Comparator;
 import java.util.List;
 
-// P7 - wypisz pracowników posortowanych wg pensji rosnąco
+// P7 - wypisz pracowników posortowanych wg pensji malejąco
 public class P7_Sortowanie {
 
 	public static void main(String[] args) {
@@ -29,7 +29,7 @@ public class P7_Sortowanie {
 //		emps.sort((emp1, emp2) -> -Integer.compare(emp1.getSalary(), emp2.getSalary()));
 
 		// można też napisać to bardziej wprost:
-		// posortuj obiekty Employee ze względu na ich pesję. odwrotnie
+		// posortuj obiekty Employee ze względu na ich pensję. odwrotnie
 		emps.sort(Comparator.comparingInt(Employee::getSalary).reversed());
 
 		for(Employee emp : emps) {