Merge branch 'master' of https://github.com/JonCook/tutorials

core-java-modules/core-java-optional/README.md

@@ -0,0 +1,8 @@
+=========
+
+## Core Java Optional
+
+### Relevant Articles: 
+- [Java Optional as Return Type](https://www.baeldung.com/java-optional-return)
+- [Guide To Java 8 Optional](https://www.baeldung.com/java-optional)
+- [Java Optional – orElse() vs orElseGet()](https://www.baeldung.com/java-optional-or-else-vs-or-else-get)

core-java-modules/core-java-optional/pom.xml

@@ -0,0 +1,52 @@
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+    <artifactId>core-java-optional</artifactId>
+    <version>0.1.0-SNAPSHOT</version>
+    <packaging>jar</packaging>
+    <name>core-java-optional</name>
+	
+    <parent>
+        <groupId>com.baeldung.core-java-modules</groupId>
+        <artifactId>core-java-modules</artifactId>
+        <version>1.0.0-SNAPSHOT</version>
+    </parent>
+  
+    <dependencies>
+        <dependency>
+            <groupId>org.hibernate</groupId>
+            <artifactId>hibernate-core</artifactId>
+            <version>${hibernate.core.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>com.h2database</groupId>
+            <artifactId>h2</artifactId>
+            <version>${h2.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>com.fasterxml.jackson.core</groupId>
+            <artifactId>jackson-databind</artifactId>
+            <version>${jackson.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.openjdk.jmh</groupId>
+            <artifactId>jmh-core</artifactId>
+            <version>${jmh-core.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.openjdk.jmh</groupId>
+            <artifactId>jmh-generator-annprocess</artifactId>
+            <version>${jmh-generator.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.openjdk.jmh</groupId>
+            <artifactId>jmh-generator-bytecode</artifactId>
+            <version>${jmh-generator.version}</version>
+        </dependency>
+    </dependencies>
+
+    <properties>
+        <hibernate.core.version>5.4.0.Final</hibernate.core.version>
+        <jmh-core.version>1.19</jmh-core.version>
+        <jmh-generator.version>1.19</jmh-generator.version>
+    </properties>
+</project>

core-java-modules/core-java-optional/src/main/java/com/baeldung/optional/Modem.java

@@ -0,0 +1,13 @@
+package com.baeldung.optional;
+
+public class Modem {
+    private Double price;
+
+    public Modem(Double price) {
+        this.price = price;
+    }
+
+    public Double getPrice() {
+        return price;
+    }
+}

core-java-modules/core-java-optional/src/main/java/com/baeldung/optional/OrElseAndOrElseGet.java

@@ -0,0 +1,34 @@
+package com.baeldung.optional;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.Optional;
+import java.util.Random;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class OrElseAndOrElseGet {
+
+    public static List<String> names = Arrays.asList("John", "Jones", "Kelly", "Cristina", "Raven");
+
+    private static final Logger LOG = LoggerFactory.getLogger(OrElseAndOrElseGet.class);
+
+    public String getRandomName() {
+        LOG.info("getRandomName() method - start");
+        Random random = new Random();
+        int index = random.nextInt(5);
+        LOG.info("getRandomName() method - end");
+        return names.get(index);
+    }
+
+    public String getNameUsingOrElse(String name) {
+        return Optional.ofNullable(name)
+            .orElse(getRandomName());
+    }
+
+    public String getNameUsingOrElseGet(String name) {
+        return Optional.ofNullable(name)
+            .orElseGet(() -> getRandomName());
+    }
+}

core-java-modules/core-java-optional/src/main/java/com/baeldung/optional/OrElseAndOrElseGetBenchmarkRunner.java

@@ -0,0 +1,37 @@
+package com.baeldung.optional;
+
+import java.io.IOException;
+import java.util.concurrent.TimeUnit;
+
+import org.openjdk.jmh.annotations.Benchmark;
+import org.openjdk.jmh.annotations.BenchmarkMode;
+import org.openjdk.jmh.annotations.Fork;
+import org.openjdk.jmh.annotations.Mode;
+import org.openjdk.jmh.annotations.OutputTimeUnit;
+import org.openjdk.jmh.annotations.Scope;
+import org.openjdk.jmh.annotations.State;
+import org.openjdk.jmh.runner.RunnerException;
+
+@Fork(1)
+@State(Scope.Benchmark)
+@BenchmarkMode(Mode.AverageTime)
+@OutputTimeUnit(TimeUnit.NANOSECONDS)
+public class OrElseAndOrElseGetBenchmarkRunner {
+
+    private OrElseAndOrElseGet orElsevsOrElseGet = new OrElseAndOrElseGet();
+
+    public static void main(String[] args) throws RunnerException, IOException {
+        org.openjdk.jmh.Main.main(args);
+    }
+
+    @Benchmark
+    public String orElseBenchmark() {
+        return orElsevsOrElseGet.getNameUsingOrElse("baeldung");
+    }
+
+    @Benchmark
+    public String orElseGetBenchmark() {
+        return orElsevsOrElseGet.getNameUsingOrElseGet("baeldung");
+    }
+
+}

core-java-modules/core-java-optional/src/main/java/com/baeldung/optional/Person.java

@@ -0,0 +1,39 @@
+package com.baeldung.optional;
+
+import java.util.Optional;
+
+public class Person {
+    private String name;
+    private int age;
+    private String password;
+
+    public Person(String name, int age) {
+        this.name = name;
+        this.age = age;
+    }
+
+    public Optional<String> getName() {
+        return Optional.ofNullable(name);
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public Optional<Integer> getAge() {
+        return Optional.ofNullable(age);
+    }
+
+    public void setAge(int age) {
+        this.age = age;
+    }
+
+    public void setPassword(String password) {
+        this.password = password;
+    }
+
+    public Optional<String> getPassword() {
+        return Optional.ofNullable(password);
+    }
+
+}

core-java-modules/core-java-optional/src/main/java/com/baeldung/optionalReturnType/HandleOptionalTypeExample.java

@@ -0,0 +1,41 @@
+package com.baeldung.optionalReturnType;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Optional;
+
+public class HandleOptionalTypeExample {
+    static Map<String, User> usersByName = new HashMap();
+    static {
+        User user1 = new User();
+        user1.setUserId(1l);
+        user1.setFirstName("baeldung");
+        usersByName.put("baeldung", user1);
+    }
+
+    public static void main(String[] args) {
+        changeUserName("baeldung", "baeldung-new");
+        changeUserName("user", "user-new");
+    }
+
+    public static void changeUserName(String oldFirstName, String newFirstName) {
+        Optional<User> userOpt = findUserByName(oldFirstName);
+        if (userOpt.isPresent()) {
+            User user = userOpt.get();
+            user.setFirstName(newFirstName);
+
+            System.out.println("user with name " + oldFirstName + " is changed to " + user.getFirstName());
+        } else {
+            // user is missing
+            System.out.println("user with name " + oldFirstName + " is not found.");
+        }
+    }
+
+    public static Optional<User> findUserByName(String name) {
+        // look up the user in the database, the user object below could be null
+        User user = usersByName.get(name);
+        Optional<User> opt = Optional.ofNullable(user);
+
+        return opt;
+    }
+}

core-java-modules/core-java-optional/src/main/java/com/baeldung/optionalReturnType/OptionalToJsonExample.java

@@ -0,0 +1,19 @@
+package com.baeldung.optionalReturnType;
+
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.databind.ObjectMapper;
+
+public class OptionalToJsonExample {
+    public static void main(String[] args) {
+        UserOptional user = new UserOptional();
+        user.setUserId(1l);
+        user.setFirstName("Bael Dung");
+
+        ObjectMapper om = new ObjectMapper();
+        try {
+            System.out.print("user in json is:" + om.writeValueAsString(user));
+        } catch (JsonProcessingException e) {
+            e.printStackTrace();
+        }
+    }
+}

core-java-modules/core-java-optional/src/main/java/com/baeldung/optionalReturnType/PersistOptionalTypeExample.java

@@ -0,0 +1,26 @@
+package com.baeldung.optionalReturnType;
+
+import java.util.Optional;
+
+import javax.persistence.EntityManager;
+import javax.persistence.EntityManagerFactory;
+import javax.persistence.Persistence;
+
+public class PersistOptionalTypeExample {
+    static String persistenceUnit = "com.baeldung.optionalReturnType";
+    static EntityManagerFactory emf = Persistence.createEntityManagerFactory(persistenceUnit);
+
+    static EntityManager entityManager = emf.createEntityManager();
+
+    // to run this app, uncomment the follow line in META-INF/persistence.xml
+    // <class>com.baeldung.optionalReturnType.UserOptionalField</class>
+    public static void main(String[] args) {
+        UserOptionalField user1 = new UserOptionalField();
+        user1.setUserId(1l);
+        user1.setFirstName(Optional.of("Bael Dung"));
+        entityManager.persist(user1);
+
+        UserOptional user2 = entityManager.find(UserOptional.class, 1l);
+        System.out.print("User2.firstName:" + user2.getFirstName());
+    }
+}

core-java-modules/core-java-optional/src/main/java/com/baeldung/optionalReturnType/PersistOptionalTypeExample2.java

@@ -0,0 +1,22 @@
+package com.baeldung.optionalReturnType;
+
+import javax.persistence.EntityManager;
+import javax.persistence.EntityManagerFactory;
+import javax.persistence.Persistence;
+
+public class PersistOptionalTypeExample2 {
+    static String persistenceUnit = "com.baeldung.optionalReturnType";
+    static EntityManagerFactory emf = Persistence.createEntityManagerFactory(persistenceUnit);
+
+    static EntityManager em = emf.createEntityManager();
+
+    public static void main(String[] args) {
+        UserOptional user1 = new UserOptional();
+        user1.setUserId(1l);
+        user1.setFirstName("Bael Dung");
+        em.persist(user1);
+
+        UserOptional user2 = em.find(UserOptional.class, 1l);
+        System.out.print("User2.firstName:" + user2.getFirstName());
+    }
+}

core-java-modules/core-java-optional/src/main/java/com/baeldung/optionalReturnType/PersistUserExample.java

@@ -0,0 +1,22 @@
+package com.baeldung.optionalReturnType;
+
+import javax.persistence.EntityManager;
+import javax.persistence.EntityManagerFactory;
+import javax.persistence.Persistence;
+
+public class PersistUserExample {
+    static String persistenceUnit = "com.baeldung.optionalReturnType";
+    static EntityManagerFactory emf = Persistence.createEntityManagerFactory(persistenceUnit);
+
+    static EntityManager em = emf.createEntityManager();
+
+    public static void main(String[] args) {
+        User user1 = new User();
+        user1.setUserId(1l);
+        user1.setFirstName("Bael Dung");
+        em.persist(user1);
+
+        User user2 = em.find(User.class, 1l);
+        System.out.print("User2.firstName:" + user2.getFirstName());
+    }
+}

core-java-modules/core-java-optional/src/main/java/com/baeldung/optionalReturnType/SerializeOptionalTypeExample.java

@@ -0,0 +1,41 @@
+package com.baeldung.optionalReturnType;
+
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.ObjectOutputStream;
+import java.util.Optional;
+
+public class SerializeOptionalTypeExample {
+    public static void main(String[] args) {
+        User user1 = new User();
+        user1.setUserId(1l);
+        user1.setFirstName("baeldung");
+
+        serializeObject(user1, "user1.ser");
+
+        UserOptionalField user2 = new UserOptionalField();
+        user2.setUserId(1l);
+        user2.setFirstName(Optional.of("baeldung"));
+
+        serializeObject(user2, "user2.ser");
+
+    }
+
+    public static void serializeObject(Object object, String fileName) {
+        // Serialization
+        try {
+            FileOutputStream file = new FileOutputStream(fileName);
+            ObjectOutputStream out = new ObjectOutputStream(file);
+
+            out.writeObject(object);
+
+            out.close();
+            file.close();
+
+            System.out.println("Object " + object.toString() + " has been serialized to file " + fileName);
+
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+    }
+}

core-java-modules/core-java-optional/src/main/java/com/baeldung/optionalReturnType/User.java

@@ -0,0 +1,31 @@
+package com.baeldung.optionalReturnType;
+
+import java.io.Serializable;
+
+import javax.persistence.Entity;
+import javax.persistence.Id;
+
+@Entity
+public class User implements Serializable {
+    @Id
+    private long userId;
+
+    private String firstName;
+
+    public long getUserId() {
+        return userId;
+    }
+
+    public void setUserId(long userId) {
+        this.userId = userId;
+    }
+
+    public String getFirstName() {
+        return firstName;
+    }
+
+    public void setFirstName(String firstName) {
+        this.firstName = firstName;
+    }
+
+}

core-java-modules/core-java-optional/src/main/java/com/baeldung/optionalReturnType/UserOptional.java

@@ -0,0 +1,35 @@
+package com.baeldung.optionalReturnType;
+
+import java.io.Serializable;
+import java.util.Optional;
+
+import javax.persistence.Column;
+import javax.persistence.Entity;
+import javax.persistence.Id;
+
+@Entity
+public class UserOptional implements Serializable {
+    @Id
+    private long userId;
+
+    @Column(nullable = true)
+    private String firstName;
+
+    public long getUserId() {
+        return userId;
+    }
+
+    public void setUserId(long userId) {
+        this.userId = userId;
+    }
+
+    public Optional<String> getFirstName() {
+        return Optional.ofNullable(firstName);
+    }
+
+    public void setFirstName(String firstName) {
+        this.firstName = firstName;
+        Optional.ofNullable(firstName);
+    }
+
+}

core-java-modules/core-java-optional/src/main/java/com/baeldung/optionalReturnType/UserOptionalField.java

@@ -0,0 +1,31 @@
+package com.baeldung.optionalReturnType;
+
+import java.io.Serializable;
+import java.util.Optional;
+
+import javax.persistence.Entity;
+import javax.persistence.Id;
+
+@Entity
+public class UserOptionalField implements Serializable {
+    @Id
+    private long userId;
+
+    private Optional<String> firstName;
+
+    public long getUserId() {
+        return userId;
+    }
+
+    public void setUserId(long userId) {
+        this.userId = userId;
+    }
+
+    public Optional<String> getFirstName() {
+        return firstName;
+    }
+
+    public void setFirstName(Optional<String> firstName) {
+        this.firstName = firstName;
+    }
+}

core-java-modules/core-java-optional/src/test/java/com/baeldung/java8/optional/OptionalChainingUnitTest.java

@@ -0,0 +1,110 @@
+package com.baeldung.java8.optional;
+
+import org.junit.Before;
+import org.junit.Test;
+
+import java.util.Optional;
+import java.util.function.Supplier;
+import java.util.stream.Stream;
+
+import static org.junit.Assert.*;
+
+public class OptionalChainingUnitTest {
+
+    private boolean getEmptyEvaluated;
+    private boolean getHelloEvaluated;
+    private boolean getByeEvaluated;
+
+    @Before
+    public void setUp() {
+        getEmptyEvaluated = false;
+        getHelloEvaluated = false;
+        getByeEvaluated = false;
+    }
+
+    @Test
+    public void givenThreeOptionals_whenChaining_thenFirstNonEmptyIsReturned() {
+        Optional<String> found = Stream.of(getEmpty(), getHello(), getBye())
+                .filter(Optional::isPresent)
+                .map(Optional::get)
+                .findFirst();
+
+        assertEquals(getHello(), found);
+    }
+
+    @Test
+    public void givenTwoEmptyOptionals_whenChaining_thenEmptyOptionalIsReturned() {
+        Optional<String> found = Stream.of(getEmpty(), getEmpty())
+                .filter(Optional::isPresent)
+                .map(Optional::get)
+                .findFirst();
+
+        assertFalse(found.isPresent());
+    }
+
+    @Test
+    public void givenTwoEmptyOptionals_whenChaining_thenDefaultIsReturned() {
+        String found = Stream.<Supplier<Optional<String>>>of(
+                () -> createOptional("empty"),
+                () -> createOptional("empty")
+        )
+                .map(Supplier::get)
+                .filter(Optional::isPresent)
+                .map(Optional::get)
+                .findFirst()
+                .orElseGet(() -> "default");
+
+        assertEquals("default", found);
+    }
+
+    @Test
+    public void givenThreeOptionals_whenChaining_thenFirstNonEmptyIsReturnedAndRestNotEvaluated() {
+        Optional<String> found = Stream.<Supplier<Optional<String>>>of(this::getEmpty, this::getHello, this::getBye)
+                .map(Supplier::get)
+                .filter(Optional::isPresent)
+                .map(Optional::get)
+                .findFirst();
+
+        assertTrue(this.getEmptyEvaluated);
+        assertTrue(this.getHelloEvaluated);
+        assertFalse(this.getByeEvaluated);
+        assertEquals(getHello(), found);
+    }
+
+    @Test
+    public void givenTwoOptionalsReturnedByOneArgMethod_whenChaining_thenFirstNonEmptyIsReturned() {
+        Optional<String> found = Stream.<Supplier<Optional<String>>>of(
+                () -> createOptional("empty"),
+                () -> createOptional("hello")
+        )
+                .map(Supplier::get)
+                .filter(Optional::isPresent)
+                .map(Optional::get)
+                .findFirst();
+
+        assertEquals(createOptional("hello"), found);
+    }
+
+    private Optional<String> getEmpty() {
+        this.getEmptyEvaluated = true;
+        return Optional.empty();
+    }
+
+    private Optional<String> getHello() {
+        this.getHelloEvaluated = true;
+        return Optional.of("hello");
+    }
+
+    private Optional<String> getBye() {
+        this.getByeEvaluated = true;
+        return Optional.of("bye");
+    }
+
+    private Optional<String> createOptional(String input) {
+        if (input == null || "".equals(input) || "empty".equals(input)) {
+            return Optional.empty();
+        }
+
+        return Optional.of(input);
+    }
+}

core-java-modules/core-java-optional/src/test/java/com/baeldung/java8/optional/OptionalUnitTest.java

@@ -0,0 +1,273 @@
+package com.baeldung.java8.optional;
+
+import com.baeldung.optional.Modem;
+import com.baeldung.optional.Person;
+import org.junit.Test;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.NoSuchElementException;
+import java.util.Optional;
+
+import static org.junit.Assert.*;
+
+public class OptionalUnitTest {
+
+    private static final Logger LOG = LoggerFactory.getLogger(OptionalUnitTest.class);
+
+    // creating Optional
+    @Test
+    public void whenCreatesEmptyOptional_thenCorrect() {
+        Optional<String> empty = Optional.empty();
+        assertFalse(empty.isPresent());
+    }
+
+    @Test
+    public void givenNonNull_whenCreatesNonNullable_thenCorrect() {
+        String name = "baeldung";
+        Optional<String> opt = Optional.of(name);
+        assertTrue(opt.isPresent());
+    }
+
+    @Test(expected = NullPointerException.class)
+    public void givenNull_whenThrowsErrorOnCreate_thenCorrect() {
+        String name = null;
+        Optional.of(name);
+    }
+
+    @Test
+    public void givenNonNull_whenCreatesOptional_thenCorrect() {
+        String name = "baeldung";
+        Optional<String> opt = Optional.of(name);
+        assertTrue(opt.isPresent());
+    }
+
+    @Test
+    public void givenNonNull_whenCreatesNullable_thenCorrect() {
+        String name = "baeldung";
+        Optional<String> opt = Optional.ofNullable(name);
+        assertTrue(opt.isPresent());
+    }
+
+    @Test
+    public void givenNull_whenCreatesNullable_thenCorrect() {
+        String name = null;
+        Optional<String> opt = Optional.ofNullable(name);
+        assertFalse(opt.isPresent());
+    }
+    // Checking Value With isPresent()
+
+    @Test
+    public void givenOptional_whenIsPresentWorks_thenCorrect() {
+        Optional<String> opt = Optional.of("Baeldung");
+        assertTrue(opt.isPresent());
+
+        opt = Optional.ofNullable(null);
+        assertFalse(opt.isPresent());
+    }
+
+    // Condition Action With ifPresent()
+    @Test
+    public void givenOptional_whenIfPresentWorks_thenCorrect() {
+        Optional<String> opt = Optional.of("baeldung");
+        opt.ifPresent(name -> LOG.debug("{}", name.length()));
+    }
+
+    // returning Value With get()
+    @Test
+    public void givenOptional_whenGetsValue_thenCorrect() {
+        Optional<String> opt = Optional.of("baeldung");
+        String name = opt.get();
+        assertEquals("baeldung", name);
+    }
+
+    @Test(expected = NoSuchElementException.class)
+    public void givenOptionalWithNull_whenGetThrowsException_thenCorrect() {
+        Optional<String> opt = Optional.ofNullable(null);
+        String name = opt.get();
+    }
+
+    // Conditional Return With filter()
+    @Test
+    public void whenOptionalFilterWorks_thenCorrect() {
+        Integer year = 2016;
+        Optional<Integer> yearOptional = Optional.of(year);
+        boolean is2016 = yearOptional.filter(y -> y == 2016)
+            .isPresent();
+        assertTrue(is2016);
+        boolean is2017 = yearOptional.filter(y -> y == 2017)
+            .isPresent();
+        assertFalse(is2017);
+    }
+
+    @Test
+    public void whenFiltersWithoutOptional_thenCorrect() {
+        assertTrue(priceIsInRange1(new Modem(10.0)));
+        assertFalse(priceIsInRange1(new Modem(9.9)));
+        assertFalse(priceIsInRange1(new Modem(null)));
+        assertFalse(priceIsInRange1(new Modem(15.5)));
+        assertFalse(priceIsInRange1(null));
+
+    }
+
+    @Test
+    public void whenFiltersWithOptional_thenCorrect() {
+        assertTrue(priceIsInRange2(new Modem(10.0)));
+        assertFalse(priceIsInRange2(new Modem(9.9)));
+        assertFalse(priceIsInRange2(new Modem(null)));
+        assertFalse(priceIsInRange2(new Modem(15.5)));
+        assertFalse(priceIsInRange1(null));
+    }
+
+    public boolean priceIsInRange1(Modem modem) {
+        boolean isInRange = false;
+        if (modem != null && modem.getPrice() != null && (modem.getPrice() >= 10 && modem.getPrice() <= 15)) {
+            isInRange = true;
+        }
+        return isInRange;
+    }
+
+    public boolean priceIsInRange2(Modem modem2) {
+        return Optional.ofNullable(modem2)
+            .map(Modem::getPrice)
+            .filter(p -> p >= 10)
+            .filter(p -> p <= 15)
+            .isPresent();
+    }
+
+    // Transforming Value With map()
+    @Test
+    public void givenOptional_whenMapWorks_thenCorrect() {
+        List<String> companyNames = Arrays.asList("paypal", "oracle", "", "microsoft", "", "apple");
+        Optional<List<String>> listOptional = Optional.of(companyNames);
+
+        int size = listOptional.map(List::size)
+            .orElse(0);
+        assertEquals(6, size);
+    }
+
+    @Test
+    public void givenOptional_whenMapWorks_thenCorrect2() {
+        String name = "baeldung";
+        Optional<String> nameOptional = Optional.of(name);
+
+        int len = nameOptional.map(String::length)
+            .orElse(0);
+        assertEquals(8, len);
+    }
+
+    @Test
+    public void givenOptional_whenMapWorksWithFilter_thenCorrect() {
+        String password = " password ";
+        Optional<String> passOpt = Optional.of(password);
+        boolean correctPassword = passOpt.filter(pass -> pass.equals("password"))
+            .isPresent();
+        assertFalse(correctPassword);
+
+        correctPassword = passOpt.map(String::trim)
+            .filter(pass -> pass.equals("password"))
+            .isPresent();
+        assertTrue(correctPassword);
+    }
+
+    // Transforming Value With flatMap()
+    @Test
+    public void givenOptional_whenFlatMapWorks_thenCorrect2() {
+        Person person = new Person("john", 26);
+        Optional<Person> personOptional = Optional.of(person);
+
+        Optional<Optional<String>> nameOptionalWrapper = personOptional.map(Person::getName);
+        Optional<String> nameOptional = nameOptionalWrapper.orElseThrow(IllegalArgumentException::new);
+        String name1 = nameOptional.orElseThrow(IllegalArgumentException::new);
+        assertEquals("john", name1);
+
+        String name = personOptional.flatMap(Person::getName)
+            .orElseThrow(IllegalArgumentException::new);
+        assertEquals("john", name);
+    }
+
+    @Test
+    public void givenOptional_whenFlatMapWorksWithFilter_thenCorrect() {
+        Person person = new Person("john", 26);
+        person.setPassword("password");
+        Optional<Person> personOptional = Optional.of(person);
+
+        String password = personOptional.flatMap(Person::getPassword)
+            .filter(cleanPass -> cleanPass.equals("password"))
+            .orElseThrow(IllegalArgumentException::new);
+        assertEquals("password", password);
+    }
+
+    // Default Value With orElse
+    @Test
+    public void whenOrElseWorks_thenCorrect() {
+        String nullName = null;
+        String name = Optional.ofNullable(nullName)
+            .orElse("john");
+        assertEquals("john", name);
+    }
+
+    // Default Value With orElseGet
+    @Test
+    public void whenOrElseGetWorks_thenCorrect() {
+        String nullName = null;
+        String name = Optional.ofNullable(nullName)
+            .orElseGet(() -> "john");
+        assertEquals("john", name);
+
+    }
+
+    @Test
+    public void whenOrElseGetAndOrElseOverlap_thenCorrect() {
+        String text = null;
+        LOG.debug("Using orElseGet:");
+        String defaultText = Optional.ofNullable(text)
+            .orElseGet(this::getMyDefault);
+        assertEquals("Default Value", defaultText);
+
+        LOG.debug("Using orElse:");
+        defaultText = Optional.ofNullable(text)
+            .orElse(getMyDefault());
+        assertEquals("Default Value", defaultText);
+    }
+
+    @Test
+    public void whenOrElseGetAndOrElseDiffer_thenCorrect() {
+        String text = "Text present";
+        LOG.debug("Using orElseGet:");
+        String defaultText = Optional.ofNullable(text)
+            .orElseGet(this::getMyDefault);
+        assertEquals("Text present", defaultText);
+
+        LOG.debug("Using orElse:");
+        defaultText = Optional.ofNullable(text)
+            .orElse(getMyDefault());
+        assertEquals("Text present", defaultText);
+    }
+
+    // Exceptions With orElseThrow
+    @Test(expected = IllegalArgumentException.class)
+    public void whenOrElseThrowWorks_thenCorrect() {
+        String nullName = null;
+        String name = Optional.ofNullable(nullName)
+            .orElseThrow(IllegalArgumentException::new);
+    }
+
+    public String getMyDefault() {
+        LOG.debug("Getting default value...");
+        return "Default Value";
+    }
+    
+//    Uncomment code when code base is compatiable with Java 11     
+//    @Test
+//    public void givenAnEmptyOptional_thenIsEmptyBehavesAsExpected() {
+//        Optional<String> opt = Optional.of("Baeldung");
+//        assertFalse(opt.isEmpty());
+//     
+//        opt = Optional.ofNullable(null);
+//        assertTrue(opt.isEmpty());
+//    }
+
+}

core-java-modules/core-java-optional/src/test/java/com/baeldung/java8/optional/OrElseAndOrElseGetUnitTest.java

@@ -0,0 +1,44 @@
+package com.baeldung.java8.optional;
+
+import org.junit.Test;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import static org.junit.Assert.*;
+
+import com.baeldung.optional.OrElseAndOrElseGet;
+
+public class OrElseAndOrElseGetUnitTest {
+
+    private OrElseAndOrElseGet orElsevsOrElseGet = new OrElseAndOrElseGet();
+
+    private static final Logger LOG = LoggerFactory.getLogger(OrElseAndOrElseGetUnitTest.class);
+
+    @Test
+    public void givenNonEmptyOptional_whenOrElseUsed_thenGivenStringReturned() {
+        LOG.info("In givenNonEmptyOptional_whenOrElseUsed_thenGivenStringReturned()");
+        String name = orElsevsOrElseGet.getNameUsingOrElse("baeldung");
+        assertEquals(name, "baeldung");
+    }
+
+    @Test
+    public void givenEmptyOptional_whenOrElseUsed_thenRandomStringReturned() {
+        LOG.info("In givenEmptyOptional_whenOrElseUsed_thenRandomStringReturned()");
+        String name = orElsevsOrElseGet.getNameUsingOrElse(null);
+        assertTrue(orElsevsOrElseGet.names.contains(name));
+    }
+
+    @Test
+    public void givenNonEmptyOptional_whenOrElseGetUsed_thenGivenStringReturned() {
+        LOG.info("In givenNonEmptyOptional_whenOrElseGetUsed_thenGivenStringReturned()");
+        String name = orElsevsOrElseGet.getNameUsingOrElseGet("baeldung");
+        assertEquals(name, "baeldung");
+    }
+
+    @Test
+    public void givenEmptyOptional_whenOrElseGetUsed_thenRandomStringReturned() {
+        LOG.info("In givenEmptyOptional_whenOrElseGetUsed_thenRandomStringReturned()");
+        String name = orElsevsOrElseGet.getNameUsingOrElseGet(null);
+        assertTrue(orElsevsOrElseGet.names.contains(name));
+    }
+}