streams done

src/main/java/data/Generator.java

@@ -60,7 +60,11 @@ public static Employee generateEmployee() {
     }
 
     public static List<Employee> generateEmployeeList() {
-        // TODO
-        throw new UnsupportedOperationException();
+        int maxLength = 10;
+        final int length = ThreadLocalRandom.current().nextInt(maxLength) + 1;
+
+        return Stream.generate(Generator::generateEmployee)
+                .limit(length)
+                .collect(toList());
     }
 }

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

@@ -7,6 +7,7 @@
 
 import java.util.*;
 import java.util.concurrent.ThreadLocalRandom;
+import java.util.function.Predicate;
 import java.util.stream.Collectors;
 import java.util.stream.IntStream;
 import java.util.stream.Stream;
@@ -15,6 +16,9 @@
 import static java.util.stream.Collectors.groupingBy;
 import static java.util.stream.Collectors.mapping;
 import static java.util.stream.Collectors.toList;
+import static org.hamcrest.core.IsEqual.equalTo;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertThat;
 
 public class StreamsExercise1 {
     // https://youtu.be/kxgo7Y4cdA8 Сергей Куксенко и Алексей Шипилёв — Через тернии к лямбдам, часть 1
@@ -25,16 +29,60 @@ 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 (Employee e : employees){
+            for (JobHistoryEntry j : e.getJobHistory())
+                if (j.getEmployer().equals("epam")){
+                    expected.add(e.getPerson());
+                    break;
+                }
+        }
+
+        List<Person> actual = employees.stream()
+                .filter(this::hasExperienceInEpam)
+                .map(Employee::getPerson)
+                .collect(toList());
+
+
+        assertThat(actual, equalTo(expected));
+    }
+
+    private boolean hasExperienceInEpam(Employee employee){
+        return employee.getJobHistory().stream()
+                .filter(j -> j.getEmployer().equals("epam"))
+                .count() > 0;
     }
 
     @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 (Employee e : employees){
+            if (e.getJobHistory().size() > 0 && e.getJobHistory().get(0).getEmployer().equals("epam"))
+                expected.add(e.getPerson());
+        }
+
+        List<Person> actual = employees.stream()
+                .filter(this::startExperienceInEpam)
+                .map(Employee::getPerson)
+                .collect(toList());
+
+        assertThat(actual, equalTo(expected));
+    }
+
+    private boolean startExperienceInEpam(Employee employee) {
+        return employee.getJobHistory().stream()
+                .limit(1)
+                .filter(j -> j.getEmployer().equals("epam"))
+                .count() > 0;
     }
 
+
     @Test
     public void sumEpamDurations() {
         final List<Employee> employees = generateEmployeeList();
@@ -49,11 +97,13 @@ public void sumEpamDurations() {
             }
         }
 
-        // TODO
-        throw new UnsupportedOperationException();
-
-        // int result = ???
-        // assertEquals(expected, result);
+        int result = employees.stream()
+                .flatMap(employee -> employee.getJobHistory().stream())
+                .filter(j -> j.getEmployer().equals("epam"))
+                .mapToInt(JobHistoryEntry::getDuration)
+                .sum();
+
+        assertEquals(expected, result);
     }
 
 }

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

@@ -5,15 +5,13 @@
 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.Stream;
 
-import static data.Generator.generateEmployeeList;
 import static java.util.stream.Collectors.*;
+import static org.hamcrest.core.IsEqual.equalTo;
 import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertThat;
 
 public class StreamsExercise2 {
     // https://youtu.be/kxgo7Y4cdA8 Сергей Куксенко и Алексей Шипилёв — Через тернии к лямбдам, часть 1
@@ -23,26 +21,120 @@ public class StreamsExercise2 {
     // https://youtu.be/i0Jr2l3jrDA Сергей Куксенко — Stream API, часть 2
 
     // TODO class PersonEmployerPair
+    public static class PersonEmployerPair {
+        private Person person;
+        private String employer;
+        private int duration;
+
+        public PersonEmployerPair(Person person, String employer) {
+            this.person = person;
+            this.employer = employer;
+        }
+
+        public PersonEmployerPair(Person person, String employer, int duration) {
+            this(person, 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();
+        List<Employee> employees = getEmployees();
+
+        Map<String, List<Person>> expected = new HashMap<>();
+        for (Employee employee : employees) {
+            for (JobHistoryEntry j : employee.getJobHistory()) {
+                if (!expected.containsKey(j.getEmployer())) {
+                    expected.put(j.getEmployer(), new ArrayList<Person>());
+                }
+                expected.get(j.getEmployer()).add(employee.getPerson());
+            }
+        }
+
+        Map<String, List<Person>> actual = employees.stream()
+                .flatMap(this::getPersonEmployerPairs)
+                .collect(groupingBy(
+                        PersonEmployerPair::getEmployer,
+                        mapping(PersonEmployerPair::getPerson, toList())
+                ));
+
+        assertThat(actual, equalTo(expected));
+    }
+
+    private Stream<PersonEmployerPair> getPersonEmployerPairs(Employee employee) {
+        return employee.getJobHistory().stream()
+                .map(j -> new PersonEmployerPair(employee.getPerson(), j.getEmployer()));
     }
 
     @Test
     public void indexByFirstEmployer() {
-        Map<String, List<Person>> employeesIndex = null;// TODO
-        throw new UnsupportedOperationException();
+        List<Employee> employees = getEmployees();
+
+        Map<String, List<Person>> expected = new HashMap<>();
+        for (Employee employee : employees) {
+            if (employee.getJobHistory().size() > 0) {
+                String employer = employee.getJobHistory().get(0).getEmployer();
+                if (!expected.containsKey(employer)) {
+                    expected.put(employer, new ArrayList<>());
+                }
+
+                expected.get(employer).add(employee.getPerson());
+            }
+        }
+
+        Map<String, List<Person>> actual = employees.stream()
+                .flatMap(this::getFirstPersonEmployerPairs)
+                .collect(groupingBy(
+                        PersonEmployerPair::getEmployer,
+                        mapping(PersonEmployerPair::getPerson, toList())
+                ));
+
+
+        assertThat(actual, equalTo(expected));
+    }
+
+    private Stream<PersonEmployerPair> getFirstPersonEmployerPairs(Employee employee) {
+        return employee.getJobHistory().stream()
+                .map(j -> new PersonEmployerPair(employee.getPerson(), j.getEmployer()))
+                .limit(1);
     }
 
     @Test
     public void greatestExperiencePerEmployer() {
-        Map<String, Person> employeesIndex = null;// TODO
+        List<Employee> employees = getEmployees();
+
+
+        Map<String, Person> employeesIndex = employees.stream()
+                .flatMap(this::getPersonEmployerDuration)
+                .collect(groupingBy(
+                        PersonEmployerPair::getEmployer,
+                        collectingAndThen(
+                                maxBy(Comparator.comparingInt(PersonEmployerPair::getDuration)),
+                                p -> p.get().getPerson()
+                        )
+                ));
 
         assertEquals(new Person("John", "White", 28), employeesIndex.get("epam"));
     }
 
+    private Stream<PersonEmployerPair> getPersonEmployerDuration(Employee employee) {
+        return employee.getJobHistory().stream()
+                .map(j -> new PersonEmployerPair(employee.getPerson(), j.getEmployer(), j.getDuration()));
+    }
+
 
     private List<Employee> getEmployees() {
         return Arrays.asList(