diff --git a/src/main/java/data/Generator.java b/src/main/java/data/Generator.java index cbd46ea..701f6b6 100644 --- a/src/main/java/data/Generator.java +++ b/src/main/java/data/Generator.java @@ -60,7 +60,11 @@ public static Employee generateEmployee() { } public static List generateEmployeeList() { - // TODO - throw new UnsupportedOperationException(); + int maxEmployee = 10; + final int length = ThreadLocalRandom.current().nextInt(maxEmployee) + 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..e4e610c 100755 --- a/src/test/java/part1/exercise/StreamsExercise1.java +++ b/src/test/java/part1/exercise/StreamsExercise1.java @@ -1,20 +1,18 @@ 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.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.summarizingInt; import static java.util.stream.Collectors.toList; +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertTrue; public class StreamsExercise1 { // https://youtu.be/kxgo7Y4cdA8 Сергей Куксенко и Алексей Шипилёв — Через тернии к лямбдам, часть 1 @@ -25,21 +23,102 @@ public class StreamsExercise1 { @Test public void getAllEpamEmployees() { - List epamEmployees = null;// TODO all persons with experience in epam - throw new UnsupportedOperationException(); + List employees = Generator.generateEmployeeList(); + + List epamEmployees = + employees.stream() + .filter(employee -> + employee.getJobHistory() + .stream() + .anyMatch( + job -> job.getEmployer().equals("epam") + ) + ) + .map(Employee::getPerson) + .collect(toList()); + + employees.forEach(employee -> + { + epamEmployees.forEach( + person -> { + if (person.equals(employee.getPerson())) { + assertTrue( + employee.getJobHistory() + .stream() + .anyMatch( + job -> job.getEmployer().equals("epam") + ) + ); + } + } + ); + } + ); + + long epamEmployeesCount = + employees.stream() + .filter( + employee -> employee.getJobHistory() + .stream() + .anyMatch(job -> job.getEmployer().equals("epam")) + ) + .count(); + + assertEquals(epamEmployees.size(), epamEmployeesCount); } @Test public void getEmployeesStartedFromEpam() { - List epamEmployees = null;// TODO all persons with first experience in epam - throw new UnsupportedOperationException(); + List employees = Generator.generateEmployeeList(); + List epamEmployees = + employees.stream() + .filter( + employee -> employee.getJobHistory() + .stream() + .findFirst() + .filter(job -> job.getEmployer().equals("epam")) + .isPresent() + ) + .map(Employee::getPerson) + .collect(toList()); + + employees.forEach(employee -> + { + epamEmployees.forEach( + person -> { + if (person.equals(employee.getPerson())) { + employee.getJobHistory() + .stream() + .findFirst() + .ifPresent( + job -> assertEquals("epam", job.getEmployer()) + ); + } + } + ); + } + ); + + long epamEmployeesCount = + employees.stream() + .filter( + employee -> employee.getJobHistory() + .stream() + .findFirst() + .filter(job -> job.getEmployer().equals("epam")) + .isPresent() + ) + .count(); + + assertEquals(epamEmployees.size(), epamEmployeesCount); + } @Test public void sumEpamDurations() { final List employees = generateEmployeeList(); - int expected = 0; + long expected = 0; for (Employee e : employees) { for (JobHistoryEntry j : e.getJobHistory()) { @@ -49,11 +128,18 @@ public void sumEpamDurations() { } } - // TODO - throw new UnsupportedOperationException(); + long result = + employees.stream() + .flatMap(employee -> + employee.getJobHistory().stream() + .filter(job -> job.getEmployer().equals("epam")) + ) + .collect( + summarizingInt(JobHistoryEntry::getDuration) + ) + .getSum(); - // 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..d90082e 100755 --- a/src/test/java/part1/exercise/StreamsExercise2.java +++ b/src/test/java/part1/exercise/StreamsExercise2.java @@ -5,15 +5,11 @@ 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; +import static org.junit.Assert.assertTrue; public class StreamsExercise2 { // https://youtu.be/kxgo7Y4cdA8 Сергей Куксенко и Алексей Шипилёв — Через тернии к лямбдам, часть 1 @@ -24,23 +20,147 @@ public class StreamsExercise2 { // TODO class PersonEmployerPair + + class PersonEmployerPair { + private String employer; + private Person person; + + PersonEmployerPair(String employer, Person person) { + this.person = person; + this.employer = employer; + } + + Person getPerson() { + return person; + } + + String getEmployer() { + return employer; + } + } + + class PersonEmployerDuration extends PersonEmployerPair { + private int duration; + + PersonEmployerDuration(String employer, Person person, int duration) { + super(employer, person); + this.duration = duration; + } + + int getDuration() { + return duration; + } + } + @Test public void employersStuffLists() { - Map> employersStuffLists = null;// TODO - throw new UnsupportedOperationException(); + Map> employersStuffLists = + getEmployees().stream() + .flatMap(e -> + e.getJobHistory() + .stream() + .map(job -> new PersonEmployerPair(job.getEmployer(), e.getPerson())) + ) + .collect( + groupingBy( + PersonEmployerPair::getEmployer, + mapping( + PersonEmployerPair::getPerson, + toSet() + ) + ) + ); + + getEmployees().forEach( + employee -> { + employersStuffLists.forEach( + (employer, persons) -> { + persons.forEach(p -> + { + if (employee.getPerson().equals(p)) { + assertTrue(employee.getJobHistory() + .stream() + .anyMatch( + job -> job.getEmployer().equals(employer) + ) + ); + } + } + ); + } + ); + }); } @Test public void indexByFirstEmployer() { - Map> employeesIndex = null;// TODO - throw new UnsupportedOperationException(); + Map> employeesIndex = + getEmployees().stream() + .map(e -> + e.getJobHistory() + .stream() + .findFirst() + .map(job -> new PersonEmployerPair(job.getEmployer(), e.getPerson())) + ) + .filter(Optional::isPresent) + .map(Optional::get) + .collect( + groupingBy( + PersonEmployerPair::getEmployer, + mapping( + PersonEmployerPair::getPerson, + toSet() + ) + ) + ); + + getEmployees() + .forEach(employee -> + employeesIndex.forEach( + (employer, persons) -> { + persons.forEach(p -> + { + if (employee.getPerson().equals(p)) { + assertTrue( + employee.getJobHistory() + .get(0).getEmployer() + .equals(employer) + ); + } + } + ); + } + ) + ); } @Test public void greatestExperiencePerEmployer() { - Map employeesIndex = null;// TODO + Map employeesIndex = + getEmployees().stream() + .flatMap(e -> + e.getJobHistory() + .stream() + .map(job -> new PersonEmployerDuration( + job.getEmployer(), + e.getPerson(), + job.getDuration()) + ) + ) + .collect( + groupingBy( + PersonEmployerDuration::getEmployer, + collectingAndThen( + maxBy(Comparator.comparingInt(PersonEmployerDuration::getDuration)), + ped -> ped.get().getPerson() + ) + ) + ); + assertEquals(new Person("John", "Doe", 30), employeesIndex.get("abc")); + assertEquals(new Person("John", "Doe", 21), employeesIndex.get("yandex")); assertEquals(new Person("John", "White", 28), employeesIndex.get("epam")); + assertEquals(new Person("John", "Galt", 20), employeesIndex.get("google")); } @@ -55,7 +175,7 @@ private List getEmployees() { new Employee( new Person("John", "Doe", 21), Arrays.asList( - new JobHistoryEntry(4, "BA", "yandex"), + new JobHistoryEntry(7, "BA", "yandex"), new JobHistoryEntry(2, "QA", "epam"), new JobHistoryEntry(2, "dev", "abc") )), @@ -117,8 +237,12 @@ private List getEmployees() { new Person("Bob", "White", 31), Collections.singletonList( new JobHistoryEntry(6, "QA", "epam") - )) - ); + )), + new Employee( + new Person("Empty", "JobHistory", 666), + Collections.EMPTY_LIST + )); + } }