streams_part1_Komarova

src/main/java/data/Generator.java

@@ -1,5 +1,6 @@
 package data;
 
+import java.util.ArrayList;
 import java.util.List;
 import java.util.concurrent.ThreadLocalRandom;
 import java.util.stream.Collectors;
@@ -60,7 +61,11 @@ public static Employee generateEmployee() {
     }
 
     public static List<Employee> generateEmployeeList() {
-        // TODO
-        throw new UnsupportedOperationException();
+        List<Employee> result = new ArrayList<>();
+        for (Employee e : result) {
+            e = generateEmployee();
+            result.add(e);
+        }
+        return result;
     }
 }

src/test/java/part1/exercise/StreamsExercise1.java

@@ -15,6 +15,7 @@
 import static java.util.stream.Collectors.groupingBy;
 import static java.util.stream.Collectors.mapping;
 import static java.util.stream.Collectors.toList;
+import static org.junit.Assert.assertEquals;
 
 public class StreamsExercise1 {
     // https://youtu.be/kxgo7Y4cdA8 Сергей Куксенко и Алексей Шипилёв — Через тернии к лямбдам, часть 1
@@ -25,14 +26,22 @@ public class StreamsExercise1 {
 
     @Test
     public void getAllEpamEmployees() {
-        List<Person> epamEmployees = null;// TODO all persons with experience in epam
-        throw new UnsupportedOperationException();
+        List<Employee> employees = generateEmployeeList();
+        List<Employee> epamEmployees = employees.stream()
+                .filter(e -> e.getJobHistory().stream()
+                        .anyMatch(s -> s.getEmployer().equals("epam")))
+                .collect(toList());
     }
 
     @Test
     public void getEmployeesStartedFromEpam() {
-        List<Person> epamEmployees = null;// TODO all persons with first experience in epam
-        throw new UnsupportedOperationException();
+        List<Employee> epamEmployees = generateEmployeeList().stream()
+                .filter(e -> e.getJobHistory().stream()
+                        .findFirst()
+                        .map(JobHistoryEntry::getEmployer)
+                        .map(employer -> employer.equals("epam"))
+                        .orElse(false))
+                .collect(toList());
     }
 
     @Test
@@ -49,11 +58,12 @@ public void sumEpamDurations() {
             }
         }
 
-        // TODO
-        throw new UnsupportedOperationException();
+        final int result = employees.stream()
+                .flatMap(e -> e.getJobHistory().stream()
+                        .filter(s -> s.getEmployer().equals("epam")))
+                .mapToInt(JobHistoryEntry::getDuration)
+                .sum();
 
-        // int result = ???
-        // assertEquals(expected, result);
+        assertEquals(expected, result);
     }
-
 }

src/test/java/part1/exercise/StreamsExercise2.java

@@ -5,10 +5,8 @@
 import data.Person;
 import org.junit.Test;
 
-import java.util.Arrays;
-import java.util.Collections;
-import java.util.List;
-import java.util.Map;
+import java.util.*;
+import java.util.stream.Collectors;
 import java.util.stream.Stream;
 
 import static data.Generator.generateEmployeeList;
@@ -22,23 +20,117 @@ public class StreamsExercise2 {
     // https://youtu.be/O8oN4KSZEXE Сергей Куксенко — Stream API, часть 1
     // https://youtu.be/i0Jr2l3jrDA Сергей Куксенко — Stream API, часть 2
 
-    // TODO class PersonEmployerPair
+    private static class PersonEmployerPair {
+        private final Person person;
+        private final String employer;
+
+        public PersonEmployerPair(Person person, String employer) {
+            this.person = person;
+            this.employer = employer;
+
+        }
+
+        public Person getPerson() {
+            return person;
+        }
+
+        public String getEmployer() {
+            return employer;
+        }
+
+    }
+
+    private static class PersonEmployerDuration {
+        private final Person person;
+        private final String employer;
+        private final int duration;
+
+        public PersonEmployerDuration (Person person, String employer, int duration) {
+            this.person = person;
+            this.employer = employer;
+            this.duration = duration;
+        }
+
+        public Person getPerson() {
+            return person;
+        }
+
+        public String getEmployer() {
+            return employer;
+        }
+
+        public int getDuration() {
+            return duration;
+        }
+    }
+
+    private static Stream<PersonEmployerPair> employersToPersons(Employee employee) {
+        return employee.getJobHistory().stream()
+                .map(JobHistoryEntry::getEmployer)
+                .map(person -> new PersonEmployerPair(employee.getPerson(), person));
+    }
 
     @Test
     public void employersStuffLists() {
-        Map<String, List<Person>> employersStuffLists = null;// TODO
-        throw new UnsupportedOperationException();
+        List<Employee> employees = generateEmployeeList();
+
+        final Stream<PersonEmployerPair> personEmployerPairStream = employees.stream()
+                .flatMap(StreamsExercise2::employersToPersons);
+
+        Map<String, List<Person>> var1 =
+                personEmployerPairStream
+                        .collect(Collectors.groupingBy(PersonEmployerPair::getEmployer,
+                                mapping(PersonEmployerPair::getPerson, toList())));
+
+        Map<String, List<Person>> var2  = new HashMap<>();
+
+        for (Employee employee : employees) {
+            for (JobHistoryEntry jobHistoryEntry : employee.getJobHistory()) {
+                if (var2.containsKey(jobHistoryEntry.getEmployer())) {
+                    var2.get(jobHistoryEntry.getPosition()).add(employee.getPerson());
+                } else {
+                    var2.put(jobHistoryEntry.getEmployer(),
+                            new ArrayList<>(Collections.singletonList(employee.getPerson())));
+                }
+            }
+        }
+        assertEquals(var1, var2);
     }
 
     @Test
     public void indexByFirstEmployer() {
-        Map<String, List<Person>> employeesIndex = null;// TODO
-        throw new UnsupportedOperationException();
+        List<Employee> employees = generateEmployeeList();
+
+        Map<String, List<Person>> var1
+                = employees.stream().limit(1)
+                .flatMap(employee -> employee.getJobHistory().stream()
+                        .map(jobHistoryEntry -> new PersonEmployerPair(employee.getPerson(), jobHistoryEntry.getEmployer())))
+                .collect(Collectors.groupingBy(PersonEmployerPair::getEmployer,
+                        mapping((PersonEmployerPair::getPerson), toList())));
+
+
+        Map<String, List<Person>> var2 = new HashMap<>();
+        for (Employee e : employees) {
+            for (JobHistoryEntry j : e.getJobHistory()) {
+                if (var2.containsKey(e.getJobHistory().get(0).getEmployer())) {
+                    var2.get(j.getEmployer()).add(e.getPerson());
+                } else {
+                    var2.put(j.getEmployer(), new ArrayList<>(Collections.singletonList(e.getPerson())));
+                }
+            }
+        }
+
+        assertEquals(var1, var2);
     }
 
     @Test
     public void greatestExperiencePerEmployer() {
-        Map<String, Person> employeesIndex = null;// TODO
+        Map<String, Person> employeesIndex = getEmployees().stream()
+                .flatMap(e -> e.getJobHistory().stream()
+                        .map(j -> new PersonEmployerDuration(e.getPerson(), j.getEmployer(), j.getDuration())))
+                .collect(groupingBy(PersonEmployerDuration::getEmployer,
+                        collectingAndThen(maxBy(Comparator.comparing(PersonEmployerDuration::getDuration)),
+                                p -> p.get().getPerson())));
 
         assertEquals(new Person("John", "White", 28), employeesIndex.get("epam"));
     }