[BAEL-9555] - Created a core-java-modules folder

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

@@ -0,0 +1,7 @@
+
+### Relevant Articles: 
+
+- [Java 10 LocalVariable Type-Inference](http://www.baeldung.com/java-10-local-variable-type-inference)
+- [Guide to Java 10](http://www.baeldung.com/java-10-overview)
+- [Copy a List to Another List in Java](http://www.baeldung.com/java-copy-list-to-another)
+- [Deep Dive Into the New Java JIT Compiler – Graal](https://www.baeldung.com/graal-java-jit-compiler)

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

@@ -0,0 +1,37 @@
+<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>
+    <groupId>com.baeldung</groupId>
+    <artifactId>core-java-10</artifactId>
+    <version>0.1.0-SNAPSHOT</version>
+    <name>core-java-10</name>
+    <packaging>jar</packaging>
+    <url>http://maven.apache.org</url>
+
+    <parent>
+        <groupId>com.baeldung</groupId>
+        <artifactId>parent-modules</artifactId>
+        <version>1.0.0-SNAPSHOT</version>
+        <relativePath>../../</relativePath>
+    </parent>
+
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-compiler-plugin</artifactId>
+                <version>${maven-compiler-plugin.version}</version>
+                <configuration>
+                    <source>${maven.compiler.source.version}</source>
+                    <target>${maven.compiler.target.version}</target>
+                </configuration>
+            </plugin>
+        </plugins>
+    </build>
+
+    <properties>
+        <maven.compiler.source.version>10</maven.compiler.source.version>
+        <maven.compiler.target.version>10</maven.compiler.target.version>
+    </properties>
+
+</project>

core-java-modules/core-java-10/src/main/java/com/baeldung/App.java

@@ -0,0 +1,13 @@
+package com.baeldung;
+
+/**
+ * Hello world!
+ *
+ */
+public class App 
+{
+    public static void main( String[] args )
+    {
+        System.out.println( "Hello World!" );
+    }
+}

core-java-modules/core-java-10/src/main/java/com/baeldung/graal/CountUppercase.java

@@ -0,0 +1,25 @@
+package com.baeldung.graal;
+
+public class CountUppercase {
+    static final int ITERATIONS = Math.max(Integer.getInteger("iterations", 1), 1);
+
+    public static void main(String[] args) {
+        String sentence = String.join(" ", args);
+        for (int iter = 0; iter < ITERATIONS; iter++) {
+            if (ITERATIONS != 1) System.out.println("-- iteration " + (iter + 1) + " --");
+            long total = 0, start = System.currentTimeMillis(), last = start;
+            for (int i = 1; i < 10_000_000; i++) {
+                total += sentence
+                  .chars()
+                  .filter(Character::isUpperCase)
+                  .count();
+                if (i % 1_000_000 == 0) {
+                    long now = System.currentTimeMillis();
+                    System.out.printf("%d (%d ms)%n", i / 1_000_000, now - last);
+                    last = now;
+                }
+            }
+            System.out.printf("total: %d (%d ms)%n", total, System.currentTimeMillis() - start);
+        }
+    }
+}

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

@@ -0,0 +1,13 @@
+<?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>
+
+    <root level="INFO">
+        <appender-ref ref="STDOUT" />
+    </root>
+</configuration>

core-java-modules/core-java-10/src/test/java/com/baeldung/AppTest.java

@@ -0,0 +1,38 @@
+package com.baeldung;
+
+import junit.framework.Test;
+import junit.framework.TestCase;
+import junit.framework.TestSuite;
+
+/**
+ * Unit test for simple App.
+ */
+public class AppTest 
+    extends TestCase
+{
+    /**
+     * Create the test case
+     *
+     * @param testName name of the test case
+     */
+    public AppTest( String testName )
+    {
+        super( testName );
+    }
+
+    /**
+     * @return the suite of tests being tested
+     */
+    public static Test suite()
+    {
+        return new TestSuite( AppTest.class );
+    }
+
+    /**
+     * Rigourous Test :-)
+     */
+    public void testApp()
+    {
+        assertTrue( true );
+    }
+}

core-java-modules/core-java-10/src/test/java/com/baeldung/java10/Java10FeaturesUnitTest.java

@@ -0,0 +1,61 @@
+package com.baeldung.java10;
+
+import static org.hamcrest.CoreMatchers.is;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.stream.Collectors;
+
+import org.junit.Before;
+import org.junit.Test;
+
+public class Java10FeaturesUnitTest {
+
+    private List<Integer> someIntList;
+    
+    @Before
+    public void setup() {
+        someIntList = new ArrayList<>();
+        
+        someIntList.add(1);
+        someIntList.add(2);
+        someIntList.add(3);
+    }
+
+    @Test
+    public void whenVarInitWithString_thenGetStringTypeVar() {
+        var message = "Hello, Java 10";
+        assertTrue(message instanceof String);
+    }
+
+    @Test
+    public void whenVarInitWithAnonymous_thenGetAnonymousType() {
+        var obj = new Object() {};
+        assertFalse(obj.getClass().equals(Object.class));
+    }
+
+    @Test(expected = UnsupportedOperationException.class)
+    public void whenModifyCopyOfList_thenThrowsException() {
+        List<Integer> copyList = List.copyOf(someIntList);
+        copyList.add(4);
+    }
+
+    @Test(expected = UnsupportedOperationException.class)
+    public void whenModifyToUnmodifiableList_thenThrowsException() {
+        List<Integer> evenList = someIntList.stream()
+          .filter(i -> i % 2 == 0)
+          .collect(Collectors.toUnmodifiableList());
+        evenList.add(4);
+    }
+
+    @Test
+    public void whenListContainsInteger_OrElseThrowReturnsInteger() {
+        Integer firstEven = someIntList.stream()
+          .filter(i -> i % 2 == 0)
+          .findFirst()
+          .orElseThrow();
+        is(firstEven).equals(Integer.valueOf(2));
+    }
+}

core-java-modules/core-java-10/src/test/java/com/baeldung/java10/list/CopyListServiceUnitTest.java

@@ -0,0 +1,14 @@
+package com.baeldung.java10.list;
+
+import org.junit.Test;
+
+import java.util.Arrays;
+import java.util.List;
+
+public class CopyListServiceUnitTest {
+
+    @Test(expected = UnsupportedOperationException.class)
+    public void whenModifyCopyOfList_thenThrowsException() {
+        List<Integer> copyList = List.copyOf(Arrays.asList(1, 2, 3, 4));
+    }
+}

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

@@ -0,0 +1,9 @@
+### Relevant articles
+
+- [Java 11 Single File Source Code](https://www.baeldung.com/java-single-file-source-code)
+- [Java 11 Local Variable Syntax for Lambda Parameters](https://www.baeldung.com/java-var-lambda-params)
+- [Java 11 String API Additions](https://www.baeldung.com/java-11-string-api)
+- [Java 11 Nest Based Access Control](https://www.baeldung.com/java-nest-based-access-control)
+- [Exploring the New HTTP Client in Java 9 and 11](https://www.baeldung.com/java-9-http-client)
+- [An Introduction to Epsilon GC: A No-Op Experimental Garbage Collector](https://www.baeldung.com/jvm-epsilon-gc-garbage-collector)
+- [Guide to jlink](https://www.baeldung.com/jlink)

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

@@ -0,0 +1,46 @@
+<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>
+    <groupId>com.baeldung</groupId>
+    <artifactId>core-java-11</artifactId>
+    <version>0.1.0-SNAPSHOT</version>
+    <name>core-java-11</name>
+    <packaging>jar</packaging>
+    <url>http://maven.apache.org</url>
+
+    <parent>
+        <groupId>com.baeldung</groupId>
+        <artifactId>parent-modules</artifactId>
+        <version>1.0.0-SNAPSHOT</version>
+        <relativePath>../../</relativePath>
+    </parent>
+
+    <dependencies>
+        <dependency>
+            <groupId>com.google.guava</groupId>
+            <artifactId>guava</artifactId>
+            <version>${guava.version}</version>
+        </dependency>
+    </dependencies>
+
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-compiler-plugin</artifactId>
+                <version>${maven-compiler-plugin.version}</version>
+                <configuration>
+                    <source>${maven.compiler.source.version}</source>
+                    <target>${maven.compiler.target.version}</target>
+                </configuration>
+            </plugin>
+        </plugins>
+    </build>
+
+    <properties>
+        <maven.compiler.source.version>11</maven.compiler.source.version>
+        <maven.compiler.target.version>11</maven.compiler.target.version>
+        <guava.version>27.1-jre</guava.version>
+    </properties>
+
+</project>

core-java-modules/core-java-11/src/main/java/com/baeldung/App.java

@@ -0,0 +1,13 @@
+package com.baeldung;
+
+/**
+ * Hello world!
+ *
+ */
+public class App 
+{
+    public static void main( String[] args )
+    {
+        System.out.println( "Hello World!" );
+    }
+}

core-java-modules/core-java-11/src/main/java/com/baeldung/Outer.java

@@ -0,0 +1,24 @@
+package com.baeldung;
+
+import java.lang.reflect.Method;
+
+public class Outer {
+
+    public void outerPublic() {
+    }
+
+    private void outerPrivate() {
+    }
+
+    class Inner {
+
+        public void innerPublic() {
+            outerPrivate();
+        }
+
+        public void innerPublicReflection(Outer ob) throws Exception {
+            Method method = ob.getClass().getDeclaredMethod("outerPrivate");
+            method.invoke(ob);
+        }
+    }
+}

core-java-modules/core-java-11/src/main/java/com/baeldung/add

@@ -0,0 +1,12 @@
+#!/usr/local/bin/java --source 11
+
+import java.util.Arrays;
+
+public class Addition
+{
+    public static void main(String[] args) {
+        System.out.println(Arrays.stream(args)
+          .mapToInt(Integer::parseInt)
+          .sum());
+    }
+}

core-java-modules/core-java-11/src/main/java/com/baeldung/epsilongc/MemoryPolluter.java

@@ -0,0 +1,18 @@
+package com.baeldung.epsilongc;
+
+public class MemoryPolluter {
+
+    private static final int MEGABYTE_IN_BYTES = 1024 * 1024;
+    private static final int ITERATION_COUNT = 1024 * 10;
+
+    public static void main(String[] args) {
+        System.out.println("Starting pollution");
+
+        for (int i = 0; i < ITERATION_COUNT; i++) {
+            byte[] array = new byte[MEGABYTE_IN_BYTES];
+        }
+
+        System.out.println("Terminating");
+    }
+
+}

core-java-modules/core-java-11/src/main/java/com/baeldung/java11/httpclient/HttpClientExample.java

@@ -0,0 +1,132 @@
+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package com.baeldung.java11.httpclient;
+
+import java.io.IOException;
+import java.net.URI;
+import java.net.URISyntaxException;
+import java.net.http.HttpClient;
+import java.net.http.HttpClient.Version;
+import java.net.http.HttpRequest;
+import java.net.http.HttpRequest.BodyPublishers;
+import java.net.http.HttpResponse;
+import java.net.http.HttpResponse.BodyHandlers;
+import java.net.http.HttpResponse.PushPromiseHandler;
+import java.util.Arrays;
+import java.util.List;
+import java.util.concurrent.CompletableFuture;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+
+public class HttpClientExample {
+
+    public static void main(String[] args) throws Exception {
+        httpGetRequest();
+        httpPostRequest();
+        asynchronousGetRequest();
+        asynchronousMultipleRequests();
+        pushRequest();
+    }
+
+    public static void httpGetRequest() throws URISyntaxException, IOException, InterruptedException {
+        HttpClient client = HttpClient.newHttpClient();
+        HttpRequest request = HttpRequest.newBuilder()
+            .version(HttpClient.Version.HTTP_2)
+            .uri(URI.create("http://jsonplaceholder.typicode.com/posts/1"))
+            .headers("Accept-Enconding", "gzip, deflate")
+            .build();
+        HttpResponse<String> response = client.send(request, BodyHandlers.ofString());
+
+        String responseBody = response.body();
+        int responseStatusCode = response.statusCode();
+
+        System.out.println("httpGetRequest: " + responseBody);
+        System.out.println("httpGetRequest status code: " + responseStatusCode);
+    }
+
+    public static void httpPostRequest() throws URISyntaxException, IOException, InterruptedException {
+        HttpClient client = HttpClient.newBuilder()
+            .version(HttpClient.Version.HTTP_2)
+            .build();
+        HttpRequest request = HttpRequest.newBuilder(new URI("http://jsonplaceholder.typicode.com/posts"))
+            .version(HttpClient.Version.HTTP_2)
+            .POST(BodyPublishers.ofString("Sample Post Request"))
+            .build();
+        HttpResponse<String> response = client.send(request, BodyHandlers.ofString());
+        String responseBody = response.body();
+        System.out.println("httpPostRequest : " + responseBody);
+    }
+
+    public static void asynchronousGetRequest() throws URISyntaxException {
+        HttpClient client = HttpClient.newHttpClient();
+        URI httpURI = new URI("http://jsonplaceholder.typicode.com/posts/1");
+        HttpRequest request = HttpRequest.newBuilder(httpURI)
+            .version(HttpClient.Version.HTTP_2)
+            .build();
+        CompletableFuture<Void> futureResponse = client.sendAsync(request, HttpResponse.BodyHandlers.ofString())
+            .thenAccept(resp -> {
+                System.out.println("Got pushed response " + resp.uri());
+                System.out.println("Response statuscode: " + resp.statusCode());
+                System.out.println("Response body: " + resp.body());
+            });
+        System.out.println("futureResponse" + futureResponse);
+
+    }
+
+    public static void asynchronousMultipleRequests() throws URISyntaxException {
+        HttpClient client = HttpClient.newHttpClient();
+        List<URI> uris = Arrays.asList(new URI("http://jsonplaceholder.typicode.com/posts/1"), new URI("http://jsonplaceholder.typicode.com/posts/2"));
+        List<HttpRequest> requests = uris.stream()
+            .map(HttpRequest::newBuilder)
+            .map(reqBuilder -> reqBuilder.build())
+            .collect(Collectors.toList());
+        System.out.println("Got pushed response1 " + requests);
+        CompletableFuture.allOf(requests.stream()
+            .map(request -> client.sendAsync(request, BodyHandlers.ofString()))
+            .toArray(CompletableFuture<?>[]::new))
+            .thenAccept(System.out::println)
+            .join();
+    }
+
+    public static void pushRequest() throws URISyntaxException, InterruptedException {
+        System.out.println("Running HTTP/2 Server Push example...");
+
+        HttpClient httpClient = HttpClient.newBuilder()
+            .version(Version.HTTP_2)
+            .build();
+
+        HttpRequest pageRequest = HttpRequest.newBuilder()
+            .uri(URI.create("https://http2.golang.org/serverpush"))
+            .build();
+
+        // Interface HttpResponse.PushPromiseHandler<T>
+        // void applyPushPromise​(HttpRequest initiatingRequest, HttpRequest pushPromiseRequest, Function<HttpResponse.BodyHandler<T>,​CompletableFuture<HttpResponse<T>>> acceptor)
+        httpClient.sendAsync(pageRequest, BodyHandlers.ofString(), pushPromiseHandler())
+            .thenAccept(pageResponse -> {
+                System.out.println("Page response status code: " + pageResponse.statusCode());
+                System.out.println("Page response headers: " + pageResponse.headers());
+                String responseBody = pageResponse.body();
+                System.out.println(responseBody);
+            }).join();
+
+        Thread.sleep(1000); // waiting for full response
+    }
+
+    private static PushPromiseHandler<String> pushPromiseHandler() {
+        return (HttpRequest initiatingRequest, 
+            HttpRequest pushPromiseRequest, 
+            Function<HttpResponse.BodyHandler<String>, 
+            CompletableFuture<HttpResponse<String>>> acceptor) -> {
+            acceptor.apply(BodyHandlers.ofString())
+                .thenAccept(resp -> {
+                    System.out.println(" Pushed response: " + resp.uri() + ", headers: " + resp.headers());
+                });
+            System.out.println("Promise request: " + pushPromiseRequest.uri());
+            System.out.println("Promise request: " + pushPromiseRequest.headers());
+        };
+    }
+
+}

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

@@ -0,0 +1,13 @@
+<?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>
+
+    <root level="INFO">
+        <appender-ref ref="STDOUT" />
+    </root>
+</configuration>

core-java-modules/core-java-11/src/modules/jlinkModule/com/baeldung/jlink/HelloWorld.java

@@ -0,0 +1,12 @@
+package com.baeldung.jlink;
+
+import java.util.logging.Logger;
+
+public class HelloWorld {
+
+    private static final Logger LOG = Logger.getLogger(HelloWorld.class.getName());
+
+    public static void main(String[] args) {
+        LOG.info("Hello World!");
+    }
+}

core-java-modules/core-java-11/src/modules/jlinkModule/module-info.java

@@ -0,0 +1,3 @@
+module jlinkModule {
+    requires java.logging;
+}

core-java-modules/core-java-11/src/test/java/com/baeldung/AppTest.java

@@ -0,0 +1,38 @@
+package com.baeldung;
+
+import junit.framework.Test;
+import junit.framework.TestCase;
+import junit.framework.TestSuite;
+
+/**
+ * Unit test for simple App.
+ */
+public class AppTest 
+    extends TestCase
+{
+    /**
+     * Create the test case
+     *
+     * @param testName name of the test case
+     */
+    public AppTest( String testName )
+    {
+        super( testName );
+    }
+
+    /**
+     * @return the suite of tests being tested
+     */
+    public static Test suite()
+    {
+        return new TestSuite( AppTest.class );
+    }
+
+    /**
+     * Rigourous Test :-)
+     */
+    public void testApp()
+    {
+        assertTrue( true );
+    }
+}

core-java-modules/core-java-11/src/test/java/com/baeldung/EmptyStringToEmptyOptionalUnitTest.java

@@ -0,0 +1,32 @@
+package com.baeldung;
+
+import com.google.common.base.Strings;
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.util.Optional;
+import java.util.function.Predicate;
+
+public class EmptyStringToEmptyOptionalUnitTest {
+
+    @Test
+    public void givenEmptyString_whenFilteringOnOptional_thenEmptyOptionalIsReturned() {
+        String str = "";
+        Optional<String> opt = Optional.ofNullable(str).filter(s -> !s.isEmpty());
+        Assert.assertFalse(opt.isPresent());
+    }
+
+    @Test
+    public void givenEmptyString_whenFilteringOnOptionalInJava11_thenEmptyOptionalIsReturned() {
+        String str = "";
+        Optional<String> opt = Optional.ofNullable(str).filter(Predicate.not(String::isEmpty));
+        Assert.assertFalse(opt.isPresent());
+    }
+
+    @Test
+    public void givenEmptyString_whenPassingResultOfEmptyToNullToOfNullable_thenEmptyOptionalIsReturned() {
+        String str = "";
+        Optional<String> opt = Optional.ofNullable(Strings.emptyToNull(str));
+        Assert.assertFalse(opt.isPresent());
+    }
+}

core-java-modules/core-java-11/src/test/java/com/baeldung/NewStringAPIUnitTest.java

@@ -0,0 +1,43 @@
+package com.baeldung;
+
+import static org.hamcrest.CoreMatchers.is;
+
+import static org.junit.Assert.assertTrue;
+
+import org.junit.Test;
+
+public class NewStringAPIUnitTest {
+
+    @Test
+    public void whenRepeatStringTwice_thenGetStringTwice() {
+        String output = "La ".repeat(2) + "Land";
+
+        is(output).equals("La La Land");
+    }
+
+    @Test
+    public void whenStripString_thenReturnStringWithoutWhitespaces() {
+        is("\n\t  hello   \u2005".strip()).equals("hello");
+    }
+
+    @Test
+    public void whenTrimAdvanceString_thenReturnStringWithWhitespaces() {
+        is("\n\t  hello   \u2005".trim()).equals("hello   \u2005");
+    }
+
+    @Test
+    public void whenBlankString_thenReturnTrue() {
+        assertTrue("\n\t\u2005  ".isBlank());
+    }
+
+    @Test
+    public void whenMultilineString_thenReturnNonEmptyLineCount() {
+        String multilineStr = "This is\n \n a multiline\n string.";
+
+        long lineCount = multilineStr.lines()
+          .filter(String::isBlank)
+          .count();
+
+        is(lineCount).equals(3L);
+    }
+}

core-java-modules/core-java-11/src/test/java/com/baeldung/OuterUnitTest.java

@@ -0,0 +1,46 @@
+package com.baeldung;
+
+import static org.junit.Assert.assertTrue;
+import static org.hamcrest.CoreMatchers.is;
+
+import java.util.Arrays;
+import java.util.Set;
+import java.util.stream.Collectors;
+import org.junit.Test;
+
+public class OuterUnitTest {
+
+    private static final String NEST_HOST_NAME = "com.baeldung.Outer";
+
+    @Test
+    public void whenGetNestHostFromOuter_thenGetNestHost() {
+        is(Outer.class.getNestHost().getName()).equals(NEST_HOST_NAME);
+    }
+
+    @Test
+    public void whenGetNestHostFromInner_thenGetNestHost() {
+        is(Outer.Inner.class.getNestHost().getName()).equals(NEST_HOST_NAME);
+    }
+
+    @Test
+    public void whenCheckNestmatesForNestedClasses_thenGetTrue() {
+        is(Outer.Inner.class.isNestmateOf(Outer.class)).equals(true);
+    }
+
+    @Test
+    public void whenCheckNestmatesForUnrelatedClasses_thenGetFalse() {
+        is(Outer.Inner.class.isNestmateOf(Outer.class)).equals(false);
+    }
+
+    @Test
+    public void whenGetNestMembersForNestedClasses_thenGetAllNestedClasses() {
+        Set<String> nestMembers = Arrays.stream(Outer.Inner.class.getNestMembers())
+          .map(Class::getName)
+          .collect(Collectors.toSet());
+
+        is(nestMembers.size()).equals(2);
+
+        assertTrue(nestMembers.contains("com.baeldung.Outer"));
+        assertTrue(nestMembers.contains("com.baeldung.Outer$Inner"));
+    }
+}

core-java-modules/core-java-11/src/test/java/com/baeldung/java11/httpclient/test/HttpClientTest.java

@@ -0,0 +1,240 @@
+package com.baeldung.java11.httpclient.test;
+
+import static org.hamcrest.CoreMatchers.containsString;
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertThat;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+import java.io.IOException;
+import java.net.Authenticator;
+import java.net.CookieManager;
+import java.net.CookiePolicy;
+import java.net.HttpURLConnection;
+import java.net.PasswordAuthentication;
+import java.net.ProxySelector;
+import java.net.URI;
+import java.net.URISyntaxException;
+import java.net.http.HttpClient;
+import java.net.http.HttpRequest;
+import java.net.http.HttpResponse;
+import java.net.http.HttpResponse.BodyHandlers;
+import java.util.Arrays;
+import java.util.List;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.CompletionException;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.TimeUnit;
+import java.util.stream.Collectors;
+
+import org.junit.jupiter.api.Test;
+
+public class HttpClientTest {
+
+    @Test
+    public void shouldReturnSampleDataContentWhenConnectViaSystemProxy() throws IOException, InterruptedException, URISyntaxException {
+        HttpRequest request = HttpRequest.newBuilder()
+            .uri(new URI("https://postman-echo.com/post"))
+            .headers("Content-Type", "text/plain;charset=UTF-8")
+            .POST(HttpRequest.BodyPublishers.ofString("Sample body"))
+            .build();
+      
+        
+        HttpResponse<String> response = HttpClient.newBuilder()
+            .proxy(ProxySelector.getDefault())
+            .build()
+            .send(request, HttpResponse.BodyHandlers.ofString());
+        
+        assertThat(response.statusCode(), equalTo(HttpURLConnection.HTTP_OK));
+        assertThat(response.body(), containsString("Sample body"));
+    }
+
+    @Test
+    public void shouldNotFollowRedirectWhenSetToDefaultNever() throws IOException, InterruptedException, URISyntaxException {
+        HttpRequest request = HttpRequest.newBuilder()
+            .uri(new URI("http://stackoverflow.com"))
+            .version(HttpClient.Version.HTTP_1_1)
+            .GET()
+            .build();
+        HttpResponse<String> response = HttpClient.newBuilder()
+            .build()
+            .send(request, HttpResponse.BodyHandlers.ofString());
+
+        assertThat(response.statusCode(), equalTo(HttpURLConnection.HTTP_MOVED_PERM));
+        assertThat(response.body(), containsString("https://stackoverflow.com/"));
+    }
+
+    @Test
+    public void shouldFollowRedirectWhenSetToAlways() throws IOException, InterruptedException, URISyntaxException {
+        HttpRequest request = HttpRequest.newBuilder()
+            .uri(new URI("http://stackoverflow.com"))
+            .version(HttpClient.Version.HTTP_1_1)
+            .GET()
+            .build();
+        HttpResponse<String> response = HttpClient.newBuilder()
+            .followRedirects(HttpClient.Redirect.ALWAYS)
+            .build()
+            .send(request, HttpResponse.BodyHandlers.ofString());
+
+        assertThat(response.statusCode(), equalTo(HttpURLConnection.HTTP_OK));
+        assertThat(response.request()
+            .uri()
+            .toString(), equalTo("https://stackoverflow.com/"));
+    }
+
+    @Test
+    public void shouldReturnOKStatusForAuthenticatedAccess() throws URISyntaxException, IOException, InterruptedException {
+        HttpRequest request = HttpRequest.newBuilder()
+            .uri(new URI("https://postman-echo.com/basic-auth"))
+            .GET()
+            .build();
+        HttpResponse<String> response = HttpClient.newBuilder()
+            .authenticator(new Authenticator() {
+                @Override
+                protected PasswordAuthentication getPasswordAuthentication() {
+                    return new PasswordAuthentication("postman", "password".toCharArray());
+                }
+            })
+            .build()
+            .send(request, HttpResponse.BodyHandlers.ofString());
+
+        assertThat(response.statusCode(), equalTo(HttpURLConnection.HTTP_OK));
+    }
+
+    @Test
+    public void shouldSendRequestAsync() throws URISyntaxException, InterruptedException, ExecutionException {
+        HttpRequest request = HttpRequest.newBuilder()
+            .uri(new URI("https://postman-echo.com/post"))
+            .headers("Content-Type", "text/plain;charset=UTF-8")
+            .POST(HttpRequest.BodyPublishers.ofString("Sample body"))
+            .build();
+        CompletableFuture<HttpResponse<String>> response = HttpClient.newBuilder()
+            .build()
+            .sendAsync(request, HttpResponse.BodyHandlers.ofString());
+
+        assertThat(response.get()
+            .statusCode(), equalTo(HttpURLConnection.HTTP_OK));
+    }
+
+    @Test
+    public void shouldUseJustTwoThreadWhenProcessingSendAsyncRequest() throws URISyntaxException, InterruptedException, ExecutionException {
+        HttpRequest request = HttpRequest.newBuilder()
+            .uri(new URI("https://postman-echo.com/get"))
+            .GET()
+            .build();
+
+        ExecutorService executorService = Executors.newFixedThreadPool(2);
+
+        CompletableFuture<HttpResponse<String>> response1 = HttpClient.newBuilder()
+            .executor(executorService)
+            .build()
+            .sendAsync(request, HttpResponse.BodyHandlers.ofString());
+
+        CompletableFuture<HttpResponse<String>> response2 = HttpClient.newBuilder()
+            .executor(executorService)
+            .build()
+            .sendAsync(request, HttpResponse.BodyHandlers.ofString());
+
+        CompletableFuture<HttpResponse<String>> response3 = HttpClient.newBuilder()
+            .executor(executorService)
+            .build()
+            .sendAsync(request, HttpResponse.BodyHandlers.ofString());
+
+        CompletableFuture.allOf(response1, response2, response3)
+            .join();
+
+        assertThat(response1.get()
+            .statusCode(), equalTo(HttpURLConnection.HTTP_OK));
+        assertThat(response2.get()
+            .statusCode(), equalTo(HttpURLConnection.HTTP_OK));
+        assertThat(response3.get()
+            .statusCode(), equalTo(HttpURLConnection.HTTP_OK));
+    }
+
+    @Test
+    public void shouldNotStoreCookieWhenPolicyAcceptNone() throws URISyntaxException, IOException, InterruptedException {
+        HttpRequest request = HttpRequest.newBuilder()
+            .uri(new URI("https://postman-echo.com/get"))
+            .GET()
+            .build();
+
+        HttpClient httpClient = HttpClient.newBuilder()
+            .cookieHandler(new CookieManager(null, CookiePolicy.ACCEPT_NONE))
+            .build();
+
+        httpClient.send(request, HttpResponse.BodyHandlers.ofString());
+
+        assertTrue(httpClient.cookieHandler()
+            .isPresent());
+    }
+
+    @Test
+    public void shouldStoreCookieWhenPolicyAcceptAll() throws URISyntaxException, IOException, InterruptedException {
+        HttpRequest request = HttpRequest.newBuilder()
+            .uri(new URI("https://postman-echo.com/get"))
+            .GET()
+            .build();
+
+        HttpClient httpClient = HttpClient.newBuilder()
+            .cookieHandler(new CookieManager(null, CookiePolicy.ACCEPT_ALL))
+            .build();
+
+        httpClient.send(request, HttpResponse.BodyHandlers.ofString());
+
+        assertTrue(httpClient.cookieHandler()
+            .isPresent());
+    }
+
+    @Test
+    public void shouldProcessMultipleRequestViaStream() throws URISyntaxException, ExecutionException, InterruptedException {
+        List<URI> targets = Arrays.asList(new URI("https://postman-echo.com/get?foo1=bar1"), new URI("https://postman-echo.com/get?foo2=bar2"));
+
+        HttpClient client = HttpClient.newHttpClient();
+
+        List<CompletableFuture<String>> futures = targets.stream()
+            .map(target -> client.sendAsync(HttpRequest.newBuilder(target)
+                .GET()
+                .build(), HttpResponse.BodyHandlers.ofString())
+                .thenApply(response -> response.body()))
+            .collect(Collectors.toList());
+
+        CompletableFuture.allOf(futures.toArray(new CompletableFuture[0]))
+            .join();
+
+        if (futures.get(0)
+            .get()
+            .contains("foo1")) {
+            assertThat(futures.get(0)
+                .get(), containsString("bar1"));
+            assertThat(futures.get(1)
+                .get(), containsString("bar2"));
+        } else {
+            assertThat(futures.get(1)
+                .get(), containsString("bar2"));
+            assertThat(futures.get(1)
+                .get(), containsString("bar1"));
+        }
+
+    }
+    
+    @Test
+    public void completeExceptionallyExample() {
+        CompletableFuture<String> cf = CompletableFuture.completedFuture("message").thenApplyAsync(String::toUpperCase,
+                CompletableFuture.delayedExecutor(1, TimeUnit.SECONDS));
+        CompletableFuture<String> exceptionHandler = cf.handle((s, th) -> { return (th != null) ? "message upon cancel" : ""; });
+        cf.completeExceptionally(new RuntimeException("completed exceptionally"));
+        assertTrue("Was not completed exceptionally", cf.isCompletedExceptionally());
+        try {
+            cf.join();
+            fail("Should have thrown an exception");
+        } catch (CompletionException ex) { // just for testing
+            assertEquals("completed exceptionally", ex.getCause().getMessage());
+        }
+
+        assertEquals("message upon cancel", exceptionHandler.join());
+    }
+
+}

core-java-modules/core-java-11/src/test/java/com/baeldung/java11/httpclient/test/HttpRequestTest.java

@@ -0,0 +1,168 @@
+package com.baeldung.java11.httpclient.test;
+
+import static java.time.temporal.ChronoUnit.SECONDS;
+import static org.hamcrest.CoreMatchers.containsString;
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.junit.Assert.assertThat;
+
+import java.io.ByteArrayInputStream;
+import java.io.IOException;
+import java.net.HttpURLConnection;
+import java.net.URI;
+import java.net.URISyntaxException;
+import java.net.http.HttpClient;
+import java.net.http.HttpRequest;
+import java.net.http.HttpResponse;
+import java.nio.file.Paths;
+import java.security.NoSuchAlgorithmException;
+import java.time.Duration;
+
+import org.junit.Test;
+
+public class HttpRequestTest {
+
+    @Test
+    public void shouldReturnStatusOKWhenSendGetRequest() throws IOException, InterruptedException, URISyntaxException {
+        HttpRequest request = HttpRequest.newBuilder()
+            .uri(new URI("https://postman-echo.com/get"))
+            .GET()
+            .build();
+
+        HttpResponse<String> response = HttpClient.newHttpClient()
+            .send(request, HttpResponse.BodyHandlers.ofString());
+
+        assertThat(response.statusCode(), equalTo(HttpURLConnection.HTTP_OK));
+    }
+
+    @Test
+    public void shouldUseHttp2WhenWebsiteUsesHttp2() throws IOException, InterruptedException, URISyntaxException {
+        HttpRequest request = HttpRequest.newBuilder()
+            .uri(new URI("https://stackoverflow.com"))
+            .version(HttpClient.Version.HTTP_2)
+            .GET()
+            .build();
+        HttpResponse<String> response = HttpClient.newHttpClient()
+            .send(request, HttpResponse.BodyHandlers.ofString());
+
+        assertThat(response.statusCode(), equalTo(HttpURLConnection.HTTP_OK));
+        assertThat(response.version(), equalTo(HttpClient.Version.HTTP_2));
+    }
+
+    @Test
+    public void shouldFallbackToHttp1_1WhenWebsiteDoesNotUseHttp2() throws IOException, InterruptedException, URISyntaxException, NoSuchAlgorithmException {
+        HttpRequest request = HttpRequest.newBuilder()
+            .uri(new URI("https://postman-echo.com/get"))
+            .version(HttpClient.Version.HTTP_2)
+            .GET()
+            .build();
+
+        HttpResponse<String> response = HttpClient.newHttpClient()
+            .send(request, HttpResponse.BodyHandlers.ofString());
+
+        assertThat(response.version(), equalTo(HttpClient.Version.HTTP_1_1));
+    }
+
+    @Test
+    public void shouldReturnStatusOKWhenSendGetRequestWithDummyHeaders() throws IOException, InterruptedException, URISyntaxException {
+        HttpRequest request = HttpRequest.newBuilder()
+            .uri(new URI("https://postman-echo.com/get"))
+            .headers("key1", "value1", "key2", "value2")
+            .GET()
+            .build();
+
+        HttpResponse<String> response = HttpClient.newHttpClient()
+            .send(request, HttpResponse.BodyHandlers.ofString());
+
+        assertThat(response.statusCode(), equalTo(HttpURLConnection.HTTP_OK));
+    }
+
+    @Test
+    public void shouldReturnStatusOKWhenSendGetRequestTimeoutSet() throws IOException, InterruptedException, URISyntaxException {
+        HttpRequest request = HttpRequest.newBuilder()
+            .uri(new URI("https://postman-echo.com/get"))
+            .timeout(Duration.of(10, SECONDS))
+            .GET()
+            .build();
+
+        HttpResponse<String> response = HttpClient.newHttpClient()
+            .send(request, HttpResponse.BodyHandlers.ofString());
+
+        assertThat(response.statusCode(), equalTo(HttpURLConnection.HTTP_OK));
+    }
+
+    @Test
+    public void shouldReturnNoContentWhenPostWithNoBody() throws IOException, InterruptedException, URISyntaxException {
+        HttpRequest request = HttpRequest.newBuilder()
+            .uri(new URI("https://postman-echo.com/post"))
+            .POST(HttpRequest.BodyPublishers.noBody())
+            .build();
+
+        HttpResponse<String> response = HttpClient.newHttpClient()
+            .send(request, HttpResponse.BodyHandlers.ofString());
+
+        assertThat(response.statusCode(), equalTo(HttpURLConnection.HTTP_OK));
+    }
+
+    @Test
+    public void shouldReturnSampleDataContentWhenPostWithBodyText() throws IOException, InterruptedException, URISyntaxException {
+        HttpRequest request = HttpRequest.newBuilder()
+            .uri(new URI("https://postman-echo.com/post"))
+            .headers("Content-Type", "text/plain;charset=UTF-8")
+            .POST(HttpRequest.BodyPublishers.ofString("Sample request body"))
+            .build();
+
+        HttpResponse<String> response = HttpClient.newHttpClient()
+            .send(request, HttpResponse.BodyHandlers.ofString());
+
+        assertThat(response.statusCode(), equalTo(HttpURLConnection.HTTP_OK));
+        assertThat(response.body(), containsString("Sample request body"));
+    }
+
+    @Test
+    public void shouldReturnSampleDataContentWhenPostWithInputStream() throws IOException, InterruptedException, URISyntaxException {
+        byte[] sampleData = "Sample request body".getBytes();
+        HttpRequest request = HttpRequest.newBuilder()
+            .uri(new URI("https://postman-echo.com/post"))
+            .headers("Content-Type", "text/plain;charset=UTF-8")
+            .POST(HttpRequest.BodyPublishers.ofInputStream(() -> new ByteArrayInputStream(sampleData)))
+            .build();
+
+        HttpResponse<String> response = HttpClient.newHttpClient()
+            .send(request, HttpResponse.BodyHandlers.ofString());
+
+        assertThat(response.statusCode(), equalTo(HttpURLConnection.HTTP_OK));
+        assertThat(response.body(), containsString("Sample request body"));
+    }
+
+    @Test
+    public void shouldReturnSampleDataContentWhenPostWithByteArrayProcessorStream() throws IOException, InterruptedException, URISyntaxException {
+        byte[] sampleData = "Sample request body".getBytes();
+        HttpRequest request = HttpRequest.newBuilder()
+            .uri(new URI("https://postman-echo.com/post"))
+            .headers("Content-Type", "text/plain;charset=UTF-8")
+            .POST(HttpRequest.BodyPublishers.ofByteArray(sampleData))
+            .build();
+
+        HttpResponse<String> response = HttpClient.newHttpClient()
+            .send(request, HttpResponse.BodyHandlers.ofString());
+
+        assertThat(response.statusCode(), equalTo(HttpURLConnection.HTTP_OK));
+        assertThat(response.body(), containsString("Sample request body"));
+    }
+
+    @Test
+    public void shouldReturnSampleDataContentWhenPostWithFileProcessorStream() throws IOException, InterruptedException, URISyntaxException {
+        HttpRequest request = HttpRequest.newBuilder()
+            .uri(new URI("https://postman-echo.com/post"))
+            .headers("Content-Type", "text/plain;charset=UTF-8")
+            .POST(HttpRequest.BodyPublishers.ofFile(Paths.get("src/test/resources/sample.txt")))
+            .build();
+
+        HttpResponse<String> response = HttpClient.newHttpClient()
+            .send(request, HttpResponse.BodyHandlers.ofString());
+
+        assertThat(response.statusCode(), equalTo(HttpURLConnection.HTTP_OK));
+        assertThat(response.body(), containsString("Sample file content"));
+    }
+
+}

core-java-modules/core-java-11/src/test/java/com/baeldung/java11/httpclient/test/HttpResponseTest.java

@@ -0,0 +1,54 @@
+package com.baeldung.java11.httpclient.test;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertThat;
+
+import java.io.IOException;
+import java.net.HttpURLConnection;
+import java.net.URI;
+import java.net.URISyntaxException;
+import java.net.http.HttpClient;
+import java.net.http.HttpRequest;
+import java.net.http.HttpResponse;
+
+import org.junit.Test;
+
+public class HttpResponseTest {
+
+    @Test
+    public void shouldReturnStatusOKWhenSendGetRequest() throws IOException, InterruptedException, URISyntaxException {
+        HttpRequest request = HttpRequest.newBuilder()
+            .uri(new URI("https://postman-echo.com/get"))
+            .version(HttpClient.Version.HTTP_2)
+            .GET()
+            .build();
+
+        HttpResponse<String> response = HttpClient.newBuilder()
+            .followRedirects(HttpClient.Redirect.NORMAL)
+            .build()
+            .send(request, HttpResponse.BodyHandlers.ofString());
+
+        assertThat(response.statusCode(), equalTo(HttpURLConnection.HTTP_OK));
+        assertNotNull(response.body());
+    }
+
+    @Test
+    public void shouldResponseURIDifferentThanRequestUIRWhenRedirect() throws IOException, InterruptedException, URISyntaxException {
+        HttpRequest request = HttpRequest.newBuilder()
+            .uri(new URI("http://stackoverflow.com"))
+            .version(HttpClient.Version.HTTP_2)
+            .GET()
+            .build();
+        HttpResponse<String> response = HttpClient.newBuilder()
+            .followRedirects(HttpClient.Redirect.NORMAL)
+            .build()
+            .send(request, HttpResponse.BodyHandlers.ofString());
+
+        assertThat(request.uri()
+            .toString(), equalTo("http://stackoverflow.com"));
+        assertThat(response.uri()
+            .toString(), equalTo("https://stackoverflow.com/"));
+    }
+
+}

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

@@ -0,0 +1,23 @@
+package com.baeldung.optional;
+
+import org.junit.Test;
+
+import java.util.Optional;
+
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+/**
+ * Unit tests for {@link Optional} in Java 11.
+ */
+public class OptionalUnitTest {
+
+    @Test
+    public void givenAnEmptyOptional_isEmpty_thenBehavesAsExpected() {
+        Optional<String> opt = Optional.of("Baeldung");
+        assertFalse(opt.isEmpty());
+
+        opt = Optional.ofNullable(null);
+        assertTrue(opt.isEmpty());
+    }
+}

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

@@ -0,0 +1,50 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<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>
+    <groupId>com.baeldung</groupId>
+    <artifactId>core-java-12</artifactId>
+    <version>0.1.0-SNAPSHOT</version>
+    <name>core-java-12</name>
+    <packaging>jar</packaging>
+    <url>http://maven.apache.org</url>
+
+    <parent>
+        <groupId>com.baeldung</groupId>
+        <artifactId>parent-modules</artifactId>
+        <version>1.0.0-SNAPSHOT</version>
+        <relativePath>../../</relativePath>
+    </parent>
+
+    <dependencies>
+        <dependency>
+            <groupId>org.assertj</groupId>
+            <artifactId>assertj-core</artifactId>
+            <version>${assertj.version}</version>
+            <scope>test</scope>
+        </dependency>
+    </dependencies>
+
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-compiler-plugin</artifactId>
+                <version>${maven-compiler-plugin.version}</version>
+                <configuration>
+                    <source>${maven.compiler.source.version}</source>
+                    <target>${maven.compiler.target.version}</target>
+                    <compilerArgs>--enable-preview</compilerArgs>
+                </configuration>
+            </plugin>
+        </plugins>
+    </build>
+
+    <properties>
+        <maven.compiler.source.version>12</maven.compiler.source.version>
+        <maven.compiler.target.version>12</maven.compiler.target.version>
+        <assertj.version>3.6.1</assertj.version>
+    </properties>
+
+</project>

core-java-modules/core-java-12/src/test/java/com/baeldung/collectors/CollectorsUnitTest.java

@@ -0,0 +1,71 @@
+package com.baeldung.collectors;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.Objects;
+
+import org.junit.Test;
+
+import static java.util.stream.Collectors.maxBy;
+import static java.util.stream.Collectors.minBy;
+import static java.util.stream.Collectors.teeing;
+import static org.assertj.core.api.Assertions.assertThat;
+
+/**
+ * Unit tests for collectors additions in Java 12.
+ */
+public class CollectorsUnitTest {
+
+    @Test
+    public void whenTeeing_ItShouldCombineTheResultsAsExpected() {
+        List<Integer> numbers = Arrays.asList(42, 4, 2, 24);
+        Range range = numbers.stream()
+            .collect(teeing(minBy(Integer::compareTo), maxBy(Integer::compareTo), (min, max) -> new Range(min.orElse(null), max.orElse(null))));
+
+        assertThat(range).isEqualTo(new Range(2, 42));
+    }
+
+    /**
+     * Represents a closed range of numbers between {@link #min} and
+     * {@link #max}, both inclusive.
+     */
+    private static class Range {
+
+        private final Integer min;
+
+        private final Integer max;
+
+        Range(Integer min, Integer max) {
+            this.min = min;
+            this.max = max;
+        }
+
+        Integer getMin() {
+            return min;
+        }
+
+        Integer getMax() {
+            return max;
+        }
+
+        @Override
+        public boolean equals(Object o) {
+            if (this == o)
+                return true;
+            if (o == null || getClass() != o.getClass())
+                return false;
+            Range range = (Range) o;
+            return Objects.equals(getMin(), range.getMin()) && Objects.equals(getMax(), range.getMax());
+        }
+
+        @Override
+        public int hashCode() {
+            return Objects.hash(getMin(), getMax());
+        }
+
+        @Override
+        public String toString() {
+            return "Range{" + "min=" + min + ", max=" + max + '}';
+        }
+    }
+}

core-java-modules/core-java-12/src/test/java/com/baeldung/switchExpression/SwitchUnitTest.java

@@ -0,0 +1,37 @@
+package com.baeldung.switchExpression;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+public class SwitchUnitTest {
+
+    @Test
+    public void switchJava12(){
+
+        var month = Month.AUG;
+
+        var value = switch(month){
+            case JAN,JUN, JUL -> 3;
+            case FEB,SEP, OCT, NOV, DEC -> 1;
+            case MAR,MAY, APR, AUG -> 2;
+        };
+
+        Assert.assertEquals(value, 2);
+    }
+
+    @Test
+    public void switchLocalVariable(){
+        var month = Month.AUG;
+        int i = switch (month){
+            case JAN,JUN, JUL -> 3;
+            case FEB,SEP, OCT, NOV, DEC -> 1;
+            case MAR,MAY, APR, AUG -> {
+                int j = month.toString().length() * 4;
+                break j;
+            }
+        };
+        Assert.assertEquals(12, i);
+    }
+
+    enum Month {JAN, FEB, MAR, APR, MAY, JUN, JUL, AUG, SEP, OCT, NOV, DEC}
+}

core-java-modules/core-java-8-2/.gitignore

@@ -0,0 +1,25 @@
+*.class
+
+0.*
+
+#folders#
+/target
+/neoDb*
+/data
+/src/main/webapp/WEB-INF/classes
+*/META-INF/*
+.resourceCache
+
+# Packaged files #
+*.jar
+*.war
+*.ear
+
+# Files generated by integration tests
+backup-pom.xml
+/bin/
+/temp
+
+#IntelliJ specific
+.idea/
+*.iml

core-java-modules/core-java-8-2/README.md

@@ -0,0 +1,6 @@
+=========
+
+## Core Java 8 Cookbooks and Examples (part 2)
+
+### Relevant Articles: 
+- [Anonymous Classes in Java](http://www.baeldung.com/)

core-java-modules/core-java-8-2/pom.xml

@@ -0,0 +1,50 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<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>
+    <groupId>com.baeldung</groupId>
+    <artifactId>core-java-8-2</artifactId>
+    <version>0.1.0-SNAPSHOT</version>
+    <name>core-java-8-2</name>
+    <packaging>jar</packaging>
+
+
+    <parent>
+        <groupId>com.baeldung</groupId>
+        <artifactId>parent-java</artifactId>
+        <version>0.0.1-SNAPSHOT</version>
+        <relativePath>../../parent-java</relativePath>
+    </parent>
+
+    <properties>
+        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+        <maven.compiler.source>1.8</maven.compiler.source>
+        <maven.compiler.target>1.8</maven.compiler.target>
+        <icu.version>64.2</icu.version>
+    </properties>
+
+    <dependencies>
+        <dependency>
+            <groupId>com.ibm.icu</groupId>
+            <artifactId>icu4j</artifactId>
+            <version>${icu.version}</version>
+        </dependency>
+
+    </dependencies>
+
+    <build>
+        <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>
+</project>

core-java-modules/core-java-8-2/src/main/java/com/baeldung/jarArguments/JarExample.java

@@ -0,0 +1,18 @@
+package com.baeldung.jarArguments;
+
+public class JarExample {
+
+    public static void main(String[] args) {
+        System.out.println("Hello Baeldung Reader in JarExample!");
+        
+        if(args == null) {
+            System.out.println("You have not provided any arguments!");
+        }else {
+            System.out.println("There are "+args.length+" argument(s)!");
+            for(int i=0; i<args.length; i++) {
+                System.out.println("Argument("+(i+1)+"):" + args[i]);
+            }
+        }
+    }
+
+}

core-java-modules/core-java-8-2/src/main/java/com/baeldung/localization/App.java

@@ -0,0 +1,21 @@
+package com.baeldung.localization;
+
+import java.text.ParseException;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Locale;
+
+public class App {
+
+    /**
+     * Runs all available formatter
+     * @throws ParseException 
+     */
+    public static void main(String[] args) {
+        List<Locale> locales = Arrays.asList(new Locale[] { Locale.UK, Locale.ITALY, Locale.FRANCE, Locale.forLanguageTag("pl-PL") });
+        Localization.run(locales);
+        JavaSEFormat.run(locales);
+        ICUFormat.run(locales);
+    }
+
+}

core-java-modules/core-java-8-2/src/main/java/com/baeldung/localization/ICUFormat.java

@@ -0,0 +1,29 @@
+package com.baeldung.localization;
+
+import java.util.List;
+import java.util.Locale;
+import java.util.ResourceBundle;
+
+import com.ibm.icu.text.MessageFormat;
+
+public class ICUFormat {
+
+    public static String getLabel(Locale locale, Object[] data) {
+        ResourceBundle bundle = ResourceBundle.getBundle("formats", locale);
+        String format = bundle.getString("label-icu");
+        MessageFormat formatter = new MessageFormat(format, locale);
+        return formatter.format(data);
+    }
+
+    public static void run(List<Locale> locales) {
+        System.out.println("ICU formatter");
+        locales.forEach(locale -> System.out.println(getLabel(locale, new Object[] { "Alice", "female", 0 })));
+        locales.forEach(locale -> System.out.println(getLabel(locale, new Object[] { "Alice", "female", 1 })));
+        locales.forEach(locale -> System.out.println(getLabel(locale, new Object[] { "Alice", "female", 2 })));
+        locales.forEach(locale -> System.out.println(getLabel(locale, new Object[] { "Alice", "female", 3 })));
+        locales.forEach(locale -> System.out.println(getLabel(locale, new Object[] { "Bob", "male", 0 })));
+        locales.forEach(locale -> System.out.println(getLabel(locale, new Object[] { "Bob", "male", 1 })));
+        locales.forEach(locale -> System.out.println(getLabel(locale, new Object[] { "Bob", "male", 2 })));
+        locales.forEach(locale -> System.out.println(getLabel(locale, new Object[] { "Bob", "male", 3 })));
+    }
+}

core-java-modules/core-java-8-2/src/main/java/com/baeldung/localization/JavaSEFormat.java

@@ -0,0 +1,24 @@
+package com.baeldung.localization;
+
+import java.text.MessageFormat;
+import java.util.Date;
+import java.util.List;
+import java.util.Locale;
+import java.util.ResourceBundle;
+
+public class JavaSEFormat {
+
+    public static String getLabel(Locale locale, Object[] data) {
+        ResourceBundle bundle = ResourceBundle.getBundle("formats", locale);
+        final String pattern = bundle.getString("label");
+        final MessageFormat formatter = new MessageFormat(pattern, locale);
+        return formatter.format(data);
+    }
+
+    public static void run(List<Locale> locales) {
+        System.out.println("Java formatter");
+        final Date date = new Date(System.currentTimeMillis());
+        locales.forEach(locale -> System.out.println(getLabel(locale, new Object[] { date, "Alice", 0 })));
+        locales.forEach(locale -> System.out.println(getLabel(locale, new Object[] { date, "Alice", 2 })));
+    }
+}

core-java-modules/core-java-8-2/src/main/java/com/baeldung/localization/Localization.java

@@ -0,0 +1,18 @@
+package com.baeldung.localization;
+
+import java.util.List;
+import java.util.Locale;
+import java.util.ResourceBundle;
+
+public class Localization {
+
+    public static String getLabel(Locale locale) {
+        final ResourceBundle bundle = ResourceBundle.getBundle("messages", locale);
+        return bundle.getString("label");
+    }
+
+    public static void run(List<Locale> locales) {
+        locales.forEach(locale -> System.out.println(getLabel(locale)));
+    }
+
+}

core-java-modules/core-java-8-2/src/main/resources/example_manifest.txt

@@ -0,0 +1 @@
+Main-Class: com.baeldung.jarArguments.JarExample

core-java-modules/core-java-8-2/src/main/resources/formats_en.properties

@@ -0,0 +1,2 @@
+label=On {0, date, short} {1} has sent you {2, choice, 0#no messages|1#a message|2#two messages|2<{2,number,integer} messages}.
+label-icu={0} has sent you {2, plural, =0 {no messages} =1 {a message} other {{2, number, integer} messages}}.

core-java-modules/core-java-8-2/src/main/resources/formats_fr.properties

@@ -0,0 +1,2 @@
+label={0, date, short}, {1}{2, choice, 0# ne|0<} vous a envoy<6F> {2, choice, 0#aucun message|1#un message|2#deux messages|2<{2,number,integer} messages}.
+label-icu={0} {2, plural, =0 {ne } other {}}vous a envoy<6F> {2, plural, =0 {aucun message} =1 {un message} other {{2, number, integer} messages}}.

core-java-modules/core-java-8-2/src/main/resources/formats_it.properties

@@ -0,0 +1,2 @@
+label={0, date, short} {1} ti ha inviato {2, choice, 0#nessun messagio|1#un messaggio|2#due messaggi|2<{2, number, integer} messaggi}.
+label-icu={0} {2, plural, =0 {non } other {}}ti ha inviato {2, plural, =0 {nessun messaggio} =1 {un messaggio} other {{2, number, integer} messaggi}}.

core-java-modules/core-java-8-2/src/main/resources/formats_pl.properties

@@ -0,0 +1,2 @@
+label=W {0, date, short} {1}{2, choice, 0# nie|0<} wys\u0142a\u0142a ci {2, choice, 0#\u017Cadnych wiadomo\u015Bci|1#wiadomo\u015B\u0107|2#dwie wiadomo\u015Bci|2<{2, number, integer} wiadomo\u015Bci}.
+label-icu={0} {2, plural, =0 {nie } other {}}{1, select, male {wys\u0142a\u0142} female {wys\u0142a\u0142a} other {wys\u0142a\u0142o}} ci {2, plural, =0 {\u017Cadnej wiadomo\u015Bci} =1 {wiadomo\u015B\u0107} other {{2, number, integer} wiadomo\u015Bci}}.

core-java-modules/core-java-8-2/src/main/resources/messages_en.properties

@@ -0,0 +1 @@
+label=Alice has sent you a message.

core-java-modules/core-java-8-2/src/main/resources/messages_fr.properties

@@ -0,0 +1 @@
+label=Alice vous a envoy<6F> un message.

core-java-modules/core-java-8-2/src/main/resources/messages_it.properties

@@ -0,0 +1 @@
+label=Alice ti ha inviato un messaggio.

core-java-modules/core-java-8-2/src/main/resources/messages_pl.properties

@@ -0,0 +1 @@
+label=Alice wys\u0142a\u0142a ci wiadomo\u015B\u0107.

core-java-modules/core-java-8-2/src/test/java/com/baeldung/localization/ICUFormatUnitTest.java

@@ -0,0 +1,74 @@
+package com.baeldung.localization;
+
+import static org.junit.Assert.assertEquals;
+
+import java.util.Locale;
+
+import org.junit.Test;
+
+import com.baeldung.localization.ICUFormat;
+
+public class ICUFormatUnitTest {
+
+    @Test
+    public void givenInUK_whenAliceSendsNothing_thenCorrectMessage() {
+        assertEquals("Alice has sent you no messages.", ICUFormat.getLabel(Locale.UK, new Object[] { "Alice", "female", 0 }));
+    }
+
+    @Test
+    public void givenInUK_whenAliceSendsOneMessage_thenCorrectMessage() {
+        assertEquals("Alice has sent you a message.", ICUFormat.getLabel(Locale.UK, new Object[] { "Alice", "female", 1 }));
+    }
+
+    @Test
+    public void givenInUK_whenBobSendsSixMessages_thenCorrectMessage() {
+        assertEquals("Bob has sent you 6 messages.", ICUFormat.getLabel(Locale.UK, new Object[] { "Bob", "male", 6 }));
+    }
+
+    @Test
+    public void givenInItaly_whenAliceSendsNothing_thenCorrectMessage() {
+        assertEquals("Alice non ti ha inviato nessun messaggio.", ICUFormat.getLabel(Locale.ITALY, new Object[] { "Alice", "female", 0 }));
+    }
+
+    @Test
+    public void givenInItaly_whenAliceSendsOneMessage_thenCorrectMessage() {
+        assertEquals("Alice ti ha inviato un messaggio.", ICUFormat.getLabel(Locale.ITALY, new Object[] { "Alice", "female", 1 }));
+    }
+
+    @Test
+    public void givenInItaly_whenBobSendsSixMessages_thenCorrectMessage() {
+        assertEquals("Bob ti ha inviato 6 messaggi.", ICUFormat.getLabel(Locale.ITALY, new Object[] { "Bob", "male", 6 }));
+    }
+
+    @Test
+    public void givenInFrance_whenAliceSendsNothing_thenCorrectMessage() {
+        assertEquals("Alice ne vous a envoyé aucun message.", ICUFormat.getLabel(Locale.FRANCE, new Object[] { "Alice", "female", 0 }));
+    }
+    
+    @Test
+    public void givenInFrance_whenAliceSendsOneMessage_thenCorrectMessage() {
+        assertEquals("Alice vous a envoyé un message.", ICUFormat.getLabel(Locale.FRANCE, new Object[] { "Alice", "female", 1 }));
+    }
+
+    @Test
+    public void givenInFrance_whenBobSendsSixMessages_thenCorrectMessage() {
+        assertEquals("Bob vous a envoyé 6 messages.", ICUFormat.getLabel(Locale.FRANCE, new Object[] { "Bob", "male", 6 }));
+    }
+
+
+    @Test
+    public void givenInPoland_whenAliceSendsNothing_thenCorrectMessage() {
+        assertEquals("Alice nie wysłała ci żadnej wiadomości.", ICUFormat.getLabel(Locale.forLanguageTag("pl-PL"), new Object[] { "Alice", "female", 0 }));
+    }
+    
+    @Test
+    public void givenInPoland_whenAliceSendsOneMessage_thenCorrectMessage() {
+        assertEquals("Alice wysłała ci wiadomość.", ICUFormat.getLabel(Locale.forLanguageTag("pl-PL"), new Object[] { "Alice", "female", 1 }));
+    }
+    
+    @Test
+    public void givenInPoland_whenBobSendsSixMessages_thenCorrectMessage() {
+        assertEquals("Bob wysłał ci 6 wiadomości.", ICUFormat.getLabel(Locale.forLanguageTag("pl-PL"), new Object[] { "Bob", "male", 6 }));
+    }
+
+}

core-java-modules/core-java-8/.gitignore

@@ -0,0 +1,26 @@
+*.class
+
+0.*
+
+#folders#
+/target
+/neoDb*
+/data
+/src/main/webapp/WEB-INF/classes
+*/META-INF/*
+.resourceCache
+
+# Packaged files #
+*.jar
+*.war
+*.ear
+
+# Files generated by integration tests
+*.txt
+backup-pom.xml
+/bin/
+/temp
+
+#IntelliJ specific
+.idea/
+*.iml

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

@@ -0,0 +1,42 @@
+=========
+
+## Core Java 8 Cookbooks and Examples
+
+### Relevant Articles: 
+- [Guide to Java 8’s Collectors](http://www.baeldung.com/java-8-collectors)
+- [Functional Interfaces in Java 8](http://www.baeldung.com/java-8-functional-interfaces)
+- [Java 8 – Powerful Comparison with Lambdas](http://www.baeldung.com/java-8-sort-lambda)
+- [New Features in Java 8](http://www.baeldung.com/java-8-new-features)
+- [Lambda Expressions and Functional Interfaces: Tips and Best Practices](http://www.baeldung.com/java-8-lambda-expressions-tips)
+- [The Double Colon Operator in Java 8](http://www.baeldung.com/java-8-double-colon-operator)
+- [Guide to Java 8 groupingBy Collector](http://www.baeldung.com/java-groupingby-collector)
+- [Strategy Design Pattern in Java 8](http://www.baeldung.com/java-strategy-pattern)
+- [Exceptions in Java 8 Lambda Expressions](http://www.baeldung.com/java-lambda-exceptions)
+- [Guide to Java 8 Comparator.comparing()](http://www.baeldung.com/java-8-comparator-comparing)
+- [Guide To Java 8 Optional](http://www.baeldung.com/java-optional)
+- [Guide to the Java 8 forEach](http://www.baeldung.com/foreach-java)
+- [The Difference Between map() and flatMap()](http://www.baeldung.com/java-difference-map-and-flatmap)
+- [Static and Default Methods in Interfaces in Java](http://www.baeldung.com/java-static-default-methods)
+- [Efficient Word Frequency Calculator in Java](http://www.baeldung.com/java-word-frequency)
+- [Introduction to Spliterator in Java](http://www.baeldung.com/java-spliterator)
+- [Java 8 Math New Methods](http://www.baeldung.com/java-8-math)
+- [Overview of Java Built-in Annotations](http://www.baeldung.com/java-default-annotations)
+- [Finding Min/Max in an Array with Java](http://www.baeldung.com/java-array-min-max)
+- [Internationalization and Localization in Java 8](http://www.baeldung.com/java-8-localization)
+- [Java Optional – orElse() vs orElseGet()](http://www.baeldung.com/java-optional-or-else-vs-or-else-get)
+- [Method Parameter Reflection in Java](http://www.baeldung.com/java-parameter-reflection)
+- [Java 8 Unsigned Arithmetic Support](http://www.baeldung.com/java-unsigned-arithmetic)
+- [Generalized Target-Type Inference in Java](http://www.baeldung.com/java-generalized-target-type-inference)
+- [Overriding System Time for Testing in Java](http://www.baeldung.com/java-override-system-time)
+- [Set the Time Zone of a Date in Java](https://www.baeldung.com/java-set-date-time-zone)
+- [An Overview of Regular Expressions Performance in Java](https://www.baeldung.com/java-regex-performance)
+- [Java Primitives versus Objects](https://www.baeldung.com/java-primitives-vs-objects)
+- [How to Use if/else Logic in Java 8 Streams](https://www.baeldung.com/java-8-streams-if-else-logic)
+- [How to Replace Many if Statements in Java](https://www.baeldung.com/java-replace-if-statements)
+- [Java @Override Annotation](https://www.baeldung.com/java-override)
+- [Java @SuppressWarnings Annotation](https://www.baeldung.com/java-suppresswarnings)
+- [Java @SafeVarargs Annotation](https://www.baeldung.com/java-safevarargs)
+- [Java @Deprecated Annotation](https://www.baeldung.com/java-deprecated)
+- [Java 8 Predicate Chain](https://www.baeldung.com/java-predicate-chain)
+- [Method References in Java](https://www.baeldung.com/java-method-references)
+- [Creating a Custom Annotation in Java](https://www.baeldung.com/java-custom-annotation)

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

@@ -0,0 +1,199 @@
+<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>
+    <groupId>com.baeldung</groupId>
+    <artifactId>core-java-8</artifactId>
+    <version>0.1.0-SNAPSHOT</version>
+    <name>core-java-8</name>
+    <packaging>jar</packaging>
+
+    <parent>
+        <groupId>com.baeldung</groupId>
+        <artifactId>parent-java</artifactId>
+        <version>0.0.1-SNAPSHOT</version>
+        <relativePath>../../parent-java</relativePath>
+    </parent>
+
+    <dependencies>
+        <dependency>
+            <groupId>org.apache.commons</groupId>
+            <artifactId>commons-collections4</artifactId>
+            <version>${commons-collections4.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>commons-io</groupId>
+            <artifactId>commons-io</artifactId>
+            <version>${commons-io.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.apache.commons</groupId>
+            <artifactId>commons-lang3</artifactId>
+            <version>${commons-lang3.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.apache.commons</groupId>
+            <artifactId>commons-math3</artifactId>
+            <version>${commons-math3.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>log4j</groupId>
+            <artifactId>log4j</artifactId>
+            <version>${log4j.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>commons-codec</groupId>
+            <artifactId>commons-codec</artifactId>
+            <version>${commons-codec.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.projectlombok</groupId>
+            <artifactId>lombok</artifactId>
+            <version>${lombok.version}</version>
+            <scope>provided</scope>
+        </dependency>
+        <!-- test scoped -->
+        <dependency>
+            <groupId>org.assertj</groupId>
+            <artifactId>assertj-core</artifactId>
+            <version>${assertj.version}</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>com.jayway.awaitility</groupId>
+            <artifactId>awaitility</artifactId>
+            <version>${avaitility.version}</version>
+            <scope>test</scope>
+        </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>
+        <dependency>
+            <groupId>com.codepoetics</groupId>
+            <artifactId>protonpack</artifactId>
+            <version>${protonpack.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>io.vavr</groupId>
+            <artifactId>vavr</artifactId>
+            <version>${vavr.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>joda-time</groupId>
+            <artifactId>joda-time</artifactId>
+            <version>${joda.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.aspectj</groupId>
+            <artifactId>aspectjrt</artifactId>
+            <version>${asspectj.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.aspectj</groupId>
+            <artifactId>aspectjweaver</artifactId>
+            <version>${asspectj.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.powermock</groupId>
+            <artifactId>powermock-module-junit4</artifactId>
+            <version>${powermock.version}</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.powermock</groupId>
+            <artifactId>powermock-api-mockito2</artifactId>
+            <version>${powermock.version}</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.jmockit</groupId>
+            <artifactId>jmockit</artifactId>
+            <version>${jmockit.version}</version>
+            <scope>test</scope>
+        </dependency>
+    </dependencies>
+
+    <build>
+        <finalName>core-java-8</finalName>
+        <resources>
+            <resource>
+                <directory>src/main/resources</directory>
+                <filtering>true</filtering>
+            </resource>
+        </resources>
+
+        <plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-compiler-plugin</artifactId>
+                <version>${maven-compiler-plugin.version}</version>
+                <configuration>
+                    <source>1.8</source>
+                    <target>1.8</target>
+                    <compilerArgument>-parameters</compilerArgument>
+                </configuration>
+            </plugin>
+            <plugin>
+                <groupId>org.springframework.boot</groupId>
+                <artifactId>spring-boot-maven-plugin</artifactId>
+                <version>${spring-boot-maven-plugin.version}</version>
+                <executions>
+                    <execution>
+                        <goals>
+                            <goal>repackage</goal>
+                        </goals>
+                        <configuration>
+                            <classifier>spring-boot</classifier>
+                            <mainClass>org.baeldung.executable.ExecutableMavenJar</mainClass>
+                        </configuration>
+                    </execution>
+                </executions>
+            </plugin>
+            <plugin>
+                <artifactId>maven-surefire-plugin</artifactId>
+                <version>${maven-surefire-plugin.version}</version>
+                <configuration>
+                    <argLine>
+                        -javaagent:${settings.localRepository}/org/jmockit/jmockit/${jmockit.version}/jmockit-${jmockit.version}.jar
+                    </argLine>
+                    <disableXmlReport>true</disableXmlReport>
+                </configuration>
+            </plugin>
+        </plugins>
+    </build>
+
+    <properties>
+        <!-- util -->
+        <commons-lang3.version>3.5</commons-lang3.version>
+        <commons-math3.version>3.6.1</commons-math3.version>
+        <commons-collections4.version>4.1</commons-collections4.version>
+        <collections-generic.version>4.01</collections-generic.version>
+        <commons-codec.version>1.10</commons-codec.version>
+        <vavr.version>0.9.0</vavr.version>
+        <protonpack.version>1.13</protonpack.version>
+        <joda.version>2.10</joda.version>
+        <!-- testing -->
+        <assertj.version>3.6.1</assertj.version>
+        <asspectj.version>1.8.9</asspectj.version>
+        <powermock.version>2.0.0-RC.4</powermock.version>
+        <jmockit.version>1.44</jmockit.version>
+        <avaitility.version>1.7.0</avaitility.version>
+        <jmh-core.version>1.19</jmh-core.version>
+        <jmh-generator.version>1.19</jmh-generator.version>
+        <spring-boot-maven-plugin.version>2.0.4.RELEASE</spring-boot-maven-plugin.version>
+        <!-- plugins -->
+        <maven-compiler-plugin.version>3.8.0</maven-compiler-plugin.version>
+        <maven-surefire-plugin.version>2.22.1</maven-surefire-plugin.version>
+    </properties>
+</project>

core-java-modules/core-java-8/src/main/java/com/baeldung/annotations/ClassWithAnnotation.java

@@ -0,0 +1,5 @@
+package com.baeldung.annotations;
+
+@Deprecated
+class ClassWithAnnotation {
+}

core-java-modules/core-java-8/src/main/java/com/baeldung/annotations/ClassWithDeprecatedMethod.java

@@ -0,0 +1,9 @@
+package com.baeldung.annotations;
+
+class ClassWithDeprecatedMethod {
+
+    @Deprecated
+    static void deprecatedMethod() {
+
+    }
+}

core-java-modules/core-java-8/src/main/java/com/baeldung/annotations/ClassWithSafeVarargs.java

@@ -0,0 +1,11 @@
+package com.baeldung.annotations;
+
+class ClassWithSafeVarargs<T> {
+
+    @SafeVarargs
+    final void iterateOverVarargs(T... args) {
+        for (T x : args) {
+            // do stuff with x
+        }
+    }
+}

core-java-modules/core-java-8/src/main/java/com/baeldung/annotations/ClassWithSuppressWarnings.java

@@ -0,0 +1,9 @@
+package com.baeldung.annotations;
+
+class ClassWithSuppressWarnings {
+
+    @SuppressWarnings("deprecation")
+    void useDeprecatedMethod() {
+        ClassWithDeprecatedMethod.deprecatedMethod(); // no warning is generated here
+    }
+}

core-java-modules/core-java-8/src/main/java/com/baeldung/annotations/IntConsumer.java

@@ -0,0 +1,8 @@
+package com.baeldung.annotations;
+
+@FunctionalInterface
+interface IntConsumer {
+
+    void accept(Integer number);
+
+}

core-java-modules/core-java-8/src/main/java/com/baeldung/annotations/Interval.java

@@ -0,0 +1,8 @@
+package com.baeldung.annotations;
+
+import java.lang.annotation.Repeatable;
+
+@Repeatable(Intervals.class)
+@interface Interval {
+    int hour() default 1;
+}

core-java-modules/core-java-8/src/main/java/com/baeldung/annotations/IntervalUsage.java

@@ -0,0 +1,9 @@
+package com.baeldung.annotations;
+
+public class IntervalUsage {
+
+    @Interval(hour = 17)
+    @Interval(hour = 13)
+    void doPeriodicCleanup() {
+    }
+}

core-java-modules/core-java-8/src/main/java/com/baeldung/annotations/Intervals.java

@@ -0,0 +1,5 @@
+package com.baeldung.annotations;
+
+@interface Intervals {
+    Interval[] value();
+}

core-java-modules/core-java-8/src/main/java/com/baeldung/annotations/MyAnnotation.java

@@ -0,0 +1,11 @@
+package com.baeldung.annotations;
+
+import java.lang.annotation.*;
+
+@Inherited
+@Documented
+@Retention(RetentionPolicy.RUNTIME)
+@Target({ElementType.LOCAL_VARIABLE, ElementType.FIELD})
+@interface MyAnnotation {
+
+}

core-java-modules/core-java-8/src/main/java/com/baeldung/annotations/MyAnnotationTarget.java

@@ -0,0 +1,16 @@
+package com.baeldung.annotations;
+
+class MyAnnotationTarget {
+
+    // this is OK
+    @MyAnnotation
+    String someField;
+
+    // @MyAnnotation <- this is invalid usage!
+    void doSomething() {
+
+        // this also works
+        @MyAnnotation
+        String localVariable;
+    }
+}

core-java-modules/core-java-8/src/main/java/com/baeldung/annotations/MyOperation.java

@@ -0,0 +1,6 @@
+package com.baeldung.annotations;
+
+interface MyOperation {
+
+    void perform();
+}

core-java-modules/core-java-8/src/main/java/com/baeldung/annotations/MyOperationImpl.java

@@ -0,0 +1,9 @@
+package com.baeldung.annotations;
+
+class MyOperationImpl implements MyOperation {
+
+    @Override
+    public void perform() {
+
+    }
+}

core-java-modules/core-java-8/src/main/java/com/baeldung/aspect/ChangeCallsToCurrentTimeInMillisMethod.aj

@@ -0,0 +1,9 @@
+package com.baeldung.aspect;
+
+public aspect ChangeCallsToCurrentTimeInMillisMethod {
+    long around():
+            call(public static native long java.lang.System.currentTimeMillis())
+                    && within(user.code.base.pckg.*) {
+        return 0;
+    }
+}

core-java-modules/core-java-8/src/main/java/com/baeldung/customannotations/Init.java

@@ -0,0 +1,13 @@
+package com.baeldung.customannotations;
+
+import static java.lang.annotation.ElementType.METHOD;
+import static java.lang.annotation.RetentionPolicy.RUNTIME;
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.Target;
+
+@Retention(RUNTIME)
+@Target(METHOD)
+public @interface Init {
+
+}

core-java-modules/core-java-8/src/main/java/com/baeldung/customannotations/JsonElement.java

@@ -0,0 +1,13 @@
+package com.baeldung.customannotations;
+
+import static java.lang.annotation.ElementType.FIELD;
+import static java.lang.annotation.RetentionPolicy.RUNTIME;
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.Target;
+
+@Retention(RUNTIME)
+@Target({ FIELD })
+public @interface JsonElement {
+    public String key() default "";
+}

core-java-modules/core-java-8/src/main/java/com/baeldung/customannotations/JsonSerializable.java

@@ -0,0 +1,13 @@
+package com.baeldung.customannotations;
+
+import static java.lang.annotation.ElementType.TYPE;
+import static java.lang.annotation.RetentionPolicy.RUNTIME;
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.Target;
+
+@Retention(RUNTIME)
+@Target(TYPE)
+public @interface JsonSerializable {
+
+}

core-java-modules/core-java-8/src/main/java/com/baeldung/customannotations/JsonSerializationException.java

@@ -0,0 +1,10 @@
+package com.baeldung.customannotations;
+
+public class JsonSerializationException extends RuntimeException {
+
+    private static final long serialVersionUID = 1L;
+
+    public JsonSerializationException(String message) {
+        super(message);
+    }
+}

core-java-modules/core-java-8/src/main/java/com/baeldung/customannotations/ObjectToJsonConverter.java

@@ -0,0 +1,67 @@
+package com.baeldung.customannotations;
+
+import java.lang.reflect.Field;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Objects;
+import java.util.stream.Collectors;
+
+public class ObjectToJsonConverter {
+    public String convertToJson(Object object) throws JsonSerializationException {
+        try {
+
+            checkIfSerializable(object);
+            initializeObject(object);
+            return getJsonString(object);
+
+        } catch (Exception e) {
+            throw new JsonSerializationException(e.getMessage());
+        }
+    }
+
+    private void checkIfSerializable(Object object) {
+        if (Objects.isNull(object)) {
+            throw new JsonSerializationException("Can't serialize a null object");
+        }
+
+        Class<?> clazz = object.getClass();
+        if (!clazz.isAnnotationPresent(JsonSerializable.class)) {
+            throw new JsonSerializationException("The class " + clazz.getSimpleName() + " is not annotated with JsonSerializable");
+        }
+    }
+
+    private void initializeObject(Object object) throws IllegalAccessException, IllegalArgumentException, InvocationTargetException {
+        Class<?> clazz = object.getClass();
+        for (Method method : clazz.getDeclaredMethods()) {
+            if (method.isAnnotationPresent(Init.class)) {
+                method.setAccessible(true);
+                method.invoke(object);
+            }
+        }
+    }
+
+    private String getJsonString(Object object) throws IllegalArgumentException, IllegalAccessException {
+        Class<?> clazz = object.getClass();
+        Map<String, String> jsonElementsMap = new HashMap<>();
+        for (Field field : clazz.getDeclaredFields()) {
+            field.setAccessible(true);
+            if (field.isAnnotationPresent(JsonElement.class)) {
+                jsonElementsMap.put(getKey(field), (String) field.get(object));
+            }
+        }
+
+        String jsonString = jsonElementsMap.entrySet()
+            .stream()
+            .map(entry -> "\"" + entry.getKey() + "\":\"" + entry.getValue() + "\"")
+            .collect(Collectors.joining(","));
+        return "{" + jsonString + "}";
+    }
+
+    private String getKey(Field field) {
+        String value = field.getAnnotation(JsonElement.class)
+            .key();
+        return value.isEmpty() ? field.getName() : value;
+    }
+}

core-java-modules/core-java-8/src/main/java/com/baeldung/customannotations/Person.java

@@ -0,0 +1,66 @@
+package com.baeldung.customannotations;
+
+@JsonSerializable
+public class Person {
+    @JsonElement
+    private String firstName;
+    @JsonElement
+    private String lastName;
+    @JsonElement(key = "personAge")
+    private String age;
+
+    private String address;
+
+    public Person(String firstName, String lastName) {
+        super();
+        this.firstName = firstName;
+        this.lastName = lastName;
+    }
+
+    public Person(String firstName, String lastName, String age) {
+        this.firstName = firstName;
+        this.lastName = lastName;
+        this.age = age;
+    }
+
+    @Init
+    private void initNames() {
+        this.firstName = this.firstName.substring(0, 1)
+            .toUpperCase() + this.firstName.substring(1);
+        this.lastName = this.lastName.substring(0, 1)
+            .toUpperCase() + this.lastName.substring(1);
+    }
+
+    public String getFirstName() {
+        return firstName;
+    }
+
+    public void setFirstName(String firstName) {
+        this.firstName = firstName;
+    }
+
+    public String getLastName() {
+        return lastName;
+    }
+
+    public void setLastName(String lastName) {
+        this.lastName = lastName;
+    }
+
+    public String getAge() {
+        return age;
+    }
+
+    public void setAge(String age) {
+        this.age = age;
+    }
+
+    public String getAddress() {
+        return address;
+    }
+
+    public void setAddress(String address) {
+        this.address = address;
+    }
+
+}

core-java-modules/core-java-8/src/main/java/com/baeldung/defaultstaticinterfacemethods/application/Application.java

@@ -0,0 +1,18 @@
+package com.baeldung.defaultstaticinterfacemethods.application;
+
+import com.baeldung.defaultstaticinterfacemethods.model.Car;
+import com.baeldung.defaultstaticinterfacemethods.model.Vehicle;
+
+public class Application {
+
+    public static void main(String[] args) {
+
+        Vehicle car = new Car("BMW");
+        System.out.println(car.getBrand());
+        System.out.println(car.speedUp());
+        System.out.println(car.slowDown());
+        System.out.println(car.turnAlarmOn());
+        System.out.println(car.turnAlarmOff());
+        System.out.println(Vehicle.getHorsePower(2500, 480));
+    }
+}

core-java-modules/core-java-8/src/main/java/com/baeldung/defaultstaticinterfacemethods/model/Alarm.java

@@ -0,0 +1,12 @@
+package com.baeldung.defaultstaticinterfacemethods.model;
+
+public interface Alarm {
+
+    default String turnAlarmOn() {
+        return "Turning the alarm on.";
+    }
+
+    default String turnAlarmOff() {
+        return "Turning the alarm off.";
+    }
+}

core-java-modules/core-java-8/src/main/java/com/baeldung/defaultstaticinterfacemethods/model/Car.java

@@ -0,0 +1,25 @@
+package com.baeldung.defaultstaticinterfacemethods.model;
+
+public class Car implements Vehicle {
+
+    private final String brand;
+
+    public Car(String brand) {
+        this.brand = brand;
+    }
+
+    @Override
+    public String getBrand() {
+        return brand;
+    }
+
+    @Override
+    public String speedUp() {
+        return "The car is speeding up.";
+    }
+
+    @Override
+    public String slowDown() {
+        return "The car is slowing down.";
+    }
+}

core-java-modules/core-java-8/src/main/java/com/baeldung/defaultstaticinterfacemethods/model/Motorbike.java

@@ -0,0 +1,25 @@
+package com.baeldung.defaultstaticinterfacemethods.model;
+
+public class Motorbike implements Vehicle {
+
+    private final String brand;
+
+    public Motorbike(String brand) {
+        this.brand = brand;
+    }
+
+    @Override
+    public String getBrand() {
+        return brand;
+    }
+
+    @Override
+    public String speedUp() {
+        return "The motorbike is speeding up.";
+    }
+
+    @Override
+    public String slowDown() {
+        return "The motorbike is slowing down.";
+    }
+}

core-java-modules/core-java-8/src/main/java/com/baeldung/defaultstaticinterfacemethods/model/MultiAlarmCar.java

@@ -0,0 +1,35 @@
+package com.baeldung.defaultstaticinterfacemethods.model;
+
+public class MultiAlarmCar implements Vehicle, Alarm {
+
+    private final String brand;
+
+    public MultiAlarmCar(String brand) {
+        this.brand = brand;
+    }
+
+    @Override
+    public String getBrand() {
+        return brand;
+    }
+
+    @Override
+    public String speedUp() {
+        return "The motorbike is speeding up.";
+    }
+
+    @Override
+    public String slowDown() {
+        return "The mootorbike is slowing down.";
+    }
+
+    @Override
+    public String turnAlarmOn() {
+        return Vehicle.super.turnAlarmOn() + " " + Alarm.super.turnAlarmOn();
+    }
+
+    @Override
+    public String turnAlarmOff() {
+        return Vehicle.super.turnAlarmOff() + " " + Alarm.super.turnAlarmOff();
+    }
+}

core-java-modules/core-java-8/src/main/java/com/baeldung/defaultstaticinterfacemethods/model/Vehicle.java

@@ -0,0 +1,22 @@
+package com.baeldung.defaultstaticinterfacemethods.model;
+
+public interface Vehicle {
+
+    String getBrand();
+
+    String speedUp();
+
+    String slowDown();
+
+    default String turnAlarmOn() {
+        return "Turning the vehice alarm on.";
+    }
+
+    default String turnAlarmOff() {
+        return "Turning the vehicle alarm off.";
+    }
+
+    static int getHorsePower(int rpm, int torque) {
+        return (rpm * torque) / 5252;
+    }
+}

core-java-modules/core-java-8/src/main/java/com/baeldung/doublecolon/Computer.java

@@ -0,0 +1,85 @@
+package com.baeldung.doublecolon;
+
+public class Computer {
+
+    private Integer age;
+    private String color;
+    private Integer healty;
+
+    Computer(final int age, final String color) {
+        this.age = age;
+        this.color = color;
+    }
+
+    Computer(final Integer age, final String color, final Integer healty) {
+        this.age = age;
+        this.color = color;
+        this.healty = healty;
+    }
+
+    public Computer() {
+    }
+
+    public Integer getAge() {
+        return age;
+    }
+
+    public void setAge(final Integer age) {
+        this.age = age;
+    }
+
+    String getColor() {
+        return color;
+    }
+
+    public void setColor(final String color) {
+        this.color = color;
+    }
+
+    Integer getHealty() {
+        return healty;
+    }
+
+    void setHealty(final Integer healty) {
+        this.healty = healty;
+    }
+
+    public void turnOnPc() {
+        System.out.println("Computer turned on");
+    }
+
+    public void turnOffPc() {
+        System.out.println("Computer turned off");
+    }
+
+    public Double calculateValue(Double initialValue) {
+        return initialValue / 1.50;
+    }
+
+    @Override
+    public String toString() {
+        return "Computer{" + "age=" + age + ", color='" + color + '\'' + ", healty=" + healty + '}';
+    }
+
+    @Override
+    public boolean equals(final Object o) {
+        if (this == o) {
+            return true;
+        }
+        if (o == null || getClass() != o.getClass()) {
+            return false;
+        }
+
+        final Computer computer = (Computer) o;
+
+        return (age != null ? age.equals(computer.age) : computer.age == null) && (color != null ? color.equals(computer.color) : computer.color == null);
+
+    }
+
+    @Override
+    public int hashCode() {
+        int result = age != null ? age.hashCode() : 0;
+        result = 31 * result + (color != null ? color.hashCode() : 0);
+        return result;
+    }
+}

core-java-modules/core-java-8/src/main/java/com/baeldung/doublecolon/ComputerUtils.java

@@ -0,0 +1,27 @@
+package com.baeldung.doublecolon;
+
+import com.baeldung.doublecolon.function.ComputerPredicate;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class ComputerUtils {
+
+    static final ComputerPredicate after2010Predicate = (c) -> (c.getAge() > 2010);
+    static final ComputerPredicate blackPredicate = (c) -> "black".equals(c.getColor());
+
+    public static List<Computer> filter(final List<Computer> inventory, final ComputerPredicate p) {
+
+        final List<Computer> result = new ArrayList<>();
+        inventory.stream().filter(p::filter).forEach(result::add);
+
+        return result;
+    }
+
+    static void repair(final Computer computer) {
+        if (computer.getHealty() < 50) {
+            computer.setHealty(100);
+        }
+    }
+
+}

core-java-modules/core-java-8/src/main/java/com/baeldung/doublecolon/MacbookPro.java

@@ -0,0 +1,39 @@
+package com.baeldung.doublecolon;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.function.Function;
+
+public class MacbookPro extends Computer {
+
+    private static final Logger LOG = LoggerFactory.getLogger(MacbookPro.class);
+
+    public MacbookPro(int age, String color) {
+        super(age, color);
+    }
+
+    MacbookPro(Integer age, String color, Integer healty) {
+        super(age, color, healty);
+    }
+
+    @Override
+    public void turnOnPc() {
+        LOG.debug("MacbookPro turned on");
+    }
+
+    @Override
+    public void turnOffPc() {
+        LOG.debug("MacbookPro turned off");
+    }
+
+    @Override
+    public Double calculateValue(Double initialValue) {
+
+        Function<Double, Double> function = super::calculateValue;
+        final Double pcValue = function.apply(initialValue);
+        LOG.debug("First value is:" + pcValue);
+        return pcValue + (initialValue / 10);
+
+    }
+}

core-java-modules/core-java-8/src/main/java/com/baeldung/doublecolon/function/ComputerPredicate.java

@@ -0,0 +1,10 @@
+package com.baeldung.doublecolon.function;
+
+import com.baeldung.doublecolon.Computer;
+
+@FunctionalInterface
+public interface ComputerPredicate {
+
+    boolean filter(Computer c);
+
+}

core-java-modules/core-java-8/src/main/java/com/baeldung/doublecolon/function/TriFunction.java

@@ -0,0 +1,15 @@
+package com.baeldung.doublecolon.function;
+
+import java.util.Objects;
+import java.util.function.Function;
+
+@FunctionalInterface
+public interface TriFunction<A, B, C, R> {
+
+    R apply(A a, B b, C c);
+
+    default <V> TriFunction<A, B, C, V> andThen(final Function<? super R, ? extends V> after) {
+        Objects.requireNonNull(after);
+        return (final A a, final B b, final C c) -> after.apply(apply(a, b, c));
+    }
+}

core-java-modules/core-java-8/src/main/java/com/baeldung/java8/lambda/exceptions/LambdaExceptionWrappers.java

@@ -0,0 +1,57 @@
+package com.baeldung.java8.lambda.exceptions;
+
+import java.util.function.Consumer;
+
+public class LambdaExceptionWrappers {
+
+    public static Consumer<Integer> lambdaWrapper(Consumer<Integer> consumer) {
+        return i -> {
+            try {
+                consumer.accept(i);
+            } catch (ArithmeticException e) {
+                System.err.println("Arithmetic Exception occured : " + e.getMessage());
+            }
+        };
+    }
+
+    static <T, E extends Exception> Consumer<T> consumerWrapper(Consumer<T> consumer, Class<E> clazz) {
+        return i -> {
+            try {
+                consumer.accept(i);
+            } catch (Exception ex) {
+                try {
+                    E exCast = clazz.cast(ex);
+                    System.err.println("Exception occured : " + exCast.getMessage());
+                } catch (ClassCastException ccEx) {
+                    throw ex;
+                }
+            }
+        };
+    }
+
+    public static <T> Consumer<T> throwingConsumerWrapper(ThrowingConsumer<T, Exception> throwingConsumer) {
+        return i -> {
+            try {
+                throwingConsumer.accept(i);
+            } catch (Exception ex) {
+                throw new RuntimeException(ex);
+            }
+        };
+    }
+
+    public static <T, E extends Exception> Consumer<T> handlingConsumerWrapper(ThrowingConsumer<T, E> throwingConsumer, Class<E> exceptionClass) {
+        return i -> {
+            try {
+                throwingConsumer.accept(i);
+            } catch (Exception ex) {
+                try {
+                    E exCast = exceptionClass.cast(ex);
+                    System.err.println("Exception occured : " + exCast.getMessage());
+                } catch (ClassCastException ccEx) {
+                    throw new RuntimeException(ex);
+                }
+            }
+        };
+    }
+
+}

core-java-modules/core-java-8/src/main/java/com/baeldung/java8/lambda/exceptions/ThrowingConsumer.java

@@ -0,0 +1,8 @@
+package com.baeldung.java8.lambda.exceptions;
+
+@FunctionalInterface
+public interface ThrowingConsumer<T, E extends Exception> {
+
+    void accept(T t) throws E;
+
+}

core-java-modules/core-java-8/src/main/java/com/baeldung/java8/lambda/tips/Bar.java

@@ -0,0 +1,13 @@
+package com.baeldung.java8.lambda.tips;
+
+
+@FunctionalInterface
+public interface Bar {
+
+    String method(String string);
+
+    default String defaultMethod() {
+        return "String from Bar";
+    }
+
+}

core-java-modules/core-java-8/src/main/java/com/baeldung/java8/lambda/tips/Baz.java

@@ -0,0 +1,12 @@
+package com.baeldung.java8.lambda.tips;
+
+
+@FunctionalInterface
+public interface Baz {
+
+    String method(String string);
+
+    default String defaultMethod() {
+        return "String from Baz";
+    }
+}

core-java-modules/core-java-8/src/main/java/com/baeldung/java8/lambda/tips/Foo.java

@@ -0,0 +1,11 @@
+package com.baeldung.java8.lambda.tips;
+
+
+@FunctionalInterface
+public interface Foo {
+
+    String method(String string);
+
+    default void defaultMethod() {
+    }
+}

core-java-modules/core-java-8/src/main/java/com/baeldung/java8/lambda/tips/FooExtended.java

@@ -0,0 +1,12 @@
+package com.baeldung.java8.lambda.tips;
+
+
+@FunctionalInterface
+public interface FooExtended extends Baz, Bar {
+
+    @Override
+    default String defaultMethod() {
+        return Bar.super.defaultMethod();
+    }
+
+}

core-java-modules/core-java-8/src/main/java/com/baeldung/java8/lambda/tips/Processor.java

@@ -0,0 +1,12 @@
+package com.baeldung.java8.lambda.tips;
+
+import java.util.concurrent.Callable;
+import java.util.function.Supplier;
+
+public interface Processor {
+
+    String processWithCallable(Callable<String> c) throws Exception;
+
+    String processWithSupplier(Supplier<String> s);
+
+}

core-java-modules/core-java-8/src/main/java/com/baeldung/java8/lambda/tips/ProcessorImpl.java

@@ -0,0 +1,20 @@
+package com.baeldung.java8.lambda.tips;
+
+
+import java.util.concurrent.Callable;
+import java.util.function.Consumer;
+import java.util.function.Function;
+import java.util.function.Supplier;
+
+public class ProcessorImpl implements Processor {
+
+    @Override
+    public String processWithCallable(Callable<String> c) throws Exception {
+        return c.call();
+    }
+
+    @Override
+    public String processWithSupplier(Supplier<String> s) {
+        return s.get();
+    }
+}

core-java-modules/core-java-8/src/main/java/com/baeldung/java8/lambda/tips/UseFoo.java

@@ -0,0 +1,38 @@
+package com.baeldung.java8.lambda.tips;
+
+
+import java.util.function.Function;
+
+public class UseFoo {
+
+    private String value = "Enclosing scope value";
+
+    public String add(final String string, final Foo foo) {
+        return foo.method(string);
+    }
+
+    public String addWithStandardFI(final String string, final Function<String, String> fn) {
+        return fn.apply(string);
+    }
+
+    public String scopeExperiment() {
+        final Foo fooIC = new Foo() {
+            String value = "Inner class value";
+
+            @Override
+            public String method(final String string) {
+                return value;
+            }
+        };
+        final String resultIC = fooIC.method("");
+
+        final Foo fooLambda = parameter -> {
+            final String value = "Lambda value";
+            return this.value;
+        };
+        final String resultLambda = fooLambda.method("");
+
+        return "Results: resultIC = " + resultIC + ", resultLambda = " + resultLambda;
+    }
+
+}

core-java-modules/core-java-8/src/main/java/com/baeldung/java_8_features/Address.java

@@ -0,0 +1,14 @@
+package com.baeldung.java_8_features;
+
+public class Address {
+
+    private String street;
+
+    public String getStreet() {
+        return street;
+    }
+
+    public void setStreet(String street) {
+        this.street = street;
+    }
+}

core-java-modules/core-java-8/src/main/java/com/baeldung/java_8_features/CustomException.java

@@ -0,0 +1,4 @@
+package com.baeldung.java_8_features;
+
+public class CustomException extends RuntimeException {
+}

core-java-modules/core-java-8/src/main/java/com/baeldung/java_8_features/OptionalAddress.java

@@ -0,0 +1,16 @@
+package com.baeldung.java_8_features;
+
+import java.util.Optional;
+
+public class OptionalAddress {
+
+    private String street;
+
+    public Optional<String> getStreet() {
+        return Optional.ofNullable(street);
+    }
+
+    public void setStreet(String street) {
+        this.street = street;
+    }
+}

core-java-modules/core-java-8/src/main/java/com/baeldung/java_8_features/OptionalUser.java

@@ -0,0 +1,16 @@
+package com.baeldung.java_8_features;
+
+import java.util.Optional;
+
+public class OptionalUser {
+
+    private OptionalAddress address;
+
+    public Optional<OptionalAddress> getAddress() {
+        return Optional.of(address);
+    }
+
+    public void setAddress(OptionalAddress address) {
+        this.address = address;
+    }
+}

core-java-modules/core-java-8/src/main/java/com/baeldung/java_8_features/User.java

@@ -0,0 +1,40 @@
+package com.baeldung.java_8_features;
+
+import java.util.Optional;
+
+public class User {
+
+    private String name;
+
+    private Address address;
+
+    public Address getAddress() {
+        return address;
+    }
+
+    public void setAddress(Address address) {
+        this.address = address;
+    }
+
+    public User() {
+    }
+
+    public User(String name) {
+        this.name = name;
+    }
+
+    public static boolean isRealUser(User user) {
+        return true;
+    }
+
+    public String getOrThrow() {
+        String value = null;
+        Optional<String> valueOpt = Optional.ofNullable(value);
+        String result = valueOpt.orElseThrow(CustomException::new).toUpperCase();
+        return result;
+    }
+
+    public boolean isLegalName(String name) {
+        return name.length() > 3 && name.length() < 16;
+    }
+}

core-java-modules/core-java-8/src/main/java/com/baeldung/java_8_features/Vehicle.java

@@ -0,0 +1,18 @@
+package com.baeldung.java_8_features;
+
+public interface Vehicle {
+
+    void moveTo(long altitude, long longitude);
+
+    static String producer() {
+        return "N&F Vehicles";
+    }
+
+    default long[] startPosition() {
+        return new long[] { 23, 15 };
+    }
+
+    default String getOverview() {
+        return "ATV made by " + producer();
+    }
+}

core-java-modules/core-java-8/src/main/java/com/baeldung/java_8_features/VehicleImpl.java

@@ -0,0 +1,9 @@
+package com.baeldung.java_8_features;
+
+public class VehicleImpl implements Vehicle {
+
+    @Override
+    public void moveTo(long altitude, long longitude) {
+        // do nothing
+    }
+}

core-java-modules/core-java-8/src/main/java/com/baeldung/java_8_features/groupingby/BlogPost.java

@@ -0,0 +1,36 @@
+package com.baeldung.java_8_features.groupingby;
+
+public class BlogPost {
+    private String title;
+    private String author;
+    private BlogPostType type;
+    private int likes;
+
+    public BlogPost(String title, String author, BlogPostType type, int likes) {
+        this.title = title;
+        this.author = author;
+        this.type = type;
+        this.likes = likes;
+    }
+
+    public String getTitle() {
+        return title;
+    }
+
+    public String getAuthor() {
+        return author;
+    }
+
+    public BlogPostType getType() {
+        return type;
+    }
+
+    public int getLikes() {
+        return likes;
+    }
+
+    @Override
+    public String toString() {
+        return "BlogPost{" + "title='" + title + '\'' + ", type=" + type + ", likes=" + likes + '}';
+    }
+}

core-java-modules/core-java-8/src/main/java/com/baeldung/java_8_features/groupingby/BlogPostType.java

@@ -0,0 +1,5 @@
+package com.baeldung.java_8_features.groupingby;
+
+public enum BlogPostType {
+    NEWS, REVIEW, GUIDE
+}

core-java-modules/core-java-8/src/main/java/com/baeldung/nullsafecollectionstreams/NullSafeCollectionStreamsUsingCommonsEmptyIfNull.java

@@ -0,0 +1,19 @@
+package com.baeldung.nullsafecollectionstreams;
+
+import java.util.Collection;
+import java.util.stream.Stream;
+import static org.apache.commons.collections4.CollectionUtils.emptyIfNull;
+
+public class NullSafeCollectionStreamsUsingCommonsEmptyIfNull {
+
+    /**
+    * This method shows how to make a null safe stream from a collection through the use of 
+    * emptyIfNull() method from Apache Commons CollectionUtils library
+    * 
+     * @param collection The collection that is to be converted into a stream
+     * @return The stream that has been created from the collection or an empty stream if the collection is null
+    */
+    public Stream<String> collectionAsStream(Collection<String> collection) {
+        return emptyIfNull(collection).stream();
+    }
+}

core-java-modules/core-java-8/src/main/java/com/baeldung/nullsafecollectionstreams/NullSafeCollectionStreamsUsingJava8OptionalContainer.java

@@ -0,0 +1,21 @@
+package com.baeldung.nullsafecollectionstreams;
+
+import java.util.Collection;
+import java.util.Optional;
+import java.util.stream.Stream;
+
+public class NullSafeCollectionStreamsUsingJava8OptionalContainer {
+
+    /**
+    * This method shows how to make a null safe stream from a collection  through the use of 
+    * Java SE 8’s Optional Container
+    * 
+     * @param collection The collection that is to be converted into a stream
+     * @return The stream that has been created from the collection or an empty stream if the collection is null
+    */
+    public Stream<String> collectionAsStream(Collection<String> collection) {
+        return Optional.ofNullable(collection)
+            .map(Collection::stream)
+            .orElseGet(Stream::empty);
+    }
+}