Part1 by Iurii Salnikov

src/main/java/data/Generator.java

@@ -13,6 +13,8 @@
  */
 public class Generator {
 
+    private static final int EMPLOYEES_COUNT = 12;
+
     public static String generateString() {
         final String letters = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
         final int maxLength = 10;
@@ -60,7 +62,8 @@ public static Employee generateEmployee() {
     }
 
     public static List<Employee> generateEmployeeList() {
-        // TODO
-        throw new UnsupportedOperationException();
+        return Stream.generate(Generator::generateEmployee)
+                .limit(EMPLOYEES_COUNT)
+                .collect(toList());
     }
 }

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

@@ -5,16 +5,12 @@
 import data.Person;
 import org.junit.Test;
 
-import java.util.*;
-import java.util.concurrent.ThreadLocalRandom;
+import java.util.ArrayList;
+import java.util.List;
 import java.util.stream.Collectors;
-import java.util.stream.IntStream;
-import java.util.stream.Stream;
 
 import static data.Generator.generateEmployeeList;
-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 +21,42 @@ public class StreamsExercise1 {
 
     @Test
     public void getAllEpamEmployees() {
-        List<Person> epamEmployees = null;// TODO all persons with experience in epam
-        throw new UnsupportedOperationException();
+        final List<Employee> employees = generateEmployeeList();
+
+        List<Person> expected = new ArrayList<>();
+        for (final Employee employee : employees)
+            for (final JobHistoryEntry entry : employee.getJobHistory())
+                if (entry.getEmployer().equalsIgnoreCase("epam")) {
+                    expected.add(employee.getPerson());
+                    break;
+                }
+
+        List<Person> epamEmployees = employees.stream()
+                .filter(employee -> employee.getJobHistory().stream()
+                        .anyMatch(entry -> entry.getEmployer().equalsIgnoreCase("epam")))
+                .map(Employee::getPerson)
+                .collect(Collectors.toList());
+
+        assertEquals(expected, epamEmployees);
     }
 
     @Test
     public void getEmployeesStartedFromEpam() {
-        List<Person> epamEmployees = null;// TODO all persons with first experience in epam
-        throw new UnsupportedOperationException();
+        final List<Employee> employees = generateEmployeeList();
+
+        List<Person> expected = new ArrayList<>();
+        for (final Employee employee : employees)
+            if (!employee.getJobHistory().isEmpty() &&
+                    employee.getJobHistory().get(0).getEmployer().equalsIgnoreCase("epam"))
+                expected.add(employee.getPerson());
+
+        List<Person> employeesStartedFromEpam = employees.stream()
+                .filter(employee -> !employee.getJobHistory().isEmpty() &&
+                        employee.getJobHistory().get(0).getEmployer().equalsIgnoreCase("epam"))
+                .map(Employee::getPerson)
+                .collect(Collectors.toList());
+
+        assertEquals(expected, employeesStartedFromEpam);
     }
 
     @Test
@@ -49,11 +73,13 @@ public void sumEpamDurations() {
             }
         }
 
-        // TODO
-        throw new UnsupportedOperationException();
+        int result = employees.stream()
+                .flatMap(employee -> employee.getJobHistory().stream())
+                .filter(entry -> entry.getEmployer().equalsIgnoreCase("epam"))
+                .mapToInt(JobHistoryEntry::getDuration)
+                .sum();
 
-        // int result = ???
-        // assertEquals(expected, result);
+        assertEquals(expected, result);
     }
 
 }

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

@@ -5,13 +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.stream.Stream;
+import java.util.*;
 
-import static data.Generator.generateEmployeeList;
 import static java.util.stream.Collectors.*;
 import static org.junit.Assert.assertEquals;
 
@@ -22,23 +17,90 @@ public class StreamsExercise2 {
     // https://youtu.be/O8oN4KSZEXE Сергей Куксенко — Stream API, часть 1
     // https://youtu.be/i0Jr2l3jrDA Сергей Куксенко — Stream API, часть 2
 
-    // TODO class PersonEmployerPair
+    private class PersonEmployerPair {
+        private final Person person;
+        private final String employer;
+        private final int duration;
+
+        public PersonEmployerPair(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 employersStuffLists() {
-        Map<String, List<Person>> employersStuffLists = null;// TODO
-        throw new UnsupportedOperationException();
+        final List<Employee> employees = getEmployees();
+
+        final List<Person> expected = Arrays.asList(
+                new Person("John", "Doe", 21),
+                new Person("John", "Doe", 24),
+                new Person("Bob", "Doe", 27),
+                new Person("John", "Doe", 30)
+        );
+
+        final Map<String, List<Person>> employersStuffLists =
+                employees.stream().flatMap(employee ->
+                        employee.getJobHistory().stream().map(entry ->
+                                new PersonEmployerPair(
+                                        employee.getPerson(), entry.getEmployer(), entry.getDuration())))
+                        .collect(groupingBy(PersonEmployerPair::getEmployer,
+                                mapping(PersonEmployerPair::getPerson, toList())));
+
+        assertEquals(expected, employersStuffLists.get("yandex"));
     }
 
     @Test
     public void indexByFirstEmployer() {
-        Map<String, List<Person>> employeesIndex = null;// TODO
-        throw new UnsupportedOperationException();
+        final List<Employee> employees = getEmployees();
+
+        final List<Person> expected = Arrays.asList(
+                new Person("John", "Doe", 21),
+                new Person("John", "Doe", 24),
+                new Person("Bob", "Doe", 27),
+                new Person("John", "Doe", 30)
+        );
+
+        Map<String, List<Person>> employeesIndex =
+                employees.stream()
+                        .filter(employee -> !employee.getJobHistory().isEmpty())
+                        .map(employee -> new PersonEmployerPair(
+                                employee.getPerson(),
+                                employee.getJobHistory().get(0).getEmployer(),
+                                employee.getJobHistory().get(0).getDuration()))
+                        .collect(groupingBy(PersonEmployerPair::getEmployer,
+                                mapping(PersonEmployerPair::getPerson, toList())));
+
+        assertEquals(expected, employeesIndex.get("yandex"));
     }
 
     @Test
     public void greatestExperiencePerEmployer() {
-        Map<String, Person> employeesIndex = null;// TODO
+        final List<Employee> employees = getEmployees();
+
+        final Map<String, Person> employeesIndex =
+                employees.stream().flatMap(employee ->
+                        employee.getJobHistory().stream().map(entry ->
+                                new PersonEmployerPair(
+                                        employee.getPerson(), entry.getEmployer(), entry.getDuration())))
+                        .collect(groupingBy(PersonEmployerPair::getEmployer,
+                                collectingAndThen(
+                                        maxBy(Comparator.comparing(PersonEmployerPair::getDuration)),
+                                        p -> p.get().getPerson()
+                                )));
 
         assertEquals(new Person("John", "White", 28), employeesIndex.get("epam"));
     }