diff --git a/src/main/java/data/Generator.java b/src/main/java/data/Generator.java
index cbd46ea..f98fd1b 100644
--- a/src/main/java/data/Generator.java
+++ b/src/main/java/data/Generator.java
@@ -60,7 +60,10 @@ public static Employee generateEmployee() {
     }
 
     public static List<Employee> generateEmployeeList() {
-        // TODO
-        throw new UnsupportedOperationException();
+        final int maxLength = 10;
+        final int length = ThreadLocalRandom.current().nextInt(maxLength) + 1;
+        return Stream.generate(Generator::generateEmployee)
+            .limit(length)
+            .collect(toList());
     }
 }
diff --git a/src/test/java/part1/exercise/StreamsExercise1.java b/src/test/java/part1/exercise/StreamsExercise1.java
index 02dd2da..66d9bb1 100755
--- a/src/test/java/part1/exercise/StreamsExercise1.java
+++ b/src/test/java/part1/exercise/StreamsExercise1.java
@@ -6,15 +6,12 @@
 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 static data.Generator.generateEmployeeList;
 import static java.util.stream.Collectors.groupingBy;
-import static java.util.stream.Collectors.mapping;
+import static java.util.stream.Collectors.summingInt;
 import static java.util.stream.Collectors.toList;
+import static org.junit.Assert.assertEquals;
 
 public class StreamsExercise1 {
     // https://youtu.be/kxgo7Y4cdA8 Сергей Куксенко и Алексей Шипилёв — Через тернии к лямбдам, часть 1
@@ -25,14 +22,45 @@ 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<Person> personsList = employees.stream()
+            .filter(e -> e.getJobHistory().stream()
+                .map(JobHistoryEntry::getEmployer)
+                .anyMatch(em -> em.equals("epam")))
+            .map(Employee::getPerson)
+            .collect(toList());
+
+        List<Person> expectedPersonList = new ArrayList<>();
+        for (Employee e : employees) {
+            for (JobHistoryEntry j : e.getJobHistory()) {
+                if (j.getEmployer().equals("epam")) {
+                    expectedPersonList.add(e.getPerson());
+                    break;
+                }
+            }
+        }
+
+        assertEquals(expectedPersonList, personsList);
     }
 
     @Test
     public void getEmployeesStartedFromEpam() {
-        List<Person> epamEmployees = null;// TODO all persons with first experience in epam
-        throw new UnsupportedOperationException();
+        List<Employee> employees = generateEmployeeList();
+
+        List<Person> personList = employees.stream()
+            .filter(e -> e.getJobHistory().get(0).getEmployer().equals("epam"))
+            .map(Employee::getPerson)
+            .collect(toList());
+
+        List<Person> epamEmployeesExpected = new ArrayList<>();
+        for (Employee e : employees) {
+            if (e.getJobHistory().get(0).getEmployer().equals("epam")) {
+                epamEmployeesExpected.add(e.getPerson());
+            }
+        }
+
+        assertEquals(epamEmployeesExpected, personList);
     }
 
     @Test
@@ -49,11 +77,13 @@ public void sumEpamDurations() {
             }
         }
 
-        // TODO
-        throw new UnsupportedOperationException();
+        int result = employees.stream()
+            .flatMap(e -> e.getJobHistory().stream())
+            .filter(j -> j.getEmployer().equals("epam"))
+            .mapToInt(JobHistoryEntry::getDuration)
+            .sum();
 
-        // int result = ???
-        // assertEquals(expected, result);
+        assertEquals(expected, result);
     }
 
 }
diff --git a/src/test/java/part1/exercise/StreamsExercise2.java b/src/test/java/part1/exercise/StreamsExercise2.java
index 5be9d38..43cfc2e 100755
--- a/src/test/java/part1/exercise/StreamsExercise2.java
+++ b/src/test/java/part1/exercise/StreamsExercise2.java
@@ -5,10 +5,14 @@
 import data.Person;
 import org.junit.Test;
 
+import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collections;
+import java.util.Comparator;
 import java.util.List;
 import java.util.Map;
+import java.util.Set;
+import java.util.stream.Collectors;
 import java.util.stream.Stream;
 
 import static data.Generator.generateEmployeeList;
@@ -22,23 +26,86 @@ 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;
+        private final int duration;
+
+        private 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();
+        Map<String, List<Person>> employersStuffLists = getEmployees().stream()
+            .flatMap(employee -> employee.getJobHistory().stream()
+                .map(j -> new PersonEmployerPair(employee.getPerson(), j.getEmployer(), j.getDuration())))
+            .collect(Collectors.groupingBy(
+                PersonEmployerPair::getEmployer,
+                mapping(PersonEmployerPair::getPerson, toList())
+            ));
+
+        List<Person> personList = new ArrayList<>();
+        personList.add(new Person("John", "Doe", 21));
+        personList.add(new Person("John", "Doe", 24));
+        personList.add(new Person("Bob", "Doe", 27));
+        personList.add(new Person("John", "Doe", 30));
+
+        assertEquals(personList, employersStuffLists.get("abc"));
     }
 
     @Test
     public void indexByFirstEmployer() {
-        Map<String, List<Person>> employeesIndex = null;// TODO
-        throw new UnsupportedOperationException();
+        Map<String, List<Person>> employeesIndex = getEmployees().stream()
+            .map(employee -> new PersonEmployerPair(employee.getPerson(),
+                                                    employee.getJobHistory().get(0).getEmployer(),
+                                                    employee.getJobHistory().get(0).getDuration()))
+            .collect(Collectors.groupingBy(
+                PersonEmployerPair::getEmployer,
+                mapping(PersonEmployerPair::getPerson, toList())
+            ));
+
+        List<Person> personList = new ArrayList<>();
+        personList.add(new Person("John", "Galt", 20));
+        personList.add(new Person("John", "White", 22));
+        personList.add(new Person("John", "Galt", 23));
+        personList.add(new Person("John", "White", 25));
+        personList.add(new Person("John", "Galt", 26));
+        personList.add(new Person("John", "White", 28));
+        personList.add(new Person("John", "Galt", 29));
+        personList.add(new Person("Bob", "White", 31));
+
+        assertEquals(personList, employeesIndex.get("epam"));
+
     }
 
     @Test
     public void greatestExperiencePerEmployer() {
-        Map<String, Person> employeesIndex = null;// TODO
+        Map<String, Person> employeesIndex = getEmployees().stream()
+            .flatMap(employee -> employee.getJobHistory().stream()
+            .map(j -> new PersonEmployerPair(employee.getPerson(), j.getEmployer(), j.getDuration())))
+            .collect(Collectors.groupingBy(
+                PersonEmployerPair::getEmployer,
+                Collectors.collectingAndThen(
+                    Collectors.maxBy(Comparator.comparingInt(PersonEmployerPair::getDuration)),
+                    p -> p.get().getPerson())
+            ));
 
         assertEquals(new Person("John", "White", 28), employeesIndex.get("epam"));
     }
@@ -46,78 +113,78 @@ public void greatestExperiencePerEmployer() {
 
     private List<Employee> getEmployees() {
         return Arrays.asList(
-                new Employee(
-                        new Person("John", "Galt", 20),
-                        Arrays.asList(
-                                new JobHistoryEntry(3, "dev", "epam"),
-                                new JobHistoryEntry(2, "dev", "google")
-                        )),
-                new Employee(
-                        new Person("John", "Doe", 21),
-                        Arrays.asList(
-                                new JobHistoryEntry(4, "BA", "yandex"),
-                                new JobHistoryEntry(2, "QA", "epam"),
-                                new JobHistoryEntry(2, "dev", "abc")
-                        )),
-                new Employee(
-                        new Person("John", "White", 22),
-                        Collections.singletonList(
-                                new JobHistoryEntry(6, "QA", "epam")
-                        )),
-                new Employee(
-                        new Person("John", "Galt", 23),
-                        Arrays.asList(
-                                new JobHistoryEntry(3, "dev", "epam"),
-                                new JobHistoryEntry(2, "dev", "google")
-                        )),
-                new Employee(
-                        new Person("John", "Doe", 24),
-                        Arrays.asList(
-                                new JobHistoryEntry(4, "QA", "yandex"),
-                                new JobHistoryEntry(2, "BA", "epam"),
-                                new JobHistoryEntry(2, "dev", "abc")
-                        )),
-                new Employee(
-                        new Person("John", "White", 25),
-                        Collections.singletonList(
-                                new JobHistoryEntry(6, "QA", "epam")
-                        )),
-                new Employee(
-                        new Person("John", "Galt", 26),
-                        Arrays.asList(
-                                new JobHistoryEntry(3, "dev", "epam"),
-                                new JobHistoryEntry(1, "dev", "google")
-                        )),
-                new Employee(
-                        new Person("Bob", "Doe", 27),
-                        Arrays.asList(
-                                new JobHistoryEntry(4, "QA", "yandex"),
-                                new JobHistoryEntry(2, "QA", "epam"),
-                                new JobHistoryEntry(2, "dev", "abc")
-                        )),
-                new Employee(
-                        new Person("John", "White", 28),
-                        Collections.singletonList(
-                                new JobHistoryEntry(666, "BA", "epam")
-                        )),
-                new Employee(
-                        new Person("John", "Galt", 29),
-                        Arrays.asList(
-                                new JobHistoryEntry(3, "dev", "epam"),
-                                new JobHistoryEntry(1, "dev", "google")
-                        )),
-                new Employee(
-                        new Person("John", "Doe", 30),
-                        Arrays.asList(
-                                new JobHistoryEntry(4, "QA", "yandex"),
-                                new JobHistoryEntry(2, "QA", "epam"),
-                                new JobHistoryEntry(5, "dev", "abc")
-                        )),
-                new Employee(
-                        new Person("Bob", "White", 31),
-                        Collections.singletonList(
-                                new JobHistoryEntry(6, "QA", "epam")
-                        ))
+            new Employee(
+                new Person("John", "Galt", 20),
+                Arrays.asList(
+                    new JobHistoryEntry(3, "dev", "epam"),
+                    new JobHistoryEntry(2, "dev", "google")
+                )),
+            new Employee(
+                new Person("John", "Doe", 21),
+                Arrays.asList(
+                    new JobHistoryEntry(4, "BA", "yandex"),
+                    new JobHistoryEntry(2, "QA", "epam"),
+                    new JobHistoryEntry(2, "dev", "abc")
+                )),
+            new Employee(
+                new Person("John", "White", 22),
+                Collections.singletonList(
+                    new JobHistoryEntry(6, "QA", "epam")
+                )),
+            new Employee(
+                new Person("John", "Galt", 23),
+                Arrays.asList(
+                    new JobHistoryEntry(3, "dev", "epam"),
+                    new JobHistoryEntry(2, "dev", "google")
+                )),
+            new Employee(
+                new Person("John", "Doe", 24),
+                Arrays.asList(
+                    new JobHistoryEntry(4, "QA", "yandex"),
+                    new JobHistoryEntry(2, "BA", "epam"),
+                    new JobHistoryEntry(2, "dev", "abc")
+                )),
+            new Employee(
+                new Person("John", "White", 25),
+                Collections.singletonList(
+                    new JobHistoryEntry(6, "QA", "epam")
+                )),
+            new Employee(
+                new Person("John", "Galt", 26),
+                Arrays.asList(
+                    new JobHistoryEntry(3, "dev", "epam"),
+                    new JobHistoryEntry(1, "dev", "google")
+                )),
+            new Employee(
+                new Person("Bob", "Doe", 27),
+                Arrays.asList(
+                    new JobHistoryEntry(4, "QA", "yandex"),
+                    new JobHistoryEntry(2, "QA", "epam"),
+                    new JobHistoryEntry(2, "dev", "abc")
+                )),
+            new Employee(
+                new Person("John", "White", 28),
+                Collections.singletonList(
+                    new JobHistoryEntry(666, "BA", "epam")
+                )),
+            new Employee(
+                new Person("John", "Galt", 29),
+                Arrays.asList(
+                    new JobHistoryEntry(3, "dev", "epam"),
+                    new JobHistoryEntry(1, "dev", "google")
+                )),
+            new Employee(
+                new Person("John", "Doe", 30),
+                Arrays.asList(
+                    new JobHistoryEntry(4, "QA", "yandex"),
+                    new JobHistoryEntry(2, "QA", "epam"),
+                    new JobHistoryEntry(5, "dev", "abc")
+                )),
+            new Employee(
+                new Person("Bob", "White", 31),
+                Collections.singletonList(
+                    new JobHistoryEntry(6, "QA", "epam")
+                ))
         );
     }
 
diff --git a/src/test/java/part2/exercise/CollectorsExercise1.java b/src/test/java/part2/exercise/CollectorsExercise1.java
index 46b6765..96ae277 100755
--- a/src/test/java/part2/exercise/CollectorsExercise1.java
+++ b/src/test/java/part2/exercise/CollectorsExercise1.java
@@ -6,17 +6,21 @@
 import org.junit.Test;
 
 import java.util.*;
-import java.util.concurrent.ThreadLocalRandom;
 import java.util.function.BiConsumer;
 import java.util.function.BinaryOperator;
 import java.util.function.Function;
 import java.util.function.Supplier;
 import java.util.stream.Collector;
 import java.util.stream.Collectors;
-import java.util.stream.IntStream;
 import java.util.stream.Stream;
 
-import static java.util.stream.Collectors.toList;
+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 java.util.stream.Collectors.summingInt;
+import static java.util.stream.Collectors.toMap;
+import static org.junit.Assert.assertEquals;
 
 public class CollectorsExercise1 {
 
@@ -28,6 +32,7 @@ public void getTheCoolestOne() {
     }
 
     private static class PersonPositionDuration {
+
         private final Person person;
         private final String position;
         private final int duration;
@@ -58,102 +63,182 @@ private Map<String, Person> getCoolestByPosition(List<Employee> employees) {
         // Collectors.collectingAndThen
         // Collectors.groupingBy
 
+        final Stream<PersonPositionDuration> persons = employees.stream()
+            .flatMap(e -> e.getJobHistory().stream()
+                .map(j -> new PersonPositionDuration(e.getPerson(), j.getPosition(), j.getDuration())));
+
+        Map<String, Person> option1 = persons
+            .collect(Collectors.groupingBy(
+                PersonPositionDuration::getPosition,
+                collectingAndThen(
+                    maxBy(comparing(PersonPositionDuration::getDuration)),
+                    p -> p.get().getPerson())
+            ));
+
         // Second option
         // Collectors.toMap
         // iterate twice: stream...collect(...).stream()...
-        // TODO
-        throw new UnsupportedOperationException();
+
+        Map<String, PersonPositionDuration> positionDurationMap = persons
+            .collect(toMap(
+                PersonPositionDuration::getPosition,
+                Function.identity(),
+                BinaryOperator.maxBy(comparing(PersonPositionDuration::getDuration))
+            ));
+
+        Map<String, Person> option2 = positionDurationMap.entrySet().stream()
+            .collect(toMap(Map.Entry::getKey,
+                           employee -> employee.getValue().getPerson()));
+
+        //third option
+        Map<String, Person> option3 = persons
+            .collect(new Collector<PersonPositionDuration, Map<String, PersonPositionDuration>, Map<String, Person>>() {
+                @Override
+                public Supplier<Map<String, PersonPositionDuration>> supplier() {
+                    return HashMap::new;
+                }
+
+                @Override
+                public BiConsumer<Map<String, PersonPositionDuration>, PersonPositionDuration> accumulator() {
+                    return (map, person) -> map.merge(
+                        person.getPosition(),
+                        person,
+                        (ppd1, ppd2) -> ppd1.getDuration() > ppd2.getDuration() ? ppd1 : ppd2);
+                }
+
+                @Override
+                public BinaryOperator<Map<String, PersonPositionDuration>> combiner() {
+                    return (map1, map2) -> {
+                        map2.forEach((key, value) -> map1.merge(key, value, (ppd1, ppd2) ->
+                            ppd1.getDuration() > ppd2.getDuration() ? ppd1 : ppd2));
+                        return map1;
+                    };
+                }
+
+                @Override
+                public Function<Map<String, PersonPositionDuration>, Map<String, Person>> finisher() {
+                    return (map) -> map.entrySet().stream()
+                        .collect(toMap(Map.Entry::getKey,
+                                       employee -> employee.getValue().getPerson()));
+                }
+
+                @Override
+                public Set<Characteristics> characteristics() {
+                    return Collections.emptySet();
+                }
+            });
+
+        return option1;
     }
 
     @Test
     public void getTheCoolestOne2() {
         final Map<String, Person> coolestByPosition = getCoolestByPosition2(getEmployees());
 
-        coolestByPosition.forEach((position, person) -> System.out.println(position + " -> " + person));
+        assertEquals(new Person("John", "Doe", 30), coolestByPosition.get("QA"));
+        assertEquals(new Person("John", "Galt", 26), coolestByPosition.get("dev"));
+        assertEquals(new Person("John", "Doe", 24), coolestByPosition.get("BA"));
     }
 
-    // With the longest sum duration on this position
-    // { John Doe, [{dev, google, 4}, {dev, epam, 4}] } предпочтительнее, чем { A B, [{dev, google, 6}, {QA, epam, 100}]}
+//     With the longest sum duration on this position
+//     { John Doe, [{dev, google, 4}, {dev, epam, 4}] } предпочтительнее, чем { A B, [{dev, google, 6}, {QA, epam, 100}]}
     private Map<String, Person> getCoolestByPosition2(List<Employee> employees) {
-        // TODO
-        throw new UnsupportedOperationException();
+        Map<String, List<PersonPositionDuration>> map = employees.stream()
+            .flatMap(this::positionDuration)
+            .collect(groupingBy(PersonPositionDuration::getPosition));
+
+        return map.entrySet().stream()
+            .collect(toMap(Map.Entry::getKey,
+                           ppd -> ppd.getValue().stream()
+            .reduce((ppd1, ppd2) -> ppd1.getDuration() > ppd2.getDuration() ? ppd1 : ppd2)
+            .get()
+            .getPerson()));
     }
 
-    private List<Employee> getEmployees() {
-        return Arrays.asList(
+    private Stream<PersonPositionDuration> positionDuration(Employee employee){
+        Map<String, Integer> mapEmployee = employee.getJobHistory().stream()
+            .collect(groupingBy(JobHistoryEntry::getPosition,
+                                summingInt(JobHistoryEntry::getDuration)));
+
+        return mapEmployee.entrySet().stream()
+            .map(e -> new PersonPositionDuration(employee.getPerson(), e.getKey(), e.getValue()));
+    }
+
+        private List<Employee> getEmployees () {
+            return Arrays.asList(
                 new Employee(
-                        new Person("John", "Galt", 20),
-                        Arrays.asList(
-                                new JobHistoryEntry(3, "dev", "epam"),
-                                new JobHistoryEntry(2, "dev", "google")
-                        )),
+                    new Person("John", "Galt", 20),
+                    Arrays.asList(
+                        new JobHistoryEntry(3, "dev", "epam"),
+                        new JobHistoryEntry(2, "dev", "google")
+                    )),
                 new Employee(
-                        new Person("John", "Doe", 21),
-                        Arrays.asList(
-                                new JobHistoryEntry(4, "BA", "yandex"),
-                                new JobHistoryEntry(2, "QA", "epam"),
-                                new JobHistoryEntry(2, "dev", "abc")
-                        )),
+                    new Person("John", "Doe", 21),
+                    Arrays.asList(
+                        new JobHistoryEntry(4, "BA", "yandex"),
+                        new JobHistoryEntry(2, "QA", "epam"),
+                        new JobHistoryEntry(2, "dev", "abc")
+                    )),
                 new Employee(
-                        new Person("John", "White", 22),
-                        Collections.singletonList(
-                                new JobHistoryEntry(6, "QA", "epam")
-                        )),
+                    new Person("John", "White", 22),
+                    Collections.singletonList(
+                        new JobHistoryEntry(6, "QA", "epam")
+                    )),
                 new Employee(
-                        new Person("John", "Galt", 23),
-                        Arrays.asList(
-                                new JobHistoryEntry(3, "dev", "epam"),
-                                new JobHistoryEntry(2, "dev", "google")
-                        )),
+                    new Person("John", "Galt", 23),
+                    Arrays.asList(
+                        new JobHistoryEntry(3, "dev", "epam"),
+                        new JobHistoryEntry(2, "dev", "google")
+                    )),
                 new Employee(
-                        new Person("John", "Doe", 24),
-                        Arrays.asList(
-                                new JobHistoryEntry(4, "QA", "yandex"),
-                                new JobHistoryEntry(2, "BA", "epam"),
-                                new JobHistoryEntry(2, "dev", "abc")
-                        )),
+                    new Person("John", "Doe", 24),
+                    Arrays.asList(
+                        new JobHistoryEntry(4, "QA", "yandex"),
+                        new JobHistoryEntry(2, "BA", "epam"),
+                        new JobHistoryEntry(2, "dev", "abc")
+                    )),
                 new Employee(
-                        new Person("John", "White", 25),
-                        Collections.singletonList(
-                                new JobHistoryEntry(6, "QA", "epam")
-                        )),
+                    new Person("John", "White", 25),
+                    Collections.singletonList(
+                        new JobHistoryEntry(6, "QA", "epam")
+                    )),
                 new Employee(
-                        new Person("John", "Galt", 26),
-                        Arrays.asList(
-                                new JobHistoryEntry(3, "dev", "epam"),
-                                new JobHistoryEntry(1, "dev", "google")
-                        )),
+                    new Person("John", "Galt", 26),
+                    Arrays.asList(
+                        new JobHistoryEntry(3, "dev", "epam"),
+                        new JobHistoryEntry(1, "dev", "google")
+                    )),
                 new Employee(
-                        new Person("Bob", "Doe", 27),
-                        Arrays.asList(
-                                new JobHistoryEntry(4, "QA", "yandex"),
-                                new JobHistoryEntry(2, "QA", "epam"),
-                                new JobHistoryEntry(2, "dev", "abc")
-                        )),
+                    new Person("Bob", "Doe", 27),
+                    Arrays.asList(
+                        new JobHistoryEntry(4, "QA", "yandex"),
+                        new JobHistoryEntry(2, "QA", "epam"),
+                        new JobHistoryEntry(2, "dev", "abc")
+                    )),
                 new Employee(
-                        new Person("John", "White", 28),
-                        Collections.singletonList(
-                                new JobHistoryEntry(6, "BA", "epam")
-                        )),
+                    new Person("John", "White", 28),
+                    Collections.singletonList(
+                        new JobHistoryEntry(6, "BA", "epam")
+                    )),
                 new Employee(
-                        new Person("John", "Galt", 29),
-                        Arrays.asList(
-                                new JobHistoryEntry(3, "dev", "epam"),
-                                new JobHistoryEntry(1, "dev", "google")
-                        )),
+                    new Person("John", "Galt", 29),
+                    Arrays.asList(
+                        new JobHistoryEntry(3, "dev", "epam"),
+                        new JobHistoryEntry(1, "dev", "google")
+                    )),
                 new Employee(
-                        new Person("John", "Doe", 30),
-                        Arrays.asList(
-                                new JobHistoryEntry(4, "QA", "yandex"),
-                                new JobHistoryEntry(2, "QA", "epam"),
-                                new JobHistoryEntry(5, "dev", "abc")
-                        )),
+                    new Person("John", "Doe", 30),
+                    Arrays.asList(
+                        new JobHistoryEntry(4, "QA", "yandex"),
+                        new JobHistoryEntry(2, "QA", "epam"),
+                        new JobHistoryEntry(5, "dev", "abc")
+                    )),
                 new Employee(
-                        new Person("Bob", "White", 31),
-                        Collections.singletonList(
-                                new JobHistoryEntry(6, "QA", "epam")
-                        ))
-        );
-    }
+                    new Person("Bob", "White", 31),
+                    Collections.singletonList(
+                        new JobHistoryEntry(6, "QA", "epam")
+                    ))
+            );
+        }
 
-}
+    }
diff --git a/src/test/java/part2/exercise/CollectorsExercise2.java b/src/test/java/part2/exercise/CollectorsExercise2.java
index 00fda00..ddce3e7 100755
--- a/src/test/java/part2/exercise/CollectorsExercise2.java
+++ b/src/test/java/part2/exercise/CollectorsExercise2.java
@@ -3,6 +3,7 @@
 import data.Employee;
 import data.JobHistoryEntry;
 import data.Person;
+import org.junit.Assert;
 import org.junit.Test;
 
 import java.util.*;
@@ -16,6 +17,7 @@
 import java.util.stream.IntStream;
 import java.util.stream.Stream;
 
+import static java.util.Collections.singletonList;
 import static java.util.stream.Collectors.toList;
 
 public class CollectorsExercise2 {
@@ -26,15 +28,15 @@ private static String generateString() {
         final int length = ThreadLocalRandom.current().nextInt(maxLength) + 1;
 
         return IntStream.range(0, length)
-                .mapToObj(letters::charAt)
-                .map(Object::toString)
-                .collect(Collectors.joining());
+            .mapToObj(letters::charAt)
+            .map(Object::toString)
+            .collect(Collectors.joining());
     }
 
     private static String[] generateStringArray(int length) {
         return Stream.generate(CollectorsExercise2::generateString)
-                .limit(length)
-                .toArray(String[]::new);
+            .limit(length)
+            .toArray(String[]::new);
     }
 
     public static String pickString(String[] array) {
@@ -42,6 +44,7 @@ public static String pickString(String[] array) {
     }
 
     public static class Key {
+
         private final String id;
 
         public Key(String id) {
@@ -54,8 +57,12 @@ public String getId() {
 
         @Override
         public boolean equals(Object o) {
-            if (this == o) return true;
-            if (o == null || getClass() != o.getClass()) return false;
+            if (this == o) {
+                return true;
+            }
+            if (o == null || getClass() != o.getClass()) {
+                return false;
+            }
 
             Key key = (Key) o;
 
@@ -70,6 +77,7 @@ public int hashCode() {
     }
 
     public static class Value {
+
         private final String keyId;
 
         public Value(String keyId) {
@@ -82,6 +90,7 @@ public String getKeyId() {
     }
 
     public static class Pair {
+
         private final Key key;
         private final Value value;
 
@@ -103,16 +112,18 @@ public static List<Pair> generatePairs(int idCount, int length) {
         final String[] ids = generateStringArray(idCount);
 
         return Stream.generate(() -> new Pair(new Key(pickString(ids)), new Value(pickString(ids))))
-                .limit(length)
-                .collect(toList());
+            .limit(length)
+            .collect(toList());
     }
 
     private static class SubResult {
+
         private final Map<Key, List<Value>> subResult;
         private final Map<String, List<Key>> knownKeys;
         private final Map<String, List<Value>> valuesWithoutKeys;
 
-        public SubResult(Map<Key, List<Value>> subResult, Map<String, List<Key>> knownKeys, Map<String, List<Value>> valuesWithoutKeys) {
+        public SubResult(Map<Key, List<Value>> subResult, Map<String, List<Key>> knownKeys,
+                         Map<String, List<Value>> valuesWithoutKeys) {
             this.subResult = subResult;
             this.knownKeys = knownKeys;
             this.valuesWithoutKeys = valuesWithoutKeys;
@@ -132,6 +143,7 @@ public Map<String, List<Key>> getKnownKeys() {
     }
 
     private static class MapPair {
+
         private final Map<String, Key> keyById;
         private final Map<String, List<Value>> valueById;
 
@@ -168,90 +180,111 @@ public void collectKeyValueMap() {
         final List<Pair> pairs = generatePairs(10, 100);
 
         // В два прохода
-        // final Map<String, Key> keyMap1 = pairs.stream()...
-
-        // final Map<String, List<Value>> valuesMap1 = pairs.stream()...
+        final Map<String, Key> keyMap1 = pairs.stream()
+            .map(Pair::getKey)
+            .collect(Collectors.toMap(Key::getId, Function.identity(), (k1, k2) -> k1));
 
+        final Map<String, List<Value>> valueMap1 = pairs.stream()
+            .map(Pair::getValue)
+            .collect(Collectors.groupingBy(Value::getKeyId));
         // В каждом Map.Entry id ключа должно совпадать с keyId для каждого значения в списке
-        // final Map<Key, List<Value>> keyValuesMap1 = valueMap1.entrySet().stream()...
-
+        final Map<Key, List<Value>> keyValuesMap1 = valueMap1.entrySet().stream()
+            .collect(Collectors.toMap(e -> keyMap1.get(e.getKey()),
+                                      Map.Entry::getValue,
+                                      (list1, list2) -> Stream.concat(list1.stream(), list2.stream())
+                                          .collect(Collectors.toList())));
         // В 1 проход в 2 Map с использованием MapPair и mapMerger
         final MapPair res2 = pairs.stream()
-                .collect(new Collector<Pair, MapPair, MapPair>() {
-                    @Override
-                    public Supplier<MapPair> supplier() {
-                        // TODO
-                        throw new UnsupportedOperationException();
-                    }
-
-                    @Override
-                    public BiConsumer<MapPair, Pair> accumulator() {
-                        // TODO add key and value to maps
-                        throw new UnsupportedOperationException();
-                    }
-
-                    @Override
-                    public BinaryOperator<MapPair> combiner() {
-                        // TODO use mapMerger
-                        throw new UnsupportedOperationException();
-                    }
-
-                    @Override
-                    public Function<MapPair, MapPair> finisher() {
-                        return Function.identity();
-                    }
-
-                    @Override
-                    public Set<Characteristics> characteristics() {
-                        return Collections.unmodifiableSet(EnumSet.of(
-                                Characteristics.UNORDERED,
-                                Characteristics.IDENTITY_FINISH));
-                    }
-                });
+            .collect(new Collector<Pair, MapPair, MapPair>() {
+                @Override
+                public Supplier<MapPair> supplier() {
+                    return MapPair::new;
+                }
+
+                @Override
+                public BiConsumer<MapPair, Pair> accumulator() {
+                    return ((mapPair, pair) -> {
+                        mapPair.getKeyById().merge(pair.getKey().getId(), pair.getKey(), (k1, k2) -> k1);
+                        mapPair.getValueById()
+                            .computeIfAbsent(pair.getValue().getKeyId(), s -> new ArrayList<Value>())
+                            .add(pair.getValue());
+                    });
+                }
+
+                @Override
+                public BinaryOperator<MapPair> combiner() {
+                    return (m1, m2) -> {
+                        BinaryOperator<Map<String, Key>> keyMapMerge = mapMerger(
+                            (Key k1, Key k2) -> k1
+                        );
+
+                        Map<String, Key> keyMap = keyMapMerge.apply(
+                            m1.getKeyById(),
+                            m2.getKeyById()
+                        );
+
+                        BinaryOperator<Map<String, List<Value>>> valueMapMerge = mapMerger(
+                            (List<Value> list1, List<Value> list2) -> {
+                                list1.addAll(list2);
+                                return list1;
+                            }
+                        );
+
+                        Map<String, List<Value>> valueMap = valueMapMerge.apply(
+                            m1.getValueById(),
+                            m2.getValueById()
+                        );
+
+                        return new MapPair(keyMap, valueMap);
+                    };
+                }
+
+                @Override
+                public Function<MapPair, MapPair> finisher() {
+                    return Function.identity();
+                }
+
+                @Override
+                public Set<Characteristics> characteristics() {
+                    return Collections.unmodifiableSet(EnumSet.of(
+                        Characteristics.UNORDERED,
+                        Characteristics.IDENTITY_FINISH));
+                }
+            });
 
         final Map<String, Key> keyMap2 = res2.getKeyById();
-        final Map<String, List<Value>> valuesMap2 = res2.getValueById();
-
-        // final Map<Key, List<Value>> keyValuesMap2 = valueMap2.entrySet().stream()...
-
-        // Получение результата сразу:
-
-        final SubResult res3 = pairs.stream()
-                .collect(new Collector<Pair, SubResult, SubResult>() {
-                    @Override
-                    public Supplier<SubResult> supplier() {
-                        // TODO
-                        throw new UnsupportedOperationException();
-                    }
-
-                    @Override
-                    public BiConsumer<SubResult, Pair> accumulator() {
-                        // TODO add key to map, then check value.keyId and add it to one of maps
-                        throw new UnsupportedOperationException();
-                    }
-
-                    @Override
-                    public BinaryOperator<SubResult> combiner() {
-                        // TODO use mapMerger, then check all valuesWithoutKeys
-                        throw new UnsupportedOperationException();
-                    }
-
-                    @Override
-                    public Function<SubResult, SubResult> finisher() {
-                        // TODO use mapMerger, then check all valuesWithoutKeys
-                        throw new UnsupportedOperationException();
-                    }
-
-                    @Override
-                    public Set<Characteristics> characteristics() {
-                        return Collections.unmodifiableSet(EnumSet.of(
-                                Characteristics.UNORDERED));
-                    }
-                });
-
-        final Map<Key, List<Value>> keyValuesMap3 = res3.getSubResult();
-
-        // compare results
+        final Map<String, List<Value>> valueMap2 = res2.getValueById();
+
+        final Map<Key, List<Value>> keyValuesMap2 = valueMap2.entrySet().stream()
+            .collect(Collectors.toMap(entry -> keyMap2.get(entry.getKey()),
+                                      Map.Entry::getValue, (val1, val2) -> {
+                    val1.addAll(val2);
+                    return val1;
+                }));
+
+        Assert.assertEquals(keyValuesMap1, keyValuesMap2);
+
+        final Map<String, Key> expectedKeys = new HashMap<>();
+        final Map<String, List<Value>> expectedValues = new HashMap<>();
+
+        for (Pair p : pairs) {
+            expectedKeys.put(p.getKey().getId(), p.getKey());
+            expectedValues.merge(p.getValue().getKeyId(), new ArrayList<>(singletonList(p.getValue())),
+                                 (s1, s2) -> {
+                                     s1.addAll(s2);
+                                     return s1;
+                                 }
+            );
+        }
+
+        final Map<Key, List<Value>> expected =
+            expectedValues.entrySet().stream().collect(Collectors.toMap(entry -> keyMap2.get(entry.getKey()),
+                                                                        Map.Entry::getValue, (values1, values2) -> {
+                    values1.addAll(values2);
+                    return values1;
+                }));
+
+        Assert.assertEquals(keyValuesMap1,expected);
     }
 
 }
diff --git a/src/test/java/part3/exercise/lambda/LambdaExercise.java b/src/test/java/part3/exercise/lambda/LambdaExercise.java
index 752e1f2..295f9d2 100755
--- a/src/test/java/part3/exercise/lambda/LambdaExercise.java
+++ b/src/test/java/part3/exercise/lambda/LambdaExercise.java
@@ -15,19 +15,21 @@ public class LambdaExercise {
     public void supply() {
         final Person person = new Person("John", "Galt", 30);
 
-        final Supplier<Person> getPerson = null; // TODO return person from Supplier
+        final Supplier<Person> getPerson = () -> new Person("John", "Galt", 30);
 
         assertEquals(person, getPerson.get());
     }
 
     @Test
     public void function() {
-        final Function<Person, String> getPersonName1 = null; // TODO get the name of person using expression lambda
+        final Function<Person, String> getPersonName1 = person -> person.getFirstName();
 
-        final Function<Person, String> getPersonName2 = null; // TODO get the name of person using method reference
+        final Function<Person, String> getPersonName2 = Person::getFirstName;
 
-        // TODO get the name of person and log it to System.out using statement lambda: {}
-        final Function<Person, String> getPersonNameAndLogIt = null;
+        final Function<Person, String> getPersonNameAndLogIt = person -> {
+            System.out.println(person.getFirstName());
+            return person.getFirstName();
+        };
 
         final Person person = new Person("John", "Galt", 30);
 
@@ -38,19 +40,17 @@ public void function() {
 
     @Test
     public void combineFunctions() {
-        final Function<Person, String> getPersonName = null; // TODO get the name of person
+        final Function<Person, String> getPersonName = Person::getFirstName;
 
         assertEquals("John", getPersonName.apply(new Person("John", "Galt", 30)));
 
-        final Function<String, Integer> getStringLength = null; // TODO get string length
+        final Function<String, Integer> getStringLength = String::length;
 
         assertEquals(Integer.valueOf(3), getStringLength.apply("ABC"));
 
-        // TODO get person name length using getPersonName and getStringLength without andThen
-        final Function<Person, Integer> getPersonNameLength1 = null;
+        final Function<Person, Integer> getPersonNameLength1 = person -> getStringLength.apply(getPersonName.apply(person));
 
-        // TODO get person name length using getPersonName and getStringLength with andThen
-        final Function<Person, Integer> getPersonNameLength2 = null;
+        final Function<Person, Integer> getPersonNameLength2 = getPersonName.andThen(getStringLength);
 
         final Person person = new Person("John", "Galt", 30);
 
@@ -68,22 +68,20 @@ private Person createPerson(PersonFactory pf) {
 
     // ((T -> R), (R -> boolean)) -> (T -> boolean)
     private <T, R> Predicate<T> combine(Function<T, R> f, Predicate<R> p) {
-        // TODO
-        throw new UnsupportedOperationException();
+        return (T t) -> p.test(f.apply(t));
     }
 
     @Test
     public void methodReference() {
-        // TODO use only method reverences here.
-        final Person person = createPerson(null); // TODO
+        final Person person = createPerson(Person::new);
 
         assertEquals(new Person("John", "Galt", 66), person);
 
-        final Function<Person, String> getPersonName = null; // TODO
+        final Function<Person, String> getPersonName = Person::getFirstName;
 
         assertEquals("John", getPersonName.apply(person));
 
-        final Predicate<String> isJohnString = null; // TODO using method reference check that "John" equals string parameter
+        final Predicate<String> isJohnString = "John"::equals;
 
         final Predicate<Person> isJohnPerson = combine(getPersonName, isJohnString);
 
diff --git a/src/test/java/part3/exercise/stream/StreamsExercise.java b/src/test/java/part3/exercise/stream/StreamsExercise.java
index 4e2d54b..47bd5de 100755
--- a/src/test/java/part3/exercise/stream/StreamsExercise.java
+++ b/src/test/java/part3/exercise/stream/StreamsExercise.java
@@ -8,8 +8,12 @@
 
 import java.util.Arrays;
 import java.util.Collections;
+import java.util.Comparator;
 import java.util.List;
 import java.util.Map;
+import java.util.Optional;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
 
 import static org.junit.Assert.assertEquals;
 
@@ -19,7 +23,9 @@ public class StreamsExercise {
     public void getAllJobHistoryEntries() {
         final List<Employee> employees = getEmployees();
 
-        final List<JobHistoryEntry> jobHistoryEntries = null; // TODO
+        final List<JobHistoryEntry> jobHistoryEntries = employees.stream()
+            .flatMap(employee -> employee.getJobHistory().stream())
+            .collect(Collectors.toList());
 
         assertEquals(22, jobHistoryEntries.size());
     }
@@ -29,7 +35,10 @@ public void getSumDuration() {
         // sum all durations for all persons
         final List<Employee> employees = getEmployees();
 
-        final int sumDurations = 0; // TODO
+        final int sumDurations = employees.stream()
+            .flatMap(employee -> employee.getJobHistory().stream())
+            .mapToInt(JobHistoryEntry::getDuration)
+            .sum();
 
         assertEquals(72, sumDurations);
     }
@@ -64,16 +73,27 @@ public String toString() {
     public void indexPersonsByEmployer1() {
         final List<Employee> employees = getEmployees();
 
-        final Map<String, List<PersonEmployer>> index = null; // TODO
+        final Map<String, List<PersonEmployer>> index = employees.stream()
+            .flatMap(StreamsExercise::employeesByPerson)
+            .collect(Collectors.groupingBy(PersonEmployer::getEmployer));
 
         assertEquals(11, index.get("epam").size());
     }
 
+    private static Stream<PersonEmployer> employeesByPerson(Employee employee){
+        return employee.getJobHistory().stream()
+            .map(jobHistoryEntry -> new PersonEmployer(employee.getPerson(), jobHistoryEntry.getEmployer()));
+    }
+
     @Test
     public void indexPersonsByEmployer2() {
         final List<Employee> employees = getEmployees();
 
-        final Map<String, List<Person>> index = null; // TODO
+        final Map<String, List<Person>> index = employees.stream()
+            .flatMap(StreamsExercise::employeesByPerson)
+            .collect(Collectors.groupingBy(PersonEmployer::getEmployer, Collectors.mapping(
+                PersonEmployer::getPerson, Collectors.toList()
+            )));
 
         assertEquals(11, index.get("epam").size());
     }
@@ -105,8 +125,10 @@ public String toString() {
     }
 
     private PersonDuration sumAllPersonDurations(Employee e) {
-        // TODO
-        throw new UnsupportedOperationException();
+        int duration = e.getJobHistory().stream()
+            .mapToInt(JobHistoryEntry::getDuration)
+            .sum();
+        return new PersonDuration(e.getPerson(),duration);
     }
 
     @Test
@@ -114,7 +136,8 @@ public void getSumPersonDuration() {
         // sum all durations for each person
         final List<Employee> employees = getEmployees();
 
-        final Map<Person, Integer> personDuration = null; // TODO use sumAllPersonDurations
+        final Map<Person, Integer> personDuration = employees.stream()
+            .collect(Collectors.toMap(Employee::getPerson, employee -> sumAllPersonDurations(employee).getDuration()));
 
         assertEquals(Integer.valueOf(8), personDuration.get(new Person("John", "Doe", 24)));
     }
@@ -138,15 +161,19 @@ public Map<String, Integer> getDurationByPositionIndex() {
     }
 
     private static PersonPositionIndex getPersonPositionIndex(Employee e) {
-        // TODO
-        throw new UnsupportedOperationException();
+        Map<String, Integer> map = e.getJobHistory().stream()
+            .collect(Collectors.toMap(JobHistoryEntry::getPosition, JobHistoryEntry::getDuration,
+                                      (d1, d2) -> d1 + d2));
+        return new PersonPositionIndex(e.getPerson(), map);
     }
 
     @Test
     public void getSumDurationsForPersonByPosition() {
         final List<Employee> employees = getEmployees();
 
-        final List<PersonPositionIndex> personIndexes = null; // TODO use getPersonPositionIndex
+        final List<PersonPositionIndex> personIndexes = employees.stream()
+            .map(employee -> getPersonPositionIndex(employee))
+            .collect(Collectors.toList());
 
         assertEquals(1, personIndexes.get(3).getDurationByPositionIndex().size());
     }
@@ -175,11 +202,21 @@ public int getDuration() {
         }
     }
 
+    private Stream<PersonPositionDuration> personPositionDuration(Employee employee){
+        Map<String, Integer> map = employee.getJobHistory().stream()
+            .collect(Collectors.toMap(JobHistoryEntry::getPosition, JobHistoryEntry::getDuration,
+                                      (d1, d2) -> d1 + d2));
+        return map.keySet().stream()
+            .map(s -> new PersonPositionDuration(employee.getPerson(), s, map.get(s)));
+    }
+
     @Test
     public void getDurationsForEachPersonByPosition() {
         final List<Employee> employees = getEmployees();
 
-        final List<PersonPositionDuration> personPositionDurations =  null; // TODO
+        final List<PersonPositionDuration> personPositionDurations =  employees.stream()
+            .flatMap(employee -> personPositionDuration(employee))
+            .collect(Collectors.toList());
 
 
         assertEquals(17, personPositionDurations.size());
@@ -190,7 +227,14 @@ public void getCoolestPersonByPosition1() {
         // Get person with max duration on given position
         final List<Employee> employees = getEmployees();
 
-        final Map<String, PersonPositionDuration> coolestPersonByPosition = null;// TODO
+        final Map<String, PersonPositionDuration> coolestPersonByPosition = employees
+            .stream()
+            .flatMap(e -> personPositionDuration(e))
+            .collect(Collectors.groupingBy(
+                PersonPositionDuration::getPosition,
+                Collectors
+                    .collectingAndThen(Collectors.maxBy(Comparator.comparing(PersonPositionDuration::getDuration)),
+                                       Optional::get)));
 
 
         assertEquals(new Person("John", "White", 22), coolestPersonByPosition.get("QA").getPerson());
@@ -201,7 +245,14 @@ public void getCoolestPersonByPosition2() {
         // Get person with max duration on given position
         final List<Employee> employees = getEmployees();
 
-        final Map<String, Person> coolestPersonByPosition = null; // TODO
+        final Map<String, Person> coolestPersonByPosition = employees
+            .stream()
+            .flatMap(e -> personPositionDuration(e))
+            .collect(Collectors.groupingBy(
+                PersonPositionDuration::getPosition,
+                Collectors
+                    .collectingAndThen(Collectors.maxBy(Comparator.comparing(PersonPositionDuration::getDuration)),
+                                       p -> p.get().getPerson())));
 
 
         assertEquals(new Person("John", "White", 22), coolestPersonByPosition.get("QA"));