Part1. StreamsExercise1 is done

src/main/java/data/Generator.java

@@ -60,7 +60,6 @@ public static Employee generateEmployee() {
     }
 
     public static List<Employee> generateEmployeeList() {
-        // TODO
-        throw new UnsupportedOperationException();
+        return Stream.generate(Generator::generateEmployee).limit(10).collect(toList());
     }
 }

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

@@ -1,6 +1,7 @@
 package part1.exercise;
 
 import data.Employee;
+import data.Generator;
 import data.JobHistoryEntry;
 import data.Person;
 import org.junit.Test;
@@ -15,6 +16,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,18 +27,47 @@ public class StreamsExercise1 {
 
     @Test
     public void getAllEpamEmployees() {
-        List<Person> epamEmployees = null;// TODO all persons with experience in epam
-        throw new UnsupportedOperationException();
+        final List<Employee> employeeList = Generator.generateEmployeeList();
+        List<Person> epamEmployees = employeeList.stream().filter(employee -> employee.getJobHistory()
+                .stream().map(JobHistoryEntry::getEmployer).anyMatch("epam"::equalsIgnoreCase)
+        ).map(Employee::getPerson).collect(toList());
+
+        List<Person> expectedPersonList = new ArrayList<>();
+        for(Employee employee : employeeList){
+            for(JobHistoryEntry jobHistoryEntry : employee.getJobHistory()){
+                if(jobHistoryEntry.getEmployer().equalsIgnoreCase("epam")){
+                    expectedPersonList.add(employee.getPerson());
+                    break;
+                }
+            }
+        }
+
+        assertEquals(epamEmployees, expectedPersonList);
     }
 
     @Test
     public void getEmployeesStartedFromEpam() {
-        List<Person> epamEmployees = null;// TODO all persons with first experience in epam
-        throw new UnsupportedOperationException();
+        final List<Employee> employeeList = Generator.generateEmployeeList();
+        List<Person> epamEmployees = employeeList.stream().filter(employee -> employee.getJobHistory().
+                stream().limit(1).collect(toList())
+                .get(0).getEmployer().equalsIgnoreCase("epam"))
+                .map(Employee::getPerson).collect(toList());
+
+
+        List<Person> expectedPersonList = new ArrayList<>();
+        for(Employee employee : employeeList){
+            if(employee.getJobHistory().get(0).getEmployer().equalsIgnoreCase("epam")){
+                expectedPersonList.add(employee.getPerson());
+            }
+        }
+
+        assertEquals(epamEmployees, expectedPersonList);
+
     }
 
     @Test
     public void sumEpamDurations() {
+
         final List<Employee> employees = generateEmployeeList();
 
         int expected = 0;
@@ -49,11 +80,11 @@ public void sumEpamDurations() {
             }
         }
 
-        // TODO
-        throw new UnsupportedOperationException();
+        int result = employees.stream().flatMap(employee -> employee.getJobHistory().stream())
+                .filter(j -> j.getEmployer().equals("epam"))
+                .mapToInt(JobHistoryEntry::getDuration).sum();
 
-        // int result = ???
-        // assertEquals(expected, result);
+         assertEquals(expected, result);
     }
 
 }

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

@@ -5,14 +5,14 @@
 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;
-import static java.util.stream.Collectors.*;
+import static java.util.Comparator.comparing;
+import static java.util.stream.Collectors.collectingAndThen;
+import static java.util.stream.Collectors.groupingBy;
+import static java.util.stream.Collectors.maxBy;
 import static org.junit.Assert.assertEquals;
 
 public class StreamsExercise2 {
@@ -24,21 +24,133 @@ public class StreamsExercise2 {
 
     // TODO class PersonEmployerPair
 
+    public static class PersonEmployerPair {
+
+        private Person person;
+        private String employer;
+
+        public PersonEmployerPair(Person person, String employer) {
+            this.person = person;
+            this.employer = employer;
+        }
+
+        public Person getPerson() {
+            return person;
+        }
+
+        public String getEmployer() {
+            return employer;
+        }
+
+        public static Stream<PersonEmployerPair> employeeToPairs(Employee employee) {
+            return employee.getJobHistory().stream()
+                    .map(JobHistoryEntry::getEmployer)
+                    .map(e -> new PersonEmployerPair(employee.getPerson(), e));
+        }
+    }
+
     @Test
     public void employersStuffLists() {
-        Map<String, List<Person>> employersStuffLists = null;// TODO
-        throw new UnsupportedOperationException();
+        Map<String, List<Person>> employersStuffLists = new HashMap<>();
+        final List<Employee> employees = getEmployees();
+        for (Employee employee : employees) {
+            for (JobHistoryEntry jobHistoryEntry : employee.getJobHistory()) {
+                employersStuffLists.put(jobHistoryEntry.getEmployer(), new ArrayList<>());
+            }
+        }
+        for (Employee employee : employees) {
+            for (JobHistoryEntry jobHistoryEntry : employee.getJobHistory()) {
+                employersStuffLists.get(jobHistoryEntry.getEmployer()).add(employee.getPerson());
+            }
+        }
+
+        final Stream<PersonEmployerPair> personEmployerPairStream = employees.stream()
+                .flatMap(PersonEmployerPair::employeeToPairs);
+
+        final Map<String, List<Person>> collect = personEmployerPairStream
+                .collect(groupingBy
+                        (PersonEmployerPair::getEmployer,
+                                Collectors.mapping(PersonEmployerPair::getPerson, Collectors.toList())));
+
+        assertEquals(employersStuffLists, collect);
+    }
+
+    private static PersonEmployerPair firstEmployerPersonPair(Employee employee) {
+        final JobHistoryEntry jobHistoryEntry = employee.getJobHistory().stream()
+                .limit(1)
+                .findAny()
+                .orElse(new JobHistoryEntry(-1, "Default", "Default"));
+
+        return new PersonEmployerPair(employee.getPerson(), jobHistoryEntry.getEmployer());
     }
 
     @Test
     public void indexByFirstEmployer() {
-        Map<String, List<Person>> employeesIndex = null;// TODO
-        throw new UnsupportedOperationException();
+        Map<String, List<Person>> employeesIndex = new HashMap<>();
+        final List<Employee> employees = getEmployees();
+        for (Employee employee : employees) {
+            for (JobHistoryEntry jobHistoryEntry : employee.getJobHistory()) {
+                employeesIndex.put(jobHistoryEntry.getEmployer(), new ArrayList<>());
+            }
+        }
+        for (Employee employee : employees) {
+            employeesIndex.get(employee.getJobHistory().get(0).getEmployer()).add(employee.getPerson());
+        }
+
+        employeesIndex.entrySet().removeIf(entry -> entry.getValue().equals(Collections.EMPTY_LIST));
+
+
+        final Stream<PersonEmployerPair> personEmployerPairStream = employees.stream()
+                .map(StreamsExercise2::firstEmployerPersonPair);
+
+        final Map<String, List<Person>> collect = personEmployerPairStream
+                .collect(groupingBy
+                        (PersonEmployerPair::getEmployer,
+                                Collectors.mapping(PersonEmployerPair::getPerson, Collectors.toList())));
+
+
+        assertEquals(employeesIndex, collect);
+    }
+
+    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;
+        }
     }
 
     @Test
     public void greatestExperiencePerEmployer() {
-        Map<String, Person> employeesIndex = null;// TODO
+        final List<Employee> employees = getEmployees();
+        final Stream<PersonEmployerDuration> personEmployerDurationStream = employees.stream()
+                .flatMap(
+                        e -> e.getJobHistory()
+                                .stream()
+                                .map(j -> new PersonEmployerDuration(e.getPerson(), j.getEmployer(), j.getDuration())));
+
+        Map<String, Person> employeesIndex = personEmployerDurationStream
+                .collect(groupingBy(
+                        PersonEmployerDuration::getEmployer,
+                        collectingAndThen(
+                                maxBy(comparing(PersonEmployerDuration::getDuration)), p -> p.get().getPerson())));
+
 
         assertEquals(new Person("John", "White", 28), employeesIndex.get("epam"));
     }