diff --git a/src/main/java/data/Generator.java b/src/main/java/data/Generator.java index cbd46ea..679bf70 100644 --- a/src/main/java/data/Generator.java +++ b/src/main/java/data/Generator.java @@ -60,7 +60,8 @@ public static Employee generateEmployee() { } public static List generateEmployeeList() { - // TODO - throw new UnsupportedOperationException(); + return Stream.generate(Generator::generateEmployee) + .limit(10) + .collect(toList()); } } diff --git a/src/test/java/part1/exercise/StreamsExercise1.java b/src/test/java/part1/exercise/StreamsExercise1.java index 02dd2da..e64cd5b 100755 --- a/src/test/java/part1/exercise/StreamsExercise1.java +++ b/src/test/java/part1/exercise/StreamsExercise1.java @@ -2,19 +2,18 @@ import data.Employee; 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.Collection; +import java.util.List; +import java.util.function.Predicate; 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.hamcrest.core.Is.is; +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertThat; public class StreamsExercise1 { // https://youtu.be/kxgo7Y4cdA8 Сергей Куксенко и Алексей Шипилёв — Через тернии к лямбдам, часть 1 @@ -22,17 +21,60 @@ public class StreamsExercise1 { // https://youtu.be/O8oN4KSZEXE Сергей Куксенко — Stream API, часть 1 // https://youtu.be/i0Jr2l3jrDA Сергей Куксенко — Stream API, часть 2 + private final static String EPAM = "epam"; + private final Predicate isEpam = s -> s.equals(EPAM); @Test public void getAllEpamEmployees() { - List epamEmployees = null;// TODO all persons with experience in epam - throw new UnsupportedOperationException(); + + List initialEmployees = generateEmployeeList(); + List actual = initialEmployees.stream() + .filter(employee -> + employee.getJobHistory().stream() + .map(JobHistoryEntry::getEmployer) + .anyMatch(isEpam)) + .collect(toList()); + + List expected = new ArrayList<>(); + for (Employee employee : initialEmployees) { + boolean isEpamEmloyee = false; + for (JobHistoryEntry entry : employee.getJobHistory()) { + if (isEpam.test(entry.getEmployer())) { + isEpamEmloyee = true; + } + } + if (isEpamEmloyee) expected.add(employee); + } + assertThat(actual, is(expected)); } @Test public void getEmployeesStartedFromEpam() { - List epamEmployees = null;// TODO all persons with first experience in epam - throw new UnsupportedOperationException(); + List initialList = generateEmployeeList(); + + List actualList = initialList.stream() + .filter(employee -> employee.getJobHistory() + .stream() + .findFirst() + .map(JobHistoryEntry::getEmployer) + .filter(isEpam) + .map(than -> true) + .orElse(false)) + .collect(toList()); + + List expectedList = new ArrayList<>(); + for (Employee employee : initialList) { + List jobHistory = employee.getJobHistory(); + boolean epamIsFirstEmployer = false; + if (!jobHistory.isEmpty()) { + String employer = jobHistory.get(0).getEmployer(); + epamIsFirstEmployer = isEpam.test(employer); + } + if (epamIsFirstEmployer) { + expectedList.add(employee); + } + } + assertThat(actualList, is(expectedList)); } @Test @@ -49,11 +91,14 @@ public void sumEpamDurations() { } } - // TODO - throw new UnsupportedOperationException(); + int actual = employees.stream() + .map(Employee::getJobHistory) + .flatMap(Collection::stream) + .filter(s -> isEpam.test(s.getEmployer())) + .mapToInt(JobHistoryEntry::getDuration) + .sum(); - // int result = ??? - // assertEquals(expected, result); + assertEquals(expected, actual); } } diff --git a/src/test/java/part1/exercise/StreamsExercise2.java b/src/test/java/part1/exercise/StreamsExercise2.java index 5be9d38..745366f 100755 --- a/src/test/java/part1/exercise/StreamsExercise2.java +++ b/src/test/java/part1/exercise/StreamsExercise2.java @@ -5,15 +5,15 @@ 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.function.Function; +import java.util.function.Predicate; import java.util.stream.Stream; -import static data.Generator.generateEmployeeList; +import static java.util.Comparator.comparingInt; import static java.util.stream.Collectors.*; -import static org.junit.Assert.assertEquals; +import static org.hamcrest.core.Is.is; +import static org.junit.Assert.assertThat; public class StreamsExercise2 { // https://youtu.be/kxgo7Y4cdA8 Сергей Куксенко и Алексей Шипилёв — Через тернии к лямбдам, часть 1 @@ -21,28 +21,136 @@ public class StreamsExercise2 { // https://youtu.be/O8oN4KSZEXE Сергей Куксенко — Stream API, часть 1 // https://youtu.be/i0Jr2l3jrDA Сергей Куксенко — Stream API, часть 2 + private final static Predicate hasJob = s -> !s.getJobHistory().isEmpty(); - // TODO class PersonEmployerPair + private static class PersonEmployerPair { + private final Person person; + private final String employee; + + private PersonEmployerPair(Person person, String employee) { + this.person = person; + this.employee = employee; + } + + Person getPerson() { + return person; + } + + String getEmployee() { + return employee; + } + } @Test public void employersStuffLists() { - Map> employersStuffLists = null;// TODO - throw new UnsupportedOperationException(); + List initialList = getEmployees(); + Map> actualMap = initialList.stream() + .flatMap(this::toPersonEmployerPairStream) + .collect(groupingBy(PersonEmployerPair::getEmployee, + mapping(PersonEmployerPair::getPerson, toList()))); + Map> expectedMap = new HashMap<>(); + + List employers = Arrays.asList("epam", "yandex", "google", "abc"); + for (String employer : employers) { + List personList = new ArrayList<>(); + for (Employee employee : initialList) { + if (employee.getJobHistory().stream() + .map(JobHistoryEntry::getEmployer) + .anyMatch(s -> s.equals(employer))) { + personList.add(employee.getPerson()); + } + } + expectedMap.put(employer, personList); + } + + assertThat(actualMap, is(expectedMap)); + } + + private Stream toPersonEmployerPairStream(Employee s) { + return s.getJobHistory().stream().map(g -> new PersonEmployerPair(s.getPerson(), g.getEmployer())); } @Test public void indexByFirstEmployer() { - Map> employeesIndex = null;// TODO - throw new UnsupportedOperationException(); + final List initialList = getEmployees(); + + final Function toPersonEmployerPair = + s -> new PersonEmployerPair(s.getPerson(), s.getJobHistory().get(0).getEmployer()); + + Map> actualMap = getEmployees().stream() + .filter(hasJob) + .map(toPersonEmployerPair) + .collect(groupingBy(PersonEmployerPair::getEmployee, mapping(PersonEmployerPair::getPerson, toList()))); + + Map> expectedMap = new HashMap<>(); + + List employers = Arrays.asList("epam", "yandex", "google", "abc"); + for (String employer : employers) { + List personList = new ArrayList<>(); + for (Employee employee : initialList) { + if (employee.getJobHistory().stream() + .findFirst() + .map(JobHistoryEntry::getEmployer) + .filter(s -> s.equals(employer)) + .map(s -> true) + .orElse(false)) { + personList.add(employee.getPerson()); + } + } + if (!personList.isEmpty()) expectedMap.put(employer, personList); + } + + assertThat(actualMap, is(expectedMap)); + } + + private static class PersonEmployerDuration { + private final Person person; + private final String employer; + private final int duration; + + private PersonEmployerDuration(Person person, String employer, int duration) { + this.person = person; + this.employer = employer; + this.duration = duration; + } + + Person getPerson() { + return person; + } + + String getEmployer() { + return employer; + } + + int getDuration() { + return duration; + } } @Test public void greatestExperiencePerEmployer() { - Map employeesIndex = null;// TODO - assertEquals(new Person("John", "White", 28), employeesIndex.get("epam")); + List initialList = getEmployees(); + Map employeesIndex = initialList.stream() + .filter(hasJob) + .flatMap(this::toPersonEmployerDurationStream) + .collect(groupingBy(PersonEmployerDuration::getEmployer, + collectingAndThen(maxBy(comparingInt(PersonEmployerDuration::getDuration)), + g -> g.get().getPerson()))); + + Map expected = new HashMap<>(); + + expected.put("abc", new Person("John", "Doe", 30)); + expected.put("yandex", new Person("John", "Doe", 21)); + expected.put("epam", new Person("John", "White", 28)); + expected.put("google", new Person("John", "Galt", 20)); + + assertThat(employeesIndex, is(expected)); } + private Stream toPersonEmployerDurationStream(Employee s) { + return s.getJobHistory().stream().map(j->new PersonEmployerDuration(s.getPerson(),j.getEmployer(),j.getDuration())); + } private List getEmployees() { return Arrays.asList( @@ -120,5 +228,4 @@ private List getEmployees() { )) ); } - }