grupowanie 1

src/main/java/emps/Grupowanie0.java

+package emps;
+
+import java.util.List;
+import java.util.Set;
+import java.util.TreeSet;
+
+// Dla każdego jobTitle obliczamy średnią pensję
+public class Grupowanie0 {
+    public static void main(String[] args) {
+        List<Employee> emps = ObslugaCSV.wczytaj();
+        Set<String> jobs = new TreeSet<>();
+        for (Employee emp : emps) {
+            jobs.add(emp.getJobTitle());
+        }
+        System.out.println(jobs);
+
+        for(String job : jobs) {
+            int ile = 0;
+            double suma = 0;
+            for(Employee emp : emps) {
+                if(job.equals(emp.getJobTitle())) {
+                    ile++;
+                    suma += emp.getSalary();
+                }
+            }
+            double srednia = suma / ile;
+            System.out.printf("%-32s | %2d | %8.2f\n", job, ile, srednia);
+        }
+    }
+}

src/main/java/emps/Grupowanie1.java

+package emps;
+
+import java.util.*;
+
+// Dla każdego jobTitle obliczamy średnią pensję
+public class Grupowanie1 {
+    public static void main(String[] args) {
+        List<Employee> emps = ObslugaCSV.wczytaj();
+        Map<String, Integer> ilosci = new HashMap<>();
+        Map<String, Integer> sumy = new HashMap<>();
+        for(Employee emp : emps) {
+            if(sumy.containsKey(emp.getJobTitle())) {
+                int ile = ilosci.get(emp.getJobTitle());
+                ilosci.put(emp.getJobTitle(), ile+1);
+                int suma = sumy.get(emp.getJobTitle());
+                sumy.put(emp.getJobTitle(), suma + emp.getSalary());
+            } else {
+                ilosci.put(emp.getJobTitle(), 1);
+                sumy.put(emp.getJobTitle(), emp.getSalary());
+            }
+        }
+        // System.out.println(sumy);
+
+        for(String job : sumy.keySet()) {
+            int ile = ilosci.get(job);
+            int suma = sumy.get(job);
+            double srednia = (double)suma / ile;
+            System.out.printf("%-32s | %2d | %8.2f\n", job, ile, srednia);
+        }
+    }
+}

src/main/java/emps/Grupowanie1a.java

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

src/main/java/emps/Grupowanie2.java

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

src/main/java/emps/Grupowanie2a.java

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

src/main/java/emps/Grupowanie3.java

+package emps;
+
+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/Grupowanie4.java

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

src/main/java/emps/Grupowanie5.java

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

src/main/java/emps/Grupowanie6.java

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

src/main/java/emps/MergeTlumaczenie.java

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