Nazarov_Anton/part1

src/main/java/data/Generator.java

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

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

@@ -1,20 +1,17 @@
 package part1.exercise;
 
 import data.Employee;
+import data.Generator;
 import data.JobHistoryEntry;
 import data.Person;
 import org.junit.Test;
 
-import java.util.*;
-import java.util.concurrent.ThreadLocalRandom;
-import java.util.stream.Collectors;
-import java.util.stream.IntStream;
-import java.util.stream.Stream;
+import java.util.ArrayList;
+import java.util.List;
 
 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
@@ -23,16 +20,48 @@ public class StreamsExercise1 {
     // https://youtu.be/O8oN4KSZEXE Сергей Куксенко — Stream API, часть 1
     // https://youtu.be/i0Jr2l3jrDA Сергей Куксенко — Stream API, часть 2
 
+    public List<JobHistoryEntry> getEpamOffer(List<JobHistoryEntry> jobs) {
+        return jobs.stream().filter(j -> j.getEmployer().equals("epam")).collect(toList());
+    }
+
     @Test
     public void getAllEpamEmployees() {
-        List<Person> epamEmployees = null;// TODO all persons with experience in epam
-        throw new UnsupportedOperationException();
+        final List<Employee> employees    = Generator.generateEmployeeList();
+        final List<Person>   badCalculate = new ArrayList<>();
+
+        for (Employee e : employees) {
+            for (JobHistoryEntry j : e.getJobHistory()) {
+                if (j.getEmployer().equals("epam")) {
+                    badCalculate.add(e.getPerson());
+                    break;
+                }
+            }
+        }
+
+        final List<Person> epamEmployees = employees.stream()
+                .filter(e -> !getEpamOffer(e.getJobHistory()).isEmpty())
+                .map(Employee::getPerson)
+                .collect(toList());
+        assertEquals(badCalculate, epamEmployees);
     }
 
     @Test
     public void getEmployeesStartedFromEpam() {
-        List<Person> epamEmployees = null;// TODO all persons with first experience in epam
-        throw new UnsupportedOperationException();
+        final List<Employee> employees    = Generator.generateEmployeeList();
+        final List<Person>   badCalculate = new ArrayList<>();
+
+        for (final Employee e : employees) {
+            if ("epam".equals(e.getJobHistory().get(0).getEmployer())) {
+                badCalculate.add(e.getPerson());
+            }
+        }
+
+        final List<Person> epamEmployees = employees.stream()
+                .filter(e -> "epam".equals(e.getJobHistory().get(0).getEmployer()))
+                .map(Employee::getPerson)
+                .collect(toList());
+
+        assertEquals(badCalculate, epamEmployees);
     }
 
     @Test
@@ -41,19 +70,22 @@ public void sumEpamDurations() {
 
         int expected = 0;
 
-        for (Employee e : employees) {
+
+        for (final Employee e : employees) {
             for (JobHistoryEntry j : e.getJobHistory()) {
                 if (j.getEmployer().equals("epam")) {
                     expected += j.getDuration();
                 }
             }
         }
 
-        // TODO
-        throw new UnsupportedOperationException();
 
-        // int result = ???
-        // assertEquals(expected, result);
+        int result = employees.stream()
+                .flatMap(e -> e.getJobHistory().stream())
+                .filter(j -> "epam".equals(j.getEmployer()))
+                .mapToInt(JobHistoryEntry::getDuration)
+                .sum();
+        assertEquals(expected, result);
     }
 
 }

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

@@ -5,13 +5,9 @@
 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 java.util.stream.Collectors;
 
-import static data.Generator.generateEmployeeList;
 import static java.util.stream.Collectors.*;
 import static org.junit.Assert.assertEquals;
 
@@ -22,25 +18,101 @@ public class StreamsExercise2 {
     // https://youtu.be/O8oN4KSZEXE Сергей Куксенко — Stream API, часть 1
     // https://youtu.be/i0Jr2l3jrDA Сергей Куксенко — Stream API, часть 2
 
-    // TODO class PersonEmployerPair
+    private class PersonEmploerPair {
+        private final Person person;
+        private final String employer;
+
+        public PersonEmploerPair(final Person person, final String employer) {
+            this.person = person;
+            this.employer = employer;
+        }
+
+        public String getEmployer() {
+            return employer;
+        }
+
+        public Person getPerson() {
+            return person;
+        }
+    }
+
+    private class PersonEmploerVeryUseful {
+        private final Person person;
+        private final String employer;
+        private int duration;
+
+        public PersonEmploerVeryUseful(final Person person, final String employer, final int duration) {
+            this.person = person;
+            this.employer = employer;
+            this.duration = duration;
+        }
+
+        public String getEmployer() {
+            return employer;
+        }
+
+        public Person getPerson() {
+            return person;
+        }
+
+        public int getDuration() {
+            return duration;
+        }
+
+        public void setDuration(int duration) {
+            this.duration = duration;
+        }
+    }
 
     @Test
     public void employersStuffLists() {
-        Map<String, List<Person>> employersStuffLists = null;// TODO
-        throw new UnsupportedOperationException();
+        final Map<String, List<Person>> employersStuffLists = getEmployees()
+                .stream()
+                .flatMap(e -> e.getJobHistory()
+                        .stream()
+                        .map(j -> new PersonEmploerPair(e.getPerson(), j.getEmployer())))
+                .collect(groupingBy(PersonEmploerPair::getEmployer,
+                        mapping(PersonEmploerPair::getPerson, toList())));
+        final Map<String, List<Person>> badCalculated = new HashMap<>();
+        final List<Employee>            employees     = getEmployees();
+        for (Employee e : employees) {
+            for (JobHistoryEntry j : e.getJobHistory()) {
+                badCalculated.computeIfAbsent(j.getEmployer(), v -> new ArrayList<>()).add(e.getPerson());
+            }
+        }
+        assertEquals(badCalculated, employersStuffLists);
     }
 
     @Test
     public void indexByFirstEmployer() {
-        Map<String, List<Person>> employeesIndex = null;// TODO
-        throw new UnsupportedOperationException();
+        final Map<String, List<Person>> employeesIndex = new HashMap<>();
+        final List<Employee>            employees      = getEmployees();
+        for (final Employee e : employees) {
+            employeesIndex.computeIfAbsent(e.getJobHistory().get(0).getEmployer(), v -> new ArrayList<>()).add(e.getPerson());
+        }
+
+        final Map<String, List<Person>> streamed = employees
+                .stream()
+                .map(e -> new PersonEmploerPair(e.getPerson(), e.getJobHistory().get(0).getEmployer()))
+                .collect(groupingBy(PersonEmploerPair::getEmployer,
+                        mapping(PersonEmploerPair::getPerson, toList())));
+        assertEquals(employeesIndex, streamed);
     }
 
     @Test
     public void greatestExperiencePerEmployer() {
-        Map<String, Person> employeesIndex = null;// TODO
+        final List<Employee> employees = getEmployees();
+
+        final Map<String, Optional<Person>> collect = employees
+                .stream()
+                .flatMap(e -> e.getJobHistory()
+                        .stream()
+                        .map(j -> new PersonEmploerVeryUseful(e.getPerson(), j.getEmployer(), j.getDuration())))
+                .collect(groupingBy(PersonEmploerVeryUseful::getEmployer,
+                        collectingAndThen(Collectors.maxBy(Comparator.comparingInt(PersonEmploerVeryUseful::getDuration)),
+                                e -> e.map(PersonEmploerVeryUseful::getPerson))));
 
-        assertEquals(new Person("John", "White", 28), employeesIndex.get("epam"));
+        assertEquals(new Person("John", "White", 28), collect.get("epam").get());
     }