Merge branch 'master' into BAEL-16633

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

@@ -0,0 +1,16 @@
+## Core Java 9
+
+This module contains articles about Java 9 core features
+
+### Relevant Articles:
+
+- [Method Handles in Java](http://www.baeldung.com/java-method-handles)
+- [Introduction to Chronicle Queue](http://www.baeldung.com/java-chronicle-queue)
+- [Optional orElse Optional](http://www.baeldung.com/java-optional-or-else-optional)
+- [Iterate Through a Range of Dates in Java](https://www.baeldung.com/java-iterate-date-range)
+- [Initialize a HashMap in Java](https://www.baeldung.com/java-initialize-hashmap)
+- [Immutable Set in Java](https://www.baeldung.com/java-immutable-set)
+- [Filtering a Stream of Optionals in Java](https://www.baeldung.com/java-filter-stream-of-optional)
+
+Note: also contains part of the code for the article
+[How to Filter a Collection in Java](https://www.baeldung.com/java-collection-filtering).

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

@@ -0,0 +1,73 @@
+<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-9</artifactId>
+    <version>0.2-SNAPSHOT</version>
+    <name>core-java-9</name>
+
+    <parent>
+        <groupId>com.baeldung</groupId>
+        <artifactId>parent-modules</artifactId>
+        <version>1.0.0-SNAPSHOT</version>
+        <relativePath>../../</relativePath>
+    </parent>
+
+    <dependencies>
+        <dependency>
+            <groupId>com.jayway.awaitility</groupId>
+            <artifactId>awaitility</artifactId>
+            <version>${awaitility.version}</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.assertj</groupId>
+            <artifactId>assertj-core</artifactId>
+            <version>${assertj.version}</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>com.google.guava</groupId>
+            <artifactId>guava</artifactId>
+            <version>${guava.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.junit.platform</groupId>
+            <artifactId>junit-platform-runner</artifactId>
+            <version>${junit.platform.version}</version>
+            <scope>test</scope>
+        </dependency>
+    </dependencies>
+
+    <build>
+        <finalName>core-java-9</finalName>
+        <plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-compiler-plugin</artifactId>
+                <version>${maven-compiler-plugin.version}</version>
+                <configuration>
+                    <source>${maven.compiler.source}</source>
+                    <target>${maven.compiler.target}</target>
+                </configuration>
+            </plugin>
+        </plugins>
+    </build>
+
+    <pluginRepositories>
+        <pluginRepository>
+            <id>apache.snapshots</id>
+            <url>http://repository.apache.org/snapshots/</url>
+        </pluginRepository>
+    </pluginRepositories>
+
+    <properties>
+        <!-- testing -->
+        <assertj.version>3.10.0</assertj.version>
+        <junit.platform.version>1.2.0</junit.platform.version>
+        <awaitility.version>1.7.0</awaitility.version>
+        <maven.compiler.source>1.9</maven.compiler.source>
+        <maven.compiler.target>1.9</maven.compiler.target>
+        <guava.version>25.1-jre</guava.version>
+    </properties>
+
+</project>

core-java-modules/core-java-9/src/main/java/com/baeldung/java9/language/stream/StreamsGroupingCollectionFilter.java

@@ -0,0 +1,27 @@
+package com.baeldung.java9.language.stream;
+
+import static java.util.stream.Collectors.filtering;
+import static java.util.stream.Collectors.groupingBy;
+import static java.util.stream.Collectors.toList;
+
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import java.util.function.Function;
+
+public class StreamsGroupingCollectionFilter {
+
+    static public Map<Integer, List<Integer>> findEvenNumbersAfterGroupingByQuantityOfDigits(Collection<Integer> baseCollection) {
+        Function<Integer, Integer> getQuantityOfDigits = item -> (int) Math.log10(item) + 1;
+
+        return baseCollection.stream()
+            .collect(groupingBy(getQuantityOfDigits, filtering(item -> item % 2 == 0, toList())));
+    }
+
+    static public Map<Integer, List<Integer>> findEvenNumbersBeforeGroupingByQuantityOfDigits(Collection<Integer> baseCollection) {
+
+        return baseCollection.stream()
+            .filter(item -> item % 2 == 0)
+            .collect(groupingBy(item -> (int) Math.log10(item) + 1, toList()));
+    }
+}

core-java-modules/core-java-9/src/main/java/com/baeldung/java9/maps/initialize/MapsInitializer.java

@@ -0,0 +1,33 @@
+package com.baeldung.java9.maps.initialize;
+
+import java.util.AbstractMap;
+import java.util.HashMap;
+import java.util.Map;
+
+public class MapsInitializer {
+
+    @SuppressWarnings("unused")
+    public void createMapWithMapOf() {
+        Map<String, String> emptyMap = Map.of();
+        Map<String, String> singletonMap = Map.of("key1", "value");
+        Map<String, String> map = Map.of("key1","value1", "key2", "value2");
+    }
+    
+    public void createMapWithMapEntries() {
+        Map<String, String> map = Map.ofEntries(
+            new AbstractMap.SimpleEntry<String, String>("name", "John"),
+            new AbstractMap.SimpleEntry<String, String>("city", "budapest"),
+            new AbstractMap.SimpleEntry<String, String>("zip", "000000"),
+            new AbstractMap.SimpleEntry<String, String>("home", "1231231231")
+            );
+    }
+    
+    @SuppressWarnings("unused")
+    public void createMutableMaps() {
+        Map<String, String> map = new HashMap<String, String> (Map.of("key1","value1", "key2", "value2"));
+        Map<String, String> map2 = new HashMap<String, String> ( Map.ofEntries(
+            new AbstractMap.SimpleEntry<String, String>("name", "John"),
+            new AbstractMap.SimpleEntry<String, String>("city", "budapest")));
+        
+    }
+}

core-java-modules/core-java-9/src/main/java/com/baeldung/java9/methodhandles/Book.java

@@ -0,0 +1,17 @@
+package com.baeldung.java9.methodhandles;
+
+public class Book {
+
+    String id;
+    String title;
+
+    public Book(String id, String title) {
+        this.id = id;
+        this.title = title;
+    }
+
+    @SuppressWarnings("unused")
+    private String formatBook() {
+        return id + " > " + title;
+    }
+}

core-java-modules/core-java-9/src/main/java/com/baeldung/java9/rangedates/DatesCollectionIteration.java

@@ -0,0 +1,24 @@
+package com.baeldung.java9.rangedates;
+
+import java.util.Collection;
+import java.util.Date;
+
+public class DatesCollectionIteration {
+
+    public void iteratingRangeOfDatesJava7(Collection<Date> dates) {
+
+        for (Date date : dates) {
+            processDate(date);
+        }
+    }
+
+    public void iteratingRangeOfDatesJava8(Collection<Date> dates) {
+        dates.stream()
+            .forEach(this::processDate);
+    }
+
+    private void processDate(Date date) {
+        System.out.println(date);
+    }
+
+}

core-java-modules/core-java-9/src/main/java/com/baeldung/java9/rangedates/RangeDatesIteration.java

@@ -0,0 +1,43 @@
+package com.baeldung.java9.rangedates;
+
+import java.time.LocalDate;
+import java.util.Calendar;
+import java.util.Date;
+
+public class RangeDatesIteration {
+
+    public void iterateBetweenDatesJava9(LocalDate startDate, LocalDate endDate) {
+
+        startDate.datesUntil(endDate)
+            .forEach(this::processDate);
+    }
+
+    public void iterateBetweenDatesJava8(LocalDate start, LocalDate end) {
+        for (LocalDate date = start; date.isBefore(end); date = date.plusDays(1)) {
+            processDate(date);
+        }
+    }
+
+    public void iterateBetweenDatesJava7(Date start, Date end) {
+        Date current = start;
+
+        while (current.before(end)) {
+            processDate(current);
+
+            Calendar calendar = Calendar.getInstance();
+            calendar.setTime(current);
+
+            calendar.add(Calendar.DATE, 1);
+
+            current = calendar.getTime();
+        }
+    }
+
+    private void processDate(LocalDate date) {
+        System.out.println(date);
+    }
+
+    private void processDate(Date date) {
+        System.out.println(date);
+    }
+}

core-java-modules/core-java-9/src/main/java/com/baeldung/java9/set/UnmodifiableSet.java

@@ -0,0 +1,44 @@
+package com.baeldung.java9.set;
+
+import com.google.common.collect.ImmutableSet;
+
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.Set;
+
+public class UnmodifiableSet {
+
+    public static void main(String[] args) {
+
+        Set<String> set = new HashSet<>();
+        set.add("Canada");
+        set.add("USA");
+
+        coreJDK(set);
+        guavaOf();
+        copyOf(set);
+        java9Of();
+    }
+
+    private static void java9Of() {
+        Set<String> immutable = Set.of("Canada", "USA");
+        System.out.println(immutable);
+    }
+
+    private static void guavaOf() {
+        Set<String> immutable = ImmutableSet.of("Canada", "USA");
+        System.out.println(immutable);
+    }
+
+    private static void copyOf(Set<String> set) {
+        Set<String> immutable = ImmutableSet.copyOf(set);
+        set.add("Costa Rica");
+        System.out.println(immutable);
+    }
+
+    private static void coreJDK(Set<String> set) {
+        Set<String> unmodifiableSet = Collections.unmodifiableSet(set);
+        set.add("Costa Rica");
+        System.out.println(unmodifiableSet);
+    }
+}

core-java-modules/core-java-9/src/main/java/com/baeldung/optionals/Optionals.java

@@ -0,0 +1,26 @@
+package com.baeldung.optionals;
+
+import java.util.Optional;
+
+public class Optionals {
+
+    public static <T> Optional<T> or(Optional<T> optional, Optional<T> fallback) {
+        return optional.isPresent() ? optional : fallback;
+    }
+
+    public static Optional<String> getName(Optional<String> name) {
+        return name.or(() -> getCustomMessage());
+    }
+
+    public static com.google.common.base.Optional<String> getOptionalGuavaName(com.google.common.base.Optional<String> name) {
+        return name.or(getCustomMessageGuava());
+    }
+
+    private static Optional<String> getCustomMessage() {
+        return Optional.of("Name not provided");
+    }
+
+    private static com.google.common.base.Optional<String> getCustomMessageGuava() {
+        return com.google.common.base.Optional.of("Name not provided");
+    }
+} 

core-java-modules/core-java-9/src/main/resources/logback.xml

@@ -0,0 +1,19 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<configuration>
+    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
+        <encoder>
+            <pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n
+            </pattern>
+        </encoder>
+    </appender>
+
+    <logger name="org.springframework" level="WARN" />
+    <logger name="org.springframework.transaction" level="WARN" />
+
+    <!-- in order to debug some marshalling issues, this needs to be TRACE -->
+    <logger name="org.springframework.web.servlet.mvc" level="WARN" />
+
+    <root level="INFO">
+        <appender-ref ref="STDOUT" />
+    </root>
+</configuration>

core-java-modules/core-java-9/src/test/java/com/baeldung/java9/Java9OptionalsStreamUnitTest.java

@@ -0,0 +1,61 @@
+package com.baeldung.java9;
+
+import static org.junit.Assert.assertEquals;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.Optional;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+import org.junit.Test;
+
+public class Java9OptionalsStreamUnitTest {
+
+    private static List<Optional<String>> listOfOptionals = Arrays.asList(Optional.empty(), Optional.of("foo"), Optional.empty(), Optional.of("bar"));
+
+    @Test
+    public void filterOutPresentOptionalsWithFilter() {
+        assertEquals(4, listOfOptionals.size());
+
+        List<String> filteredList = listOfOptionals.stream().filter(Optional::isPresent).map(Optional::get).collect(Collectors.toList());
+
+        assertEquals(2, filteredList.size());
+        assertEquals("foo", filteredList.get(0));
+        assertEquals("bar", filteredList.get(1));
+    }
+
+    @Test
+    public void filterOutPresentOptionalsWithFlatMap() {
+        assertEquals(4, listOfOptionals.size());
+
+        List<String> filteredList = listOfOptionals.stream().flatMap(o -> o.isPresent() ? Stream.of(o.get()) : Stream.empty()).collect(Collectors.toList());
+        assertEquals(2, filteredList.size());
+
+        assertEquals("foo", filteredList.get(0));
+        assertEquals("bar", filteredList.get(1));
+    }
+
+    @Test
+    public void filterOutPresentOptionalsWithFlatMap2() {
+        assertEquals(4, listOfOptionals.size());
+
+        List<String> filteredList = listOfOptionals.stream().flatMap(o -> o.map(Stream::of).orElseGet(Stream::empty)).collect(Collectors.toList());
+        assertEquals(2, filteredList.size());
+
+        assertEquals("foo", filteredList.get(0));
+        assertEquals("bar", filteredList.get(1));
+    }
+
+    @Test
+    public void filterOutPresentOptionalsWithJava9() {
+        assertEquals(4, listOfOptionals.size());
+
+        List<String> filteredList = listOfOptionals.stream().flatMap(Optional::stream).collect(Collectors.toList());
+
+        assertEquals(2, filteredList.size());
+        assertEquals("foo", filteredList.get(0));
+        assertEquals("bar", filteredList.get(1));
+    }
+
+}

core-java-modules/core-java-9/src/test/java/com/baeldung/java9/SetExamplesUnitTest.java

@@ -0,0 +1,38 @@
+package com.baeldung.java9;
+
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.Set;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+
+public class SetExamplesUnitTest {
+
+    @Test
+    public void testUnmutableSet() {
+        Set<String> strKeySet = Set.of("key1", "key2", "key3");
+        try {
+            strKeySet.add("newKey");
+        } catch (UnsupportedOperationException uoe) {
+        }
+        assertEquals(strKeySet.size(), 3);
+    }
+
+    @Test
+    public void testArrayToSet() {
+        Integer[] intArray = new Integer[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 };
+        Set<Integer> intSet = Set.of(intArray);
+        assertEquals(intSet.size(), intArray.length);
+    }
+
+    @Test(expected = UnsupportedOperationException.class)
+    public void testUnmodifiableSet() {
+        Set<String> set = new HashSet<>();
+        set.add("Canada");
+        set.add("USA");
+
+        Set<String> unmodifiableSet = Collections.unmodifiableSet(set);
+        unmodifiableSet.add("Costa Rica");
+    }
+}

core-java-modules/core-java-9/src/test/java/com/baeldung/java9/language/stream/CollectionFilterUnitTest.java

@@ -0,0 +1,51 @@
+package com.baeldung.java9.language.stream;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import org.junit.jupiter.api.Test;
+import org.junit.platform.runner.JUnitPlatform;
+import org.junit.runner.RunWith;
+
+@RunWith(JUnitPlatform.class)
+public class CollectionFilterUnitTest {
+
+    private static final Collection<Integer> BASE_INTEGER_COLLECTION = Arrays.asList(9, 12, 55, 56, 101, 115, 8002, 223, 2668, 19, 8);
+    private static final Map<Integer, List<Integer>> EXPECTED_EVEN_FILTERED_AFTER_GROUPING_MAP = createExpectedFilterAfterGroupingMap();
+    private static Map<Integer, List<Integer>> createExpectedFilterAfterGroupingMap() {
+        Map<Integer, List<Integer>> map = new HashMap<>();
+        map.put(1, Arrays.asList(8));
+        map.put(2, Arrays.asList(12, 56));
+        map.put(3, Collections.emptyList());
+        map.put(4, Arrays.asList(8002, 2668));
+        return map;
+
+    }
+
+    private static final Map<Integer, List<Integer>> EXPECTED_EVEN_FILTERED_BEFORE_GROUPING_MAP = createExpectedFilterBeforeGroupingMap();
+    private static Map<Integer, List<Integer>> createExpectedFilterBeforeGroupingMap() {
+        Map<Integer, List<Integer>> map = new HashMap<>();
+        map.put(1, Arrays.asList(8));
+        map.put(2, Arrays.asList(12, 56));
+        map.put(4, Arrays.asList(8002, 2668));
+        return map;
+
+    }
+
+    @Test
+    public void givenAStringCollection_whenFilteringFourLetterWords_thenObtainTheFilteredCollection() {
+        Map<Integer, List<Integer>> filteredAfterGroupingMap = StreamsGroupingCollectionFilter.findEvenNumbersAfterGroupingByQuantityOfDigits(BASE_INTEGER_COLLECTION);
+        Map<Integer, List<Integer>> filteredBeforeGroupingMap = StreamsGroupingCollectionFilter.findEvenNumbersBeforeGroupingByQuantityOfDigits(BASE_INTEGER_COLLECTION);
+
+        assertThat(filteredAfterGroupingMap).containsAllEntriesOf(EXPECTED_EVEN_FILTERED_AFTER_GROUPING_MAP);
+        assertThat(filteredBeforeGroupingMap).doesNotContainKey(3)
+            .containsAllEntriesOf(EXPECTED_EVEN_FILTERED_BEFORE_GROUPING_MAP);
+    }
+
+}

core-java-modules/core-java-9/src/test/java/com/baeldung/java9/methodhandles/MethodHandlesTest.java

@@ -0,0 +1,152 @@
+package com.baeldung.java9.methodhandles;
+
+import static org.hamcrest.CoreMatchers.is;
+import static org.junit.Assert.*;
+
+import java.lang.invoke.MethodHandle;
+import java.lang.invoke.MethodHandles;
+import java.lang.invoke.MethodType;
+import java.lang.invoke.WrongMethodTypeException;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.util.Arrays;
+import java.util.List;
+
+import org.junit.Test;
+
+/**
+ * Test case for the {@link MethodHandles} API
+ */
+public class MethodHandlesTest {
+
+    @Test
+    public void givenConcatMethodHandle_whenInvoked_thenCorrectlyConcatenated() throws Throwable {
+
+        MethodHandles.Lookup publicLookup = MethodHandles.publicLookup();
+        MethodType mt = MethodType.methodType(String.class, String.class);
+        MethodHandle concatMH = publicLookup.findVirtual(String.class, "concat", mt);
+
+        String output = (String) concatMH.invoke("Effective ", "Java");
+
+        assertEquals("Effective Java", output);
+    }
+
+    @Test
+    public void givenAsListMethodHandle_whenInvokingWithArguments_thenCorrectlyInvoked() throws Throwable {
+        MethodHandles.Lookup publicLookup = MethodHandles.publicLookup();
+        MethodType mt = MethodType.methodType(List.class, Object[].class);
+        MethodHandle asListMH = publicLookup.findStatic(Arrays.class, "asList", mt);
+
+        List<Integer> list = (List<Integer>) asListMH.invokeWithArguments(1, 2);
+
+        assertThat(Arrays.asList(1, 2), is(list));
+    }
+
+    @Test
+    public void givenConstructorMethodHandle_whenInvoked_thenObjectCreatedCorrectly() throws Throwable {
+        MethodHandles.Lookup publicLookup = MethodHandles.publicLookup();
+        MethodType mt = MethodType.methodType(void.class, String.class);
+        MethodHandle newIntegerMH = publicLookup.findConstructor(Integer.class, mt);
+
+        Integer integer = (Integer) newIntegerMH.invoke("1");
+
+        assertEquals(1, integer.intValue());
+    }
+
+    @Test
+    public void givenAFieldWithoutGetter_whenCreatingAGetter_thenCorrectlyInvoked() throws Throwable {
+        MethodHandles.Lookup lookup = MethodHandles.lookup();
+        MethodHandle getTitleMH = lookup.findGetter(Book.class, "title", String.class);
+
+        Book book = new Book("ISBN-1234", "Effective Java");
+
+        assertEquals("Effective Java", getTitleMH.invoke(book));
+    }
+
+    @Test
+    public void givenPrivateMethod_whenCreatingItsMethodHandle_thenCorrectlyInvoked() throws Throwable {
+        MethodHandles.Lookup lookup = MethodHandles.lookup();
+        Method formatBookMethod = Book.class.getDeclaredMethod("formatBook");
+        formatBookMethod.setAccessible(true);
+
+        MethodHandle formatBookMH = lookup.unreflect(formatBookMethod);
+
+        Book book = new Book("ISBN-123", "Java in Action");
+
+        assertEquals("ISBN-123 > Java in Action", formatBookMH.invoke(book));
+    }
+
+    @Test
+    public void givenReplaceMethod_whenUsingReflectionAndInvoked_thenCorrectlyReplaced() throws Throwable {
+        Method replaceMethod = String.class.getMethod("replace", char.class, char.class);
+
+        String string = (String) replaceMethod.invoke("jovo", 'o', 'a');
+
+        assertEquals("java", string);
+    }
+
+    @Test
+    public void givenReplaceMethodHandle_whenInvoked_thenCorrectlyReplaced() throws Throwable {
+        MethodHandles.Lookup publicLookup = MethodHandles.publicLookup();
+        MethodType mt = MethodType.methodType(String.class, char.class, char.class);
+        MethodHandle replaceMH = publicLookup.findVirtual(String.class, "replace", mt);
+
+        String replacedString = (String) replaceMH.invoke("jovo", Character.valueOf('o'), 'a');
+
+        assertEquals("java", replacedString);
+    }
+
+    @Test
+    public void givenReplaceMethodHandle_whenInvokingExact_thenCorrectlyReplaced() throws Throwable {
+        MethodHandles.Lookup lookup = MethodHandles.lookup();
+        MethodType mt = MethodType.methodType(String.class, char.class, char.class);
+        MethodHandle replaceMH = lookup.findVirtual(String.class, "replace", mt);
+
+        String s = (String) replaceMH.invokeExact("jovo", 'o', 'a');
+
+        assertEquals("java", s);
+    }
+
+    @Test
+    public void givenSumMethodHandle_whenInvokingExact_thenSumIsCorrect() throws Throwable {
+        MethodHandles.Lookup lookup = MethodHandles.lookup();
+        MethodType mt = MethodType.methodType(int.class, int.class, int.class);
+        MethodHandle sumMH = lookup.findStatic(Integer.class, "sum", mt);
+
+        int sum = (int) sumMH.invokeExact(1, 11);
+
+        assertEquals(12, sum);
+    }
+
+    @Test(expected = WrongMethodTypeException.class)
+    public void givenSumMethodHandleAndIncompatibleArguments_whenInvokingExact_thenException() throws Throwable {
+        MethodHandles.Lookup lookup = MethodHandles.lookup();
+        MethodType mt = MethodType.methodType(int.class, int.class, int.class);
+        MethodHandle sumMH = lookup.findStatic(Integer.class, "sum", mt);
+
+        sumMH.invokeExact(Integer.valueOf(1), 11);
+    }
+
+    @Test
+    public void givenSpreadedEqualsMethodHandle_whenInvokedOnArray_thenCorrectlyEvaluated() throws Throwable {
+        MethodHandles.Lookup publicLookup = MethodHandles.publicLookup();
+        MethodType mt = MethodType.methodType(boolean.class, Object.class);
+        MethodHandle equalsMH = publicLookup.findVirtual(String.class, "equals", mt);
+
+        MethodHandle methodHandle = equalsMH.asSpreader(Object[].class, 2);
+
+        assertTrue((boolean) methodHandle.invoke(new Object[] { "java", "java" }));
+        assertFalse((boolean) methodHandle.invoke(new Object[] { "java", "jova" }));
+    }
+
+    @Test
+    public void givenConcatMethodHandle_whenBindToAString_thenCorrectlyConcatenated() throws Throwable {
+        MethodHandles.Lookup publicLookup = MethodHandles.publicLookup();
+        MethodType mt = MethodType.methodType(String.class, String.class);
+        MethodHandle concatMH = publicLookup.findVirtual(String.class, "concat", mt);
+
+        MethodHandle bindedConcatMH = concatMH.bindTo("Hello ");
+
+        assertEquals("Hello World!", bindedConcatMH.invoke("World!"));
+    }
+}

core-java-modules/core-java-9/src/test/java/com/baeldung/java9/rangedates/DatesCollectionIterationUnitTest.java

@@ -0,0 +1,61 @@
+package com.baeldung.java9.rangedates;
+
+import java.time.LocalDate;
+import java.time.ZoneId;
+import java.time.temporal.ChronoUnit;
+import java.util.ArrayList;
+import java.util.Calendar;
+import java.util.Collection;
+import java.util.Date;
+import java.util.List;
+import java.util.stream.Collectors;
+
+import org.junit.Test;
+
+public class DatesCollectionIterationUnitTest {
+
+    private Collection<LocalDate> localDates = LocalDate.now()
+        .datesUntil(LocalDate.now()
+            .plus(10L, ChronoUnit.DAYS))
+        .collect(Collectors.toList());
+
+    private Collection<Date> dates = localDates.stream()
+        .map(localDate -> Date.from(localDate.atStartOfDay(ZoneId.systemDefault())
+            .toInstant()))
+        .collect(Collectors.toList());
+
+    @Test
+    public void givenIteratingListOfDatesJava7_WhenStartTodayAndEnding10DaysAhead() {
+        DatesCollectionIteration iterateInColleciton = new DatesCollectionIteration();
+        Calendar today = Calendar.getInstance();
+        Calendar next10Ahead = (Calendar) today.clone();
+        next10Ahead.add(Calendar.DATE, 10);
+
+        iterateInColleciton.iteratingRangeOfDatesJava7(createRangeDates(today.getTime(), next10Ahead.getTime()));
+    }
+
+    @Test
+    public void givenIteratingListOfDatesJava8_WhenStartTodayAndEnd10DaysAhead() {
+        DatesCollectionIteration iterateInColleciton = new DatesCollectionIteration();
+
+        iterateInColleciton.iteratingRangeOfDatesJava8(dates);
+    }
+
+    private List<Date> createRangeDates(Date start, Date end) {
+
+        List<Date> dates = new ArrayList<>();
+        Date current = start;
+
+        while (current.before(end)) {
+            dates.add(current);
+            
+            Calendar calendar = Calendar.getInstance();
+            calendar.setTime(current);
+            calendar.add(Calendar.DATE, 1);
+
+            current = calendar.getTime();
+        }
+
+        return dates;
+    }
+}

core-java-modules/core-java-9/src/test/java/com/baeldung/java9/rangedates/RangeDatesIterationUnitTest.java

@@ -0,0 +1,48 @@
+package com.baeldung.java9.rangedates;
+
+import java.time.LocalDate;
+import java.time.temporal.ChronoUnit;
+import java.util.Calendar;
+import java.util.Date;
+
+import org.junit.Test;
+
+public class RangeDatesIterationUnitTest {
+
+    @Test
+    public void givenIterateBetweenDatesJava9_WhenStartDateAsTodayAndEndDateAs10DaysAhead() {
+        LocalDate start = LocalDate.now();
+        LocalDate end = start.plus(10L, ChronoUnit.DAYS);
+
+        RangeDatesIteration iteration = new RangeDatesIteration();
+
+        iteration.iterateBetweenDatesJava9(start, end);
+    }
+
+    @Test
+    public void givenIterateBetweenDatesJava8_WhenStartDateAsTodayAndEndDateAs10DaysAhead() {
+        LocalDate start = LocalDate.now();
+        LocalDate end = start.plus(10L, ChronoUnit.DAYS);
+
+        RangeDatesIteration iteration = new RangeDatesIteration();
+
+        iteration.iterateBetweenDatesJava8(start, end);
+    }
+
+    @Test
+    public void givenIterateBetweenDatesJava7_WhenStartDateAsTodayAndEndDateAs10DaysAhead() {
+        Calendar today = Calendar.getInstance();
+        Calendar calendar = Calendar.getInstance();
+        calendar.clear();
+        calendar.set(today.get(Calendar.YEAR), today.get(Calendar.MONTH), today.get(Calendar.DATE));
+        Date start = calendar.getTime();
+
+        calendar.add(Calendar.DATE, 10);
+        Date end = calendar.getTime();
+
+        RangeDatesIteration iteration = new RangeDatesIteration();
+
+        iteration.iterateBetweenDatesJava7(start, end);
+    }
+
+}

core-java-modules/core-java-9/src/test/java/com/baeldung/optionals/OptionalsTest.java

@@ -0,0 +1,51 @@
+package com.baeldung.optionals;
+
+import static org.junit.Assert.assertEquals;
+
+import java.util.Optional;
+
+import org.junit.Test;
+
+public class OptionalsTest {
+
+    @Test
+    public void givenOptional_whenEmptyValue_thenCustomMessage() {
+        assertEquals(Optional.of("Name not provided"), Optionals.getName(Optional.ofNullable(null)));
+    }
+
+    @Test
+    public void givenOptional_whenValue_thenOptional() {
+        String name = "Filan Fisteku";
+        Optional<String> optionalString = Optional.ofNullable(name);
+        assertEquals(optionalString, Optionals.getName(optionalString));
+    }
+    
+    @Test
+    public void givenOptional_whenValue_thenOptionalGeneralMethod() {
+        String name = "Filan Fisteku";
+        String missingOptional = "Name not provided";
+        Optional<String> optionalString = Optional.ofNullable(name);
+        Optional<String> fallbackOptionalString = Optional.ofNullable(missingOptional);
+        assertEquals(optionalString, Optionals.or(optionalString, fallbackOptionalString));
+    }
+    
+    @Test
+    public void givenEmptyOptional_whenValue_thenOptionalGeneralMethod() {
+        String missingOptional = "Name not provided";
+        Optional<String> optionalString = Optional.empty();
+        Optional<String> fallbackOptionalString = Optional.ofNullable(missingOptional);
+        assertEquals(fallbackOptionalString, Optionals.or(optionalString, fallbackOptionalString));
+    }
+
+    @Test
+    public void givenGuavaOptional_whenInvoke_thenOptional() {
+        String name = "Filan Fisteku";
+        com.google.common.base.Optional<String> stringOptional = com.google.common.base.Optional.of(name);
+        assertEquals(stringOptional, Optionals.getOptionalGuavaName(stringOptional));
+    }
+
+    @Test
+    public void givenGuavaOptional_whenNull_thenDefaultText() {
+        assertEquals(com.google.common.base.Optional.of("Name not provided"), Optionals.getOptionalGuavaName(com.google.common.base.Optional.fromNullable(null)));
+    }
+} 

core-java-modules/core-java-9/src/test/resources/.gitignore

@@ -0,0 +1,13 @@
+*.class
+
+#folders#
+/target
+/neoDb*
+/data
+/src/main/webapp/WEB-INF/classes
+*/META-INF/*
+
+# Packaged files #
+*.jar
+*.war
+*.ear