Dodatkowe wersje grupowania emps

src/emps/v2_obiektowo/Grupowanie1.java

 package emps.v2_obiektowo;
 
-import java.util.HashMap;
 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 HashMap<>();
-		Map<String, Integer> ilosci = new HashMap<>();
+		
+		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);
+				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()) {
+
+		for(String job : sumy.keySet()) {
 			int suma = sumy.get(job);
 			int ile = ilosci.get(job);
-			double srednia = suma / ile;
-			System.out.printf("%-32s | %2d | %8.2f%n", job, ile, srednia);
+			double srednia = (double)suma / ile;
+			System.out.printf("| %-32s | %2d | %8.2f |%n", job, ile, srednia);
 		}
 	}
-
 }

src/emps/v2_obiektowo/Grupowanie1a.java

+package emps.v2_obiektowo;
+
+import java.util.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/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/emps/v2_obiektowo/Grupowanie3.java

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

src/emps/v2_obiektowo/Grupowanie4.java

+package emps.v2_obiektowo;
+
+import java.util.List;
+import java.util.Map;
+import java.util.TreeMap;
+
+public class Grupowanie4 {
+	// W tej wersji używam operacji merge (od Java 8), która został wymyślona dokładnie po to,
+	// aby rozwiązywać takie zadania, jak to.
+
+	// merge(KLUCZ, WARTOSC, FUNKCJA) działa tak:
+	// - jeśli w słowniku nie ma jeszcze niczego pod KLUCZem, to wstawiana jest tam WARTOSC
+	// - jeśli w słowniku pod KLUCZem jest STARA_WARTOSC, to wywoływana jest FUNKCJA(STARA_WARTOSC, WARTOSC)
+	//   a uzyskany wynik jest zapisywany z powrotem do słownika pod KLUCZ
+	
+	public static void main(String[] args) {
+		List<Employee> emps = ObslugaCSV.wczytaj("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/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/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();
+		}
+	}
+}