From b6acd80038c70fbace1916289390c37a93691df2 Mon Sep 17 00:00:00 2001 From: wopqw Date: Mon, 3 Apr 2017 02:08:51 +0300 Subject: [PATCH 1/6] lambdas01Exercise --- .../part1/exercise/Lambdas01Exercise.java | 45 ++++++++++++++++--- 1 file changed, 40 insertions(+), 5 deletions(-) diff --git a/src/test/java/lambda/part1/exercise/Lambdas01Exercise.java b/src/test/java/lambda/part1/exercise/Lambdas01Exercise.java index 14cfc0d..ec41494 100644 --- a/src/test/java/lambda/part1/exercise/Lambdas01Exercise.java +++ b/src/test/java/lambda/part1/exercise/Lambdas01Exercise.java @@ -4,10 +4,12 @@ import data.Person; import org.junit.jupiter.api.Test; +import java.util.Comparator; import java.util.List; +import java.util.stream.Stream; -import static org.junit.jupiter.api.Assertions.assertArrayEquals; -import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.hamcrest.MatcherAssert.assertThat; +import static org.hamcrest.core.Is.is; class Lambdas01Exercise { @@ -21,11 +23,24 @@ void sortPersonsByAge() { // TODO use Arrays.sort - assertArrayEquals(persons, new Person[]{ +// Java 7 +// Arrays.sort(persons, new Comparator() { +// @Override +// public int compare(Person o1, Person o2) { +// return o1.getAge() - o2.getAge(); +// } +// }); + +// Java 8 + persons = Stream.of(persons) + .sorted(Comparator.comparing(Person::getAge)) + .toArray(Person[]::new); + + assertThat(persons, is(new Person[]{ new Person("name 3", "lastName 3", 20), new Person("name 2", "lastName 1", 30), new Person("name 1", "lastName 2", 40), - }); + })); } @Test @@ -40,6 +55,26 @@ void findFirstWithAge30() { // TODO use FluentIterable - assertEquals(person, new Person("name 1", "lastName 2", 30)); +// Java 7 +// final Optional personOptional = +// FluentIterable.from(persons) +// .firstMatch(new Predicate() { +// @Override +// public boolean apply(Person p) { +// return p.getAge() == 30; +// } +// }); +// +// if(personOptional.isPresent()) +// person = personOptional.get(); + +// Java 8 + person = persons.stream() + .filter(p -> p.getAge() ==30) + .findFirst() + .orElse(new Person("n","ln", 99999)); + + assertThat(person, is(new Person("name 1", "lastName 2", 30))); } } + From f9aa2b1af1ebe7de2640673710ceae51b57d8a74 Mon Sep 17 00:00:00 2001 From: wopqw Date: Mon, 3 Apr 2017 02:15:01 +0300 Subject: [PATCH 2/6] lambdas02Exercise --- build.gradle | 2 +- .../lambda/part1/exercise/Lambdas02Exercise.java | 12 ++++++++++++ 2 files changed, 13 insertions(+), 1 deletion(-) diff --git a/build.gradle b/build.gradle index 145d1e4..3e22b0b 100644 --- a/build.gradle +++ b/build.gradle @@ -27,6 +27,6 @@ dependencies { compileOnly 'org.projectlombok:lombok:+', 'edu.washington.cs.types.checker:checker-framework:+' - testCompile 'org.junit.jupiter:junit-jupiter-api:+', + testCompile 'org.junit.jupiter:junit-jupiter-api:5.0.0-M3', 'org.hamcrest:java-hamcrest:+' } diff --git a/src/test/java/lambda/part1/exercise/Lambdas02Exercise.java b/src/test/java/lambda/part1/exercise/Lambdas02Exercise.java index 8f47d34..5488155 100644 --- a/src/test/java/lambda/part1/exercise/Lambdas02Exercise.java +++ b/src/test/java/lambda/part1/exercise/Lambdas02Exercise.java @@ -1,9 +1,12 @@ package lambda.part1.exercise; +import com.google.common.base.Optional; +import com.google.common.collect.FluentIterable; import com.google.common.collect.ImmutableList; import data.Person; import org.junit.jupiter.api.Test; +import java.util.Arrays; import java.util.List; import static org.junit.jupiter.api.Assertions.assertArrayEquals; @@ -20,6 +23,8 @@ void sortPersonsByAge() { // TODO use Arrays.sort + Arrays.sort(persons, (p1, p2) -> p1.getAge() - p2.getAge()); + assertArrayEquals(persons, new Person[]{ new Person("name 3", "lastName 3", 20), new Person("name 2", "lastName 1", 30), @@ -39,6 +44,13 @@ void findFirstWithAge30() { // TODO use FluentIterable + final Optional personOptional = + FluentIterable.from(persons) + .firstMatch(p -> p.getAge() == 30); + + if(personOptional.isPresent()) + person = personOptional.get(); + assertEquals(person, new Person("name 1", "lastName 2", 30)); } } From 4d51d8cdcd2c61507ab5cff193181ee450dfb429 Mon Sep 17 00:00:00 2001 From: wopqw Date: Tue, 4 Apr 2017 22:10:10 +0300 Subject: [PATCH 3/6] mapHelper implemented --- .../java/lambda/part3/exercise/Mapping.java | 29 +++++++++++++++++-- 1 file changed, 26 insertions(+), 3 deletions(-) diff --git a/src/test/java/lambda/part3/exercise/Mapping.java b/src/test/java/lambda/part3/exercise/Mapping.java index 308faa8..8abc0b3 100644 --- a/src/test/java/lambda/part3/exercise/Mapping.java +++ b/src/test/java/lambda/part3/exercise/Mapping.java @@ -30,7 +30,11 @@ public List getList() { // [T1, T2, T3] -> (T -> R) -> [R1, R2, R3] public MapHelper map(Function f) { // TODO - throw new UnsupportedOperationException(); + final ArrayList rs = new ArrayList<>(); + for (T t: list) { + rs.add(f.apply(t)); + } + return new MapHelper(rs); } // [T] -> (T -> [R]) -> [R] @@ -47,6 +51,22 @@ public MapHelper flatMap(Function> f) { } } + private List addOneYear(List jobHistory) { + + return new MapHelper<>(jobHistory) + .map(jobHistoryEntry -> jobHistoryEntry + .withDuration(jobHistoryEntry.getDuration()+1)) + .getList(); + } + + private List replace(List jobHistory) { + + return new MapHelper<>(jobHistory) + .map(jobHistoryEntry -> jobHistoryEntry + .withPosition(jobHistoryEntry.getPosition().equals("qa") ? "QA" : "dev")) + .getList(); + } + @Test void mapping() { final List employees = @@ -70,15 +90,18 @@ void mapping() { new JobHistoryEntry(5, "qa", "epam") )) ); - final List mappedEmployees = new MapHelper<>(employees) + .map(e -> e.withPerson(e.getPerson().withFirstName("John"))) + .map(e -> e.withJobHistory(addOneYear(e.getJobHistory()))) + .map(e -> e.withJobHistory(replace(e.getJobHistory()))) + .getList(); /* .map(TODO) // change name to John .map(e -> e.withPerson(e.getPerson().withFirstName("John"))) .map(TODO) // add 1 year to experience duration .map(e -> e.withJobHistory(addOneYear(e.getJobHistory()))) .map(TODO) // replace qa with QA * */ - .getList(); + final List expectedResult = Arrays.asList( From 8ce9fef70818af66d7308cbd948085acdb925263 Mon Sep 17 00:00:00 2001 From: wopqw Date: Wed, 5 Apr 2017 01:16:50 +0300 Subject: [PATCH 4/6] lazyMapHelper implemented --- .../java/lambda/part3/exercise/Mapping.java | 22 ++++++++++--------- 1 file changed, 12 insertions(+), 10 deletions(-) diff --git a/src/test/java/lambda/part3/exercise/Mapping.java b/src/test/java/lambda/part3/exercise/Mapping.java index 8abc0b3..ba24ed0 100644 --- a/src/test/java/lambda/part3/exercise/Mapping.java +++ b/src/test/java/lambda/part3/exercise/Mapping.java @@ -131,7 +131,13 @@ void mapping() { private static class LazyMapHelper { + private final List list; + private final Function function; + LazyMapHelper(List list, Function function) { + + this.list = list; + this.function = function; } static LazyMapHelper from(List list) { @@ -139,13 +145,11 @@ static LazyMapHelper from(List list) { } List force() { - // TODO - throw new UnsupportedOperationException(); + return new MapHelper<>(list).map(function).getList(); } public LazyMapHelper map(Function f) { - // TODO - throw new UnsupportedOperationException(); + return new LazyMapHelper<>(list, function.andThen(f)); } } @@ -213,12 +217,10 @@ void lazy_mapping() { final List mappedEmployees = LazyMapHelper.from(employees) - /* - .map(TODO) // change name to John - .map(TODO) // add 1 year to experience duration - .map(TODO) // replace qa with QA - * */ - .force(); + .map(e -> e.withPerson(e.getPerson().withFirstName("John"))) + .map(e -> e.withJobHistory(addOneYear(e.getJobHistory()))) + .map(e -> e.withJobHistory(replace(e.getJobHistory()))) + .force(); final List expectedResult = Arrays.asList( From 3fec33515b3a5fff7a48520ab2e9de809ced79be Mon Sep 17 00:00:00 2001 From: wopqw Date: Mon, 10 Apr 2017 02:03:06 +0300 Subject: [PATCH 5/6] ArrowNotation is done --- .../part2/exercise/ArrowNotationExercise.java | 23 +++++++++++++------ 1 file changed, 16 insertions(+), 7 deletions(-) diff --git a/src/test/java/lambda/part2/exercise/ArrowNotationExercise.java b/src/test/java/lambda/part2/exercise/ArrowNotationExercise.java index 75b1d82..05322ca 100644 --- a/src/test/java/lambda/part2/exercise/ArrowNotationExercise.java +++ b/src/test/java/lambda/part2/exercise/ArrowNotationExercise.java @@ -1,19 +1,21 @@ package lambda.part2.exercise; +import static org.junit.jupiter.api.Assertions.assertEquals; + import data.Person; import org.junit.jupiter.api.Test; +import java.util.StringJoiner; import java.util.function.BiFunction; +import java.util.function.BiPredicate; import java.util.function.Function; -import static org.junit.jupiter.api.Assertions.assertEquals; - class ArrowNotationExercise { @Test void getAge() { // Person -> Integer - final Function getAge = null; // TODO + final Function getAge = Person::getAge; // TODO assertEquals(Integer.valueOf(33), getAge.apply(new Person("", "", 33))); } @@ -22,9 +24,9 @@ void getAge() { void compareAges() { // TODO use BiPredicate // compareAges: (Person, Person) -> boolean + BiPredicate compareAges = (p1, p2) -> p1.getAge() == p2.getAge(); - throw new UnsupportedOperationException("Not implemented"); - //assertEquals(true, compareAges.test(new Person("a", "b", 22), new Person("c", "d", 22))); + assertEquals(true, compareAges.test(new Person("a", "b", 22), new Person("c", "d", 22))); } // TODO @@ -37,11 +39,18 @@ void compareAges() { @Test void getAgeOfPersonWithTheLongestFullName() { // Person -> String - final Function getFullName = null; // TODO + final Function getFullName = + p -> new StringJoiner(p.getFirstName()) + .add(p.getLastName()) + .toString(); // (Person, Person) -> Integer // TODO use ageOfPersonWithTheLongestFullName(getFullName) - final BiFunction ageOfPersonWithTheLongestFullName = null; + final BiFunction ageOfPersonWithTheLongestFullName = + (p1, p2) -> getFullName.apply(p1).length()>getFullName.apply(p2).length() + ?p1.getAge() + :p2.getAge(); + assertEquals( Integer.valueOf(1), From 027e5a04ea174807865b25c7d9d8fa4af922c6de Mon Sep 17 00:00:00 2001 From: wopqw Date: Mon, 10 Apr 2017 02:15:56 +0300 Subject: [PATCH 6/6] FunctionCombination is done --- .../exercise/FunctionCombinationExercise.java | 31 ++++++++----------- .../java/lambda/part3/exercise/Mapping.java | 24 +++++++++++--- 2 files changed, 33 insertions(+), 22 deletions(-) diff --git a/src/test/java/lambda/part2/exercise/FunctionCombinationExercise.java b/src/test/java/lambda/part2/exercise/FunctionCombinationExercise.java index bf2494d..b6df12f 100644 --- a/src/test/java/lambda/part2/exercise/FunctionCombinationExercise.java +++ b/src/test/java/lambda/part2/exercise/FunctionCombinationExercise.java @@ -1,12 +1,12 @@ package lambda.part2.exercise; +import static org.junit.jupiter.api.Assertions.assertEquals; + import data.Person; import org.junit.jupiter.api.Test; import java.util.function.Predicate; -import static org.junit.jupiter.api.Assertions.assertEquals; - class FunctionCombinationExercise { @Test @@ -22,19 +22,14 @@ void personHasNotEmptyLastNameAndFirstName0() { // TODO // negate1: (Person -> boolean) -> (Person -> boolean) private Predicate negate1(Predicate test) { - return p -> { - // TODO - throw new UnsupportedOperationException(); - }; + // TODO + return p -> test.negate().test(p); } // TODO // validateFirstNameAndLastName: (Person -> boolean, Person -> boolean) -> (Person -> boolean) private Predicate validateFirstNameAndLastName(Predicate t1, Predicate t2) { - return p -> { - // TODO - throw new UnsupportedOperationException(); - }; + return p -> t1.and(t2).test(p); } @Test @@ -56,14 +51,14 @@ void personHasNotEmptyLastNameAndFirstName1() { // negate: (T -> boolean) -> (T -> boolean) private Predicate negate(Predicate test) { // TODO - throw new UnsupportedOperationException(); + return t -> test.negate().test(t); } // TODO // and: (T -> boolean, T -> boolean) -> (T -> boolean) private Predicate and(Predicate t1, Predicate t2) { // TODO - throw new UnsupportedOperationException(); + return t -> t1.and(t2).test(t); } @Test @@ -71,10 +66,10 @@ void personHasNotEmptyLastNameAndFirstName2() { final Predicate hasEmptyFirstName = p -> p.getFirstName().isEmpty(); final Predicate hasEmptyLastName = p -> p.getLastName().isEmpty(); - final Predicate validateFirstName = null; // TODO use negate - final Predicate validateLastName = null; // TODO use negate + final Predicate validateFirstName = negate(hasEmptyFirstName); // TODO use negate + final Predicate validateLastName = negate(hasEmptyLastName); // TODO use negate - final Predicate validate = null; // TODO use and + final Predicate validate = validateFirstName.and(validateLastName); // TODO use and assertEquals(true, validate.test(new Person("a", "b", 0))); assertEquals(false, validate.test(new Person("", "b", 0))); @@ -86,10 +81,10 @@ void personHasNotEmptyLastNameAndFirstName3() { final Predicate hasEmptyFirstName = p -> p.getFirstName().isEmpty(); final Predicate hasEmptyLastName = p -> p.getLastName().isEmpty(); - final Predicate validateFirstName = null; // TODO use Predicate::negate - final Predicate validateLastName = null; // TODO use Predicate::negate + final Predicate validateFirstName = hasEmptyFirstName.negate(); // TODO use Predicate::negate + final Predicate validateLastName = hasEmptyLastName.negate(); // TODO use Predicate::negate - final Predicate validate = null; // TODO use Predicate::and + final Predicate validate = validateFirstName.and(validateLastName); // TODO use Predicate::and assertEquals(true, validate.test(new Person("a", "b", 0))); assertEquals(false, validate.test(new Person("", "b", 0))); diff --git a/src/test/java/lambda/part3/exercise/Mapping.java b/src/test/java/lambda/part3/exercise/Mapping.java index ba24ed0..452672d 100644 --- a/src/test/java/lambda/part3/exercise/Mapping.java +++ b/src/test/java/lambda/part3/exercise/Mapping.java @@ -1,5 +1,7 @@ package lambda.part3.exercise; +import static org.junit.jupiter.api.Assertions.assertEquals; + import data.Employee; import data.JobHistoryEntry; import data.Person; @@ -11,8 +13,6 @@ import java.util.List; import java.util.function.Function; -import static org.junit.jupiter.api.Assertions.assertEquals; - class Mapping { private static class MapHelper { @@ -156,15 +156,24 @@ public LazyMapHelper map(Function f) { private static class LazyFlatMapHelper { + private final List list; + private final Function> function; + public LazyFlatMapHelper(List list, Function> function) { + this.list = list; + this.function = function; } public static LazyFlatMapHelper from(List list) { - throw new UnsupportedOperationException(); + return new LazyFlatMapHelper<>(list, Arrays::asList); } public List force() { // TODO +// final ArrayList rs = new ArrayList<>(); +// return list.stream() +// .map(function) +// .forEach(r -> rs.add(r)); throw new UnsupportedOperationException(); } @@ -180,12 +189,19 @@ public LazyFlatMapHelper map(Function f) { // (R -> R2) -> (R -> [R2]) private Function> rR2TorListR2(Function f) { - throw new UnsupportedOperationException(); + return (R r) -> Collections.singletonList(f.apply(r)); } // TODO * LazyFlatMapHelper flatMap(Function> f) { throw new UnsupportedOperationException(); +// return new LazyFlatMapHelper +// (list, +// (T t) -> function.apply(t).forEach(r -> r) +// ) + + +// .collect(ArrayList::new, List::add, List::addAll)); } }