From 07f6e1c16b3f76c23835fcfed899929d1f5eb092 Mon Sep 17 00:00:00 2001
From: "JurassicSPb[credential]" <Jurassic5@yandex.ru>
Date: Mon, 26 Jun 2017 12:32:49 +0300
Subject: [PATCH 1/2] + optional methods

---
 src/test/java/option/OptionalExample.java | 112 +++++++++++++++++++++-
 1 file changed, 110 insertions(+), 2 deletions(-)

diff --git a/src/test/java/option/OptionalExample.java b/src/test/java/option/OptionalExample.java
index db18993..86bdd20 100644
--- a/src/test/java/option/OptionalExample.java
+++ b/src/test/java/option/OptionalExample.java
@@ -5,6 +5,8 @@
 import java.util.Optional;
 import java.util.concurrent.ThreadLocalRandom;
 import java.util.function.Function;
+import java.util.function.Predicate;
+import java.util.function.Supplier;
 
 import static org.junit.Assert.assertEquals;
 
@@ -50,9 +52,115 @@ public void map() {
         assertEquals(expected, actual);
     }
 
+    @Test
+    public void flatMap() {
+        final Optional<String> o1 = getOptional();
+
+        final Function<String, Optional<Integer>> getLength = s -> Optional.of(s.length());
+
+        final Optional<Integer> expected = o1.flatMap(getLength);
+
+        final Optional<Integer> actual;
+        if (o1.isPresent()) {
+            actual = getLength.apply(o1.get());
+        } else {
+            actual = Optional.empty();
+        }
+
+        assertEquals(expected, actual);
+    }
+
+    @Test
+    public void filter() {
+        final Optional<String> o1 = getOptional();
+
+        final Predicate<String> getLength = s -> s.length() > 0;
+
+        final Optional<String> expected = o1.filter(getLength);
+
+        final Optional<String> actual;
+        if (o1.isPresent()) {
+            actual = getLength.test(o1.get()) ? o1 : Optional.empty();
+        } else {
+            actual = Optional.empty();
+        }
+
+        assertEquals(expected, actual);
+    }
+
+    @Test
+    public void orElse() {
+        final Optional<String> o1 = getOptional();
+
+        String qqq = "qqq";
+
+        final Optional<String> expected = Optional.of(o1.orElse(qqq));
+
+        final Optional<String> actual;
+        if (o1.isPresent()) {
+            actual = Optional.of(o1.get());
+        } else {
+            actual = Optional.of(qqq);
+        }
+
+        assertEquals(expected, actual);
+    }
+
+    @Test
+    public void orElseGet() {
+        final Optional<String> o1 = getOptional();
+
+        String qqq = "qqq";
+        Supplier<String> stringSupplier = () -> qqq;
+
+        final Optional<String> expected = Optional.of(o1.orElseGet(stringSupplier));
+
+        final Optional<String> actual;
+        if (o1.isPresent()) {
+            actual = Optional.of(o1.get());
+        } else {
+            actual = Optional.of(stringSupplier.get());
+        }
+
+        assertEquals(expected, actual);
+    }
+
+    @Test
+    public void orElseThrow() {
+        final Optional<String> o1 = getOptional();
+        boolean flag = false;
+        boolean flag2 = false;
+
+        Supplier<NullPointerException> exceptionSupplier = NullPointerException::new;
+        String expected = "";
+        String actual = "";
+
+        try {
+            expected = o1.orElseThrow(exceptionSupplier);
+        } catch (NullPointerException e) {
+            flag = true;
+        }
+
+        try {
+            if (o1.isPresent()) {
+                actual = o1.get();
+            } else {
+                throw new NullPointerException();
+            }
+        } catch (NullPointerException e) {
+            flag2 = true;
+        }
+        assertEquals(flag, flag2);
+
+        if (!flag) {
+            assertEquals(expected, actual);
+        }
+    }
+
     private Optional<String> getOptional() {
         return ThreadLocalRandom.current().nextBoolean()
-            ? Optional.empty()
-            : Optional.of("abc");
+                ? Optional.empty()
+                : Optional.of("abc");
     }
 }
+

From 8fb8946eed5c703f41b83ccd0f6ffc6498558736 Mon Sep 17 00:00:00 2001
From: "JurassicSPb[credential]" <Jurassic5@yandex.ru>
Date: Mon, 26 Jun 2017 14:36:56 +0300
Subject: [PATCH 2/2] + zipMap

---
 src/test/java/option/OptionalExample.java | 24 +++++++++++++++++++++++
 1 file changed, 24 insertions(+)

diff --git a/src/test/java/option/OptionalExample.java b/src/test/java/option/OptionalExample.java
index 86bdd20..2127d47 100644
--- a/src/test/java/option/OptionalExample.java
+++ b/src/test/java/option/OptionalExample.java
@@ -4,6 +4,7 @@
 
 import java.util.Optional;
 import java.util.concurrent.ThreadLocalRandom;
+import java.util.function.BiFunction;
 import java.util.function.Function;
 import java.util.function.Predicate;
 import java.util.function.Supplier;
@@ -162,5 +163,28 @@ private Optional<String> getOptional() {
                 ? Optional.empty()
                 : Optional.of("abc");
     }
+
+    public static <T1, T2, R> Optional<R> zipMap(Optional<T1> o1, Optional<T2> o2, BiFunction<T1, T2, R> f) {
+        return o1.flatMap(t1 -> o2.map(t2 -> f.apply(t1, t2)));
+    }
+
+    @Test
+    public void zipMapTest(){
+
+        Optional <String> str = Optional.of("abc");
+        Optional <Integer> number = Optional.of(123);
+        BiFunction<String, Integer, String> function = (s, i) -> s + i;
+
+        Optional<String> zipMap1 = zipMap(str, number, function);
+
+        Optional<String> result = Optional.of("");
+
+        if (zipMap1.isPresent()){
+            result = Optional.of(zipMap1.get());
+        }
+
+        assertEquals(result.get(), "abc123");
+    }
+
 }