Merge branch 'master' into JAVA-8204

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

@@ -31,24 +31,6 @@
             <artifactId>mockserver-junit-jupiter</artifactId>
             <version>${mockserver.version}</version>
         </dependency>
-        <dependency>
-            <groupId>org.junit.jupiter</groupId>
-            <artifactId>junit-jupiter-engine</artifactId>
-            <version>${junit-jupiter.version}</version>
-            <scope>test</scope>
-        </dependency>
-        <dependency>
-            <groupId>org.junit.jupiter</groupId>
-            <artifactId>junit-jupiter-params</artifactId>
-            <version>${junit-jupiter.version}</version>
-            <scope>test</scope>
-        </dependency>
-        <dependency>
-            <groupId>org.junit.jupiter</groupId>
-            <artifactId>junit-jupiter-api</artifactId>
-            <version>${junit-jupiter.version}</version>
-            <scope>test</scope>
-        </dependency>
         <dependency>
             <groupId>org.apache.commons</groupId>
             <artifactId>commons-lang3</artifactId>

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

@@ -21,18 +21,6 @@
             <version>${assertj.version}</version>
             <scope>test</scope>
         </dependency>
-        <dependency>
-            <groupId>org.junit.jupiter</groupId>
-            <artifactId>junit-jupiter-engine</artifactId>
-            <version>${junit-jupiter.version}</version>
-            <scope>test</scope>
-        </dependency>
-        <dependency>
-            <groupId>org.junit.jupiter</groupId>
-            <artifactId>junit-jupiter-api</artifactId>
-            <version>${junit-jupiter.version}</version>
-            <scope>test</scope>
-        </dependency>
     </dependencies>
 
     <build>

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

@@ -27,18 +27,6 @@
             <version>${assertj.version}</version>
             <scope>test</scope>
         </dependency>
-        <dependency>
-            <groupId>org.junit.jupiter</groupId>
-            <artifactId>junit-jupiter-engine</artifactId>
-            <version>${junit-jupiter.version}</version>
-            <scope>test</scope>
-        </dependency>
-        <dependency>
-            <groupId>org.junit.jupiter</groupId>
-            <artifactId>junit-jupiter-api</artifactId>
-            <version>${junit-jupiter.version}</version>
-            <scope>test</scope>
-        </dependency>
     </dependencies>
 
     <build>

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

@@ -28,18 +28,6 @@
             <artifactId>commons-lang3</artifactId>
             <version>3.12.0</version>
         </dependency>
-        <dependency>
-            <groupId>org.junit.jupiter</groupId>
-            <artifactId>junit-jupiter-engine</artifactId>
-            <version>${junit-jupiter.version}</version>
-            <scope>test</scope>
-        </dependency>
-        <dependency>
-            <groupId>org.junit.jupiter</groupId>
-            <artifactId>junit-jupiter-api</artifactId>
-            <version>${junit-jupiter.version}</version>
-            <scope>test</scope>
-        </dependency>
     </dependencies>
 
     <build>

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

@@ -23,18 +23,6 @@
             <version>${assertj.version}</version>
             <scope>test</scope>
         </dependency>
-        <dependency>
-            <groupId>org.junit.jupiter</groupId>
-            <artifactId>junit-jupiter-engine</artifactId>
-            <version>${junit-jupiter.version}</version>
-            <scope>test</scope>
-        </dependency>
-        <dependency>
-            <groupId>org.junit.jupiter</groupId>
-            <artifactId>junit-jupiter-api</artifactId>
-            <version>${junit-jupiter.version}</version>
-            <scope>test</scope>
-        </dependency>
     </dependencies>
 
     <build>
@@ -56,6 +44,7 @@
                 <version>${surefire.plugin.version}</version>
                 <configuration>
                     <argLine>--enable-preview</argLine>
+                    <argLine>--enable-native-access=core.java</argLine>
                     <forkCount>1</forkCount>
                 </configuration>
                 <dependencies>

core-java-modules/core-java-17/src/main/java/com/baeldung/features/JEP356.java

@@ -0,0 +1,20 @@
+package com.baeldung.features;
+
+import java.util.random.RandomGeneratorFactory;
+import java.util.stream.IntStream;
+import java.util.stream.Stream;
+
+public class JEP356 {
+
+    public Stream<String> getAllAlgorithms() {
+        return RandomGeneratorFactory.all().map(RandomGeneratorFactory::name);
+    }
+
+    public IntStream getPseudoInts(String algorithm, int streamSize) {
+        // returns an IntStream with size @streamSize of random numbers generated using the @algorithm
+        // where the lower bound is 0 and the upper is 100 (exclusive)
+        return RandomGeneratorFactory.of(algorithm)
+                .create()
+                .ints(streamSize, 0,100);
+    }
+}

core-java-modules/core-java-17/src/main/java/com/baeldung/features/JEP406.java

@@ -0,0 +1,28 @@
+package com.baeldung.features;
+
+import com.baeldung.features.JEP409.Circle;
+import com.baeldung.features.JEP409.Shape;
+import com.baeldung.features.JEP409.Triangle;
+
+public class JEP406 {
+
+    static record Human (String name, int age, String profession) {}
+
+    public String checkObject(Object obj) {
+        return switch (obj) {
+            case Human h -> "Name: %s, age: %s and profession: %s".formatted(h.name(), h.age(), h.profession());
+            case Circle c -> "This is a circle";
+            case Shape s -> "It is just a shape";
+            case null -> "It is null";
+            default -> "It is an object";
+        };
+    }
+
+    public String checkShape(Shape shape) {
+        return switch (shape) {
+            case Triangle t && (t.getNumberOfSides() != 3) -> "This is a weird triangle";
+            case Circle c && (c.getNumberOfSides() != 0) -> "This is a weird circle";
+            default -> "Just a normal shape";
+        };
+    }
+}

core-java-modules/core-java-17/src/main/java/com/baeldung/features/JEP409.java

@@ -0,0 +1,38 @@
+package com.baeldung.features;
+
+public class JEP409 {
+
+    sealed interface Shape permits Rectangle, Circle, Square, Triangle {
+        int getNumberOfSides();
+    }
+
+    static final class Rectangle implements Shape {
+        @Override
+        public int getNumberOfSides() {
+            return 4;
+        }
+    }
+
+    static final class Circle implements Shape {
+        @Override
+        public int getNumberOfSides() {
+            return 0;
+        }
+    }
+
+    static final class Square implements Shape {
+        @Override
+        public int getNumberOfSides() {
+            return 4;
+        }
+    }
+
+    static non-sealed class Triangle implements Shape {
+
+        @Override
+        public int getNumberOfSides() {
+            return 3;
+        }
+    }
+
+}

core-java-modules/core-java-17/src/main/java/com/baeldung/features/JEP412.java

@@ -0,0 +1,56 @@
+package com.baeldung.features;
+
+import jdk.incubator.foreign.CLinker;
+import jdk.incubator.foreign.FunctionDescriptor;
+import jdk.incubator.foreign.MemoryAddress;
+import jdk.incubator.foreign.SymbolLookup;
+
+import java.io.IOException;
+import java.lang.invoke.MethodType;
+
+import static jdk.incubator.foreign.ResourceScope.newImplicitScope;
+
+public class JEP412 {
+
+    private static final SymbolLookup libLookup;
+
+    static {
+        var resource = JEP412.class.getResource("/compile_c.sh");
+        try {
+            var process = new ProcessBuilder("sh", resource.getPath()).start();
+            while (process.isAlive()) {}
+        } catch (IOException ex) {
+            throw new RuntimeException(ex);
+        }
+
+        var path = JEP412.class.getResource("/print_name.so").getPath();
+        System.load(path);
+        libLookup = SymbolLookup.loaderLookup();
+    }
+
+    public String getPrintNameFormat(String name){
+
+        var printMethod = libLookup.lookup("printName");
+
+        if (printMethod.isPresent()) {
+            var methodReference = CLinker.getInstance()
+                .downcallHandle(
+                    printMethod.get(),
+                    MethodType.methodType(MemoryAddress.class, MemoryAddress.class),
+                    FunctionDescriptor.of(CLinker.C_POINTER, CLinker.C_POINTER)
+                );
+
+            try {
+                var nativeString = CLinker.toCString(name, newImplicitScope());
+                var invokeReturn = methodReference.invoke(nativeString.address());
+                var memoryAddress = (MemoryAddress) invokeReturn;
+                return CLinker.toJavaString(memoryAddress);
+            } catch (Throwable throwable) {
+                throw new RuntimeException(throwable);
+            }
+        }
+        throw new RuntimeException("printName function not found.");
+    }
+}
+
+

core-java-modules/core-java-17/src/main/java/com/baeldung/features/JEP414.java

@@ -0,0 +1,27 @@
+package com.baeldung.features;
+
+import jdk.incubator.vector.FloatVector;
+import jdk.incubator.vector.VectorSpecies;
+
+public class JEP414 {
+
+    private static final VectorSpecies<Float> SPECIES = FloatVector.SPECIES_PREFERRED;
+
+
+    public void newVectorComputation(float[] a, float[] b, float[] c) {
+        for (var i = 0; i < a.length; i += SPECIES.length()) {
+            var m = SPECIES.indexInRange(i, a.length);
+            var va = FloatVector.fromArray(SPECIES, a, i, m);
+            var vb = FloatVector.fromArray(SPECIES, b, i, m);
+            var vc = va.mul(vb);
+            vc.intoArray(c, i, m);
+        }
+    }
+
+    public void commonVectorComputation(float[] a, float[] b, float[] c) {
+        for (var i = 0; i < a.length; i ++) {
+            c[i] = a[i] * b[i];
+        }
+    }
+
+}

core-java-modules/core-java-17/src/main/java/module-info.java

@@ -0,0 +1,4 @@
+module core.java {
+    requires jdk.incubator.vector;
+    requires jdk.incubator.foreign;
+}

core-java-modules/core-java-17/src/main/resources/compile_c.sh

@@ -0,0 +1,9 @@
+#!/bin/bash
+
+SCRIPTPATH="$( cd -- "$(dirname "$0")" >/dev/null 2>&1 ; pwd -P )"
+
+gcc -c -fPIC $SCRIPTPATH/print_name.c
+gcc -shared -rdynamic -o print_name.so print_name.o
+
+mv print_name.so $SCRIPTPATH/
+mv print_name.o $SCRIPTPATH/

core-java-modules/core-java-17/src/main/resources/print_name.c

@@ -0,0 +1,8 @@
+#include<stdio.h>
+#include<stdlib.h>
+
+char* printName(char *name) {
+    char* newString = (char*)malloc((15 + sizeof(name))*sizeof(char));
+    sprintf(newString, "Your name is %s", name);
+    return newString;
+}

core-java-modules/core-java-17/src/test/java/com/baeldung/features/JEP356UnitTest.java

@@ -0,0 +1,19 @@
+package com.baeldung.features;
+
+import org.junit.jupiter.api.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class JEP356UnitTest {
+
+    @Test
+    void getPseudoInts_whenUsingAlgorithmXoroshiro128PlusPlus_shouldReturnStreamOfRandomInteger() {
+        var algorithm = "Xoshiro256PlusPlus";
+        var streamSize = 100;
+
+        JEP356 jep356 = new JEP356();
+
+        jep356.getPseudoInts(algorithm, streamSize)
+            .forEach(value -> assertThat(value).isLessThanOrEqualTo(99));
+    }
+}

core-java-modules/core-java-17/src/test/java/com/baeldung/features/JEP406UnitTest.java

@@ -0,0 +1,33 @@
+package com.baeldung.features;
+
+import com.baeldung.features.JEP406.Human;
+import com.baeldung.features.JEP409.Square;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class JEP406UnitTest {
+
+    @Test
+    void checkObject_shouldMatchWithHuman() {
+        var jep406 = new JEP406();
+
+        var human = new Human("John", 31, "Developer");
+
+        var checkResult = jep406.checkObject(human);
+
+        assertEquals("Name: John, age: 31 and profession: Developer", checkResult);
+    }
+
+    @Test
+    void checkShape_shouldMatchWithShape() {
+        var jep406 = new JEP406();
+
+        var square = new Square();
+
+        var checkResult = jep406.checkShape(square);
+
+        assertEquals("Just a normal shape", checkResult);
+    }
+
+}

core-java-modules/core-java-17/src/test/java/com/baeldung/features/JEP409UnitTest.java

@@ -0,0 +1,39 @@
+package com.baeldung.features;
+
+import com.baeldung.features.JEP409.*;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.verify;
+
+class JEP409UnitTest {
+
+    static class WeirdTriangle extends Triangle {
+        @Override public int getNumberOfSides() {
+            return 40;
+        }
+    }
+
+    @Test
+    void testSealedClass_shouldInvokeRightClass() {
+
+        Shape shape = spy(new WeirdTriangle());
+
+        int numberOfSides = getNumberOfSides(shape);
+
+        assertEquals(40, numberOfSides);
+        verify(shape).getNumberOfSides();
+    }
+
+    int getNumberOfSides(Shape shape) {
+        return switch (shape) {
+            case WeirdTriangle t -> t.getNumberOfSides();
+            case Circle c -> c.getNumberOfSides();
+            case Triangle t -> t.getNumberOfSides();
+            case Rectangle r -> r.getNumberOfSides();
+            case Square s -> s.getNumberOfSides();
+        };
+    }
+}

core-java-modules/core-java-17/src/test/java/com/baeldung/features/JEP412UnitTest.java

@@ -0,0 +1,17 @@
+package com.baeldung.features;
+
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+class JEP412UnitTest {
+
+    @Test
+    void getPrintNameFormat_whenPassingAName_shouldReceiveItFormatted() {
+        var jep412 = new JEP412();
+
+        var formattedName = jep412.getPrintNameFormat("John");
+
+        assertEquals("Your name is John", formattedName);
+    }
+}

core-java-modules/core-java-17/src/test/java/com/baeldung/features/JEP414UnitTest.java

@@ -0,0 +1,38 @@
+package com.baeldung.features;
+
+import org.junit.jupiter.api.Test;
+
+import static java.util.stream.Collectors.toList;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+class JEP414UnitTest {
+
+    @Test
+    void vectorComputation_shouldMultiplyVectors() {
+        var jep414 = new JEP414();
+
+        float[] a = initArray(100);
+        float[] b = initArray(100);
+        float[] c = new float[100];
+        float[] d = new float[100];
+
+        jep414.newVectorComputation(a, b, c);
+        jep414.commonVectorComputation(a, b, d);
+
+        for (int i = 0; i < a.length; i++) {
+            assertEquals(c[i], d[i]);
+        }
+    }
+
+    private float[] initArray(int size) {
+        final var jep356 = new JEP356();
+        final var values = new float[size];
+        final var pseudoInts = jep356.getPseudoInts("Xoshiro256PlusPlus", size).mapToObj(Float::valueOf).collect(toList());
+
+        for (int i = 0; i < pseudoInts.size(); i++) {
+            values[i] = pseudoInts.get(i);
+        }
+
+        return values;
+    }
+}

core-java-modules/core-java-17/src/test/java/com/baeldung/hexformat/ByteHexadecimalConversionUnitTest.java

@@ -0,0 +1,23 @@
+package com.baeldung.hexformat;
+
+import java.util.HexFormat;
+import org.junit.jupiter.api.Test;
+import static org.junit.jupiter.api.Assertions.assertArrayEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+class ByteHexadecimalConversionUnitTest {
+
+    private HexFormat hexFormat = HexFormat.of();
+
+    @Test
+    void givenInitialisedHexFormat_whenHexStringIsPassed_thenByteArrayRepresentationIsReturned() {
+        byte[] hexBytes = hexFormat.parseHex("ABCDEF0123456789");
+        assertArrayEquals(new byte[] { -85, -51, -17, 1, 35, 69, 103, -119 }, hexBytes);
+    }
+
+    @Test
+    void givenInitialisedHexFormat_whenByteArrayIsPassed_thenHexStringRepresentationIsReturned() {
+        String bytesAsString = hexFormat.formatHex(new byte[] { -85, -51, -17, 1, 35, 69, 103, -119});
+        assertEquals("abcdef0123456789", bytesAsString);
+    }
+}

core-java-modules/core-java-17/src/test/java/com/baeldung/hexformat/PrimitiveTypeHexadecimalConversionUnitTest.java

@@ -0,0 +1,22 @@
+package com.baeldung.hexformat;
+
+import java.util.HexFormat;
+import org.junit.jupiter.api.Test;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+public class PrimitiveTypeHexadecimalConversionUnitTest {
+
+    private HexFormat hexFormat = HexFormat.of();
+
+    @Test
+    void givenInitialisedHexFormat_whenPrimitiveByteIsPassed_thenHexStringRepresentationIsReturned() {
+        String fromByte = hexFormat.toHexDigits((byte)64);
+        assertEquals("40", fromByte);
+    }
+
+    @Test
+    void givenInitialisedHexFormat_whenPrimitiveLongIsPassed_thenHexStringRepresentationIsReturned() {
+        String fromLong = hexFormat.toHexDigits(1234_5678_9012_3456L);
+        assertEquals("000462d53c8abac0", fromLong);
+    }
+}

core-java-modules/core-java-17/src/test/java/com/baeldung/hexformat/StringFormattingUnitTest.java

@@ -0,0 +1,15 @@
+package com.baeldung.hexformat;
+
+import java.util.HexFormat;
+import org.junit.jupiter.api.Test;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+public class StringFormattingUnitTest {
+
+    private HexFormat hexFormat = HexFormat.of().withPrefix("[").withSuffix("]").withDelimiter(", ");
+
+    @Test
+    public void givenInitialisedHexFormatWithFormattedStringOptions_whenByteArrayIsPassed_thenHexStringRepresentationFormattedCorrectlyIsReturned() {
+        assertEquals("[48], [0c], [11]", hexFormat.formatHex(new byte[] {72, 12, 17}));
+    }
+}

core-java-modules/core-java-17/src/test/java/com/baeldung/hexformat/UppercaseLowercaseOutputUnitTest.java

@@ -0,0 +1,40 @@
+package com.baeldung.hexformat;
+
+import java.util.HexFormat;
+import org.junit.jupiter.api.Test;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+public class UppercaseLowercaseOutputUnitTest {
+
+    @Test
+    public void givenInitialisedHexFormat_whenByteArrayIsPassed_thenLowerCaseHexStringRepresentationIsReturned() {
+        HexFormat hexFormat = HexFormat.of();
+        String bytesAsString = hexFormat.formatHex(new byte[] { -85, -51, -17, 1, 35, 69, 103, -119});
+        assertTrue(isLowerCase(bytesAsString));
+    }
+
+    @Test
+    public void givenInitialisedHexFormatWithUpperCaseOption_whenByteArrayIsPassed_thenLowerCaseHexStringRepresentationIsReturned() {
+        HexFormat hexFormat = HexFormat.of().withUpperCase();
+        String bytesAsString = hexFormat.formatHex(new byte[] { -85, -51, -17, 1, 35, 69, 103, -119});
+        assertTrue(isUpperCase(bytesAsString));
+    }
+
+    private boolean isLowerCase(String str) {
+        char[] charArray = str.toCharArray();
+        for (int i=0; i < charArray.length; i++) {
+            if (Character.isUpperCase(charArray[i]))
+                return false;
+        }
+        return true;
+    }
+
+    private boolean isUpperCase(String str) {
+        char[] charArray = str.toCharArray();
+        for (int i=0; i < charArray.length; i++) {
+            if (Character.isLowerCase(charArray[i]))
+                return false;
+        }
+        return true;
+    }
+}

core-java-modules/core-java-collections-maps-4/pom.xml

@@ -1,34 +1,55 @@
 <?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>
-    <artifactId>core-java-collections-maps-4</artifactId>
-    <version>0.1.0-SNAPSHOT</version>
-    <name>core-java-collections-maps-4</name>
-    <packaging>jar</packaging>
+	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+	<modelVersion>4.0.0</modelVersion>
+	<artifactId>core-java-collections-maps-4</artifactId>
+	<version>0.1.0-SNAPSHOT</version>
+	<name>core-java-collections-maps-4</name>
+	<packaging>jar</packaging>
 
-    <parent>
-        <groupId>com.baeldung.core-java-modules</groupId>
-        <artifactId>core-java-modules</artifactId>
-        <version>0.0.1-SNAPSHOT</version>
-        <relativePath>../pom.xml</relativePath>
-    </parent>
+	<parent>
+		<groupId>com.baeldung.core-java-modules</groupId>
+		<artifactId>core-java-modules</artifactId>
+		<version>0.0.1-SNAPSHOT</version>
+		<relativePath>../pom.xml</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>
+	</properties>
 
-    <build>
-        <pluginManagement>
-            <plugins>
-                <plugin>
-                    <groupId>org.apache.maven.plugins</groupId>
-                    <artifactId>maven-surefire-plugin</artifactId>
-                    <version>3.0.0-M5</version>
-                    <configuration>
-                        <!-- those tests are not made for CI purposes, but for manual testing -->
-                        <groups>!performance</groups>
-                    </configuration>
-                </plugin>
-            </plugins>
-        </pluginManagement>
-    </build>
+	<dependencies>
+		<dependency>
+			<groupId>junit</groupId>
+			<artifactId>junit</artifactId>
+			<version>${junit.version}</version>
+			<scope>test</scope>
+		</dependency>
+		<dependency>
+			<groupId>org.hamcrest</groupId>
+			<artifactId>hamcrest-all</artifactId>
+			<version>${hamcrest-all.version}</version>
+			<scope>test</scope>
+		</dependency>
+	</dependencies>
+
+	<build>
+		<pluginManagement>
+			<plugins>
+				<plugin>
+					<groupId>org.apache.maven.plugins</groupId>
+					<artifactId>maven-surefire-plugin</artifactId>
+					<version>3.0.0-M5</version>
+					<configuration>
+						<!-- those tests are not made for CI purposes, but for manual testing -->
+						<groups>!performance</groups>
+					</configuration>
+				</plugin>
+			</plugins>
+		</pluginManagement>
+	</build>
 
 </project>

core-java-modules/core-java-collections-maps-4/src/main/java/com/baeldung/nestedhashmaps/Address.java

@@ -0,0 +1,32 @@
+package com.baeldung.nestedhashmaps;
+
+public class Address {
+
+    private Integer addressId;
+    private String addressLocation;
+
+    public Address() {
+    }
+
+    public Address(Integer addressId, String addressLocation) {
+        this.addressId = addressId;
+        this.addressLocation = addressLocation;
+    }
+
+    public Integer getAddressId() {
+        return addressId;
+    }
+
+    public void setAddressId(Integer addressId) {
+        this.addressId = addressId;
+    }
+
+    public String getAddressLocation() {
+        return addressLocation;
+    }
+
+    public void setAddressLocation(String addressLocation) {
+        this.addressLocation = addressLocation;
+    }
+
+}

core-java-modules/core-java-collections-maps-4/src/main/java/com/baeldung/nestedhashmaps/Employee.java

@@ -0,0 +1,43 @@
+package com.baeldung.nestedhashmaps;
+
+public class Employee {
+
+    private Integer employeeId;
+    private Address address;
+    private String employeeName;
+
+    public Employee() {
+        super();
+    }
+
+    public Employee(Integer employeeId, Address address, String employeeName) {
+        this.employeeId = employeeId;
+        this.address = address;
+        this.employeeName = employeeName;
+    }
+
+    public Integer getEmployeeId() {
+        return employeeId;
+    }
+
+    public void setEmployeeId(Integer employeeId) {
+        this.employeeId = employeeId;
+    }
+
+    public Address getAddress() {
+        return address;
+    }
+
+    public void setAddress(Address address) {
+        this.address = address;
+    }
+
+    public String getEmployeeName() {
+        return employeeName;
+    }
+
+    public void setEmployeeName(String employeeName) {
+        this.employeeName = employeeName;
+    }
+
+}

core-java-modules/core-java-collections-maps-4/src/main/java/com/baeldung/nestedhashmaps/MapsUtil.java

@@ -0,0 +1,57 @@
+package com.baeldung.nestedhashmaps;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.stream.Collectors;
+
+public class MapsUtil {
+
+    MapsUtil() {
+        super();
+    }
+
+    public Map<Integer, String> buildInnerMap(List<String> batterList) {
+        Map<Integer, String> innerBatterMap = new HashMap<Integer, String>();
+
+        int index = 1;
+        for (String item : batterList) {
+            innerBatterMap.put(index, item);
+            index++;
+        }
+
+        return innerBatterMap;
+    }
+
+    public Map<Integer, Map<String, String>> createNestedMapfromStream(List<Employee> listEmployee) {
+        Map<Integer, Map<String, String>> employeeAddressMap = listEmployee.stream()
+                .collect(Collectors.groupingBy(e -> e.getAddress().getAddressId(),
+                        Collectors.toMap(f -> f.getAddress().getAddressLocation(), Employee::getEmployeeName)));
+        return employeeAddressMap;
+    }
+
+    public Map<Integer, Map<Integer, Address>> createNestedObjectMap(List<Employee> listEmployee) {
+        Map<Integer, Map<Integer, Address>> employeeMap = new HashMap<>();
+
+        employeeMap = listEmployee.stream().collect(Collectors.groupingBy((Employee emp) -> emp.getEmployeeId(),
+                Collectors.toMap((Employee emp) -> emp.getAddress().getAddressId(), fEmpObj -> fEmpObj.getAddress())));
+
+        return employeeMap;
+    }
+
+    public Map<String, String> flattenMap(Map<?, ?> source) {
+        Map<String, String> converted = new HashMap<>();
+
+        for (Entry<?, ?> entry : source.entrySet()) {
+            if (entry.getValue() instanceof Map) {
+                flattenMap((Map<String, Object>) entry.getValue())
+                        .forEach((key, value) -> converted.put(entry.getKey() + "." + key, value));
+            } else {
+                converted.put(entry.getKey().toString(), entry.getValue().toString());
+            }
+        }
+        return converted;
+    }
+
+}

core-java-modules/core-java-collections-maps-4/src/main/java/com/baeldung/nestedhashmaps/NestedHashMapExamplesClass.java

@@ -0,0 +1,118 @@
+package com.baeldung.nestedhashmaps;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Map;
+
+import java.util.List;
+
+public class NestedHashMapExamplesClass {
+    public static void main(String[] args) {
+
+        MapsUtil mUtil = new MapsUtil();
+
+        List<String> batterList = new ArrayList<>();
+        Map<String, Map<Integer, String>> outerBakedGoodsMap = new HashMap<>();
+        Map<String, Map<Integer, String>> outerBakedGoodsMap2 = new HashMap<>();
+        Map<String, Map<Integer, String>> outerBakedGoodsMap3 = new HashMap<>();
+        Map<String, Map<Integer, String>> outerBakedGoodsMap4 = new HashMap<>();
+
+        batterList.add("Mulberry");
+        batterList.add("Cranberry");
+        batterList.add("Blackberry");
+        batterList.add("Mixed fruit");
+        batterList.add("Orange");
+
+        outerBakedGoodsMap.put("Cake", mUtil.buildInnerMap(batterList));
+
+        batterList.clear();
+        batterList.add("Candy");
+        batterList.add("Dark Chocolate");
+        batterList.add("Chocolate");
+        batterList.add("Jam filled");
+        batterList.add("Pineapple");
+
+        outerBakedGoodsMap.put("Donut", mUtil.buildInnerMap(batterList));
+
+        outerBakedGoodsMap2.put("Eclair", mUtil.buildInnerMap(batterList));
+        outerBakedGoodsMap2.put("Donut", mUtil.buildInnerMap(batterList));
+
+        outerBakedGoodsMap3.put("Cake", mUtil.buildInnerMap(batterList));
+        batterList.clear();
+        batterList.add("Banana");
+        batterList.add("Red Velvet");
+        batterList.add("Blackberry");
+        batterList.add("Passion fruit");
+        batterList.add("Kiwi");
+
+        outerBakedGoodsMap3.put("Donut", mUtil.buildInnerMap(batterList));
+
+        outerBakedGoodsMap4.putAll(outerBakedGoodsMap);
+
+        System.out.println(outerBakedGoodsMap.equals(outerBakedGoodsMap2));
+        System.out.println(outerBakedGoodsMap.equals(outerBakedGoodsMap3));
+        System.out.println(outerBakedGoodsMap.equals(outerBakedGoodsMap4));
+
+        outerBakedGoodsMap.get("Cake")
+            .put(6, "Cranberry");
+        System.out.println(outerBakedGoodsMap);
+
+        outerBakedGoodsMap.get("Cake")
+            .remove(5);
+        System.out.println(outerBakedGoodsMap);
+
+        outerBakedGoodsMap.put("Eclair", new HashMap<Integer, String>() {
+            {
+                put(1, "Dark Chocolate");
+            }
+        });
+
+        System.out.println(outerBakedGoodsMap);
+        outerBakedGoodsMap.remove("Eclair");
+        System.out.println(outerBakedGoodsMap);
+        System.out.println("Baked Goods Map Flattened: " + mUtil.flattenMap(outerBakedGoodsMap));
+
+        // Employees Map
+        List<Employee> listEmployee = new ArrayList<Employee>();
+
+        listEmployee.add(new Employee(1, new Address(124, "Timbuktoo"), "Thorin Oakenshield"));
+        listEmployee.add(new Employee(2, new Address(100, "Misty Lanes"), "Balin"));
+        listEmployee.add(new Employee(3, new Address(156, "Bramles Lane"), "Bofur"));
+        listEmployee.add(new Employee(4, new Address(200, "Bag End"), "Bilbo Baggins"));
+        listEmployee.add(new Employee(5, new Address(23, "Rivendell"), "Elrond"));
+
+        Map<Integer, Map<String, String>> employeeAddressMap = mUtil.createNestedMapfromStream(listEmployee);
+
+        Map<Integer, Map<Integer, Address>> employeeMap = mUtil.createNestedObjectMap(listEmployee);
+        Map<Integer, Map<Integer, Address>> employeeMap2 = mUtil.createNestedObjectMap(listEmployee);
+
+        listEmployee.clear();
+        listEmployee.add(new Employee(1, new Address(500, "Timbuktoo"), "Thorin Oakenshield"));
+        listEmployee.add(new Employee(2, new Address(600, "Misty Lanes"), "Balin"));
+        listEmployee.add(new Employee(3, new Address(700, "Bramles Lane"), "Bofur"));
+        listEmployee.add(new Employee(4, new Address(800, "Bag End"), "Bilbo Baggins"));
+        listEmployee.add(new Employee(5, new Address(900, "Rivendell"), "Elrond"));
+
+        Map<Integer, Map<String, String>> employeeAddressMap1 = mUtil.createNestedMapfromStream(listEmployee);
+
+        Map<Integer, Map<Integer, Address>> employeeMap1 = mUtil.createNestedObjectMap(listEmployee);
+
+        System.out.println(employeeMap.equals(employeeMap1));
+        System.out.println(employeeMap.equals(employeeMap2));
+
+        for (Map.Entry<String, Map<Integer, String>> outerBakedGoodsMapEntrySet : outerBakedGoodsMap.entrySet()) {
+            Map<Integer, String> valueMap = outerBakedGoodsMapEntrySet.getValue();
+            System.out.println(valueMap.entrySet());
+        }
+
+        for (Map.Entry<Integer, Map<String, String>> employeeEntrySet : employeeAddressMap.entrySet()) {
+            Map<String, String> valueMap = employeeEntrySet.getValue();
+            System.out.println(valueMap.entrySet());
+        }
+
+        System.out.println("Employee Address Map Flattened: " + mUtil.flattenMap(employeeAddressMap));
+
+        System.out.println(employeeAddressMap.equals(employeeAddressMap1));
+    }
+
+}

core-java-modules/core-java-collections-maps-4/src/test/java/com/baeldung/nestedhashmaps/NestedHashMapExamplesClassUnitTest.java

@@ -0,0 +1,243 @@
+package com.baeldung.nestedhashmaps;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.CoreMatchers.notNullValue;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotEquals;
+import static org.junit.Assert.assertNotSame;
+import static org.junit.Assert.assertThat;
+import org.hamcrest.collection.IsMapContaining;
+
+public class NestedHashMapExamplesClassUnitTest {
+    private MapsUtil mUtil = new MapsUtil();
+    private List<String> batterList = new ArrayList<>();
+    private List<Employee> listEmployee = new ArrayList<Employee>();
+    private Map<String, Map<Integer, String>> actualBakedGoodsMap = new HashMap<>();
+    private Map<Integer, Map<String, String>> actualEmployeeAddressMap = new HashMap<>();
+    private Map<Integer, Map<Integer, Address>> actualEmployeeMap = new HashMap<>();
+
+    @Test
+    public void whenCreateNestedHashMap_thenNestedMap() {
+        assertThat(mUtil.buildInnerMap(batterList), is(notNullValue()));
+        Assert.assertEquals(actualBakedGoodsMap.keySet().size(), 2);
+        Assert.assertThat(actualBakedGoodsMap, IsMapContaining.hasValue(equalTo(mUtil.buildInnerMap(batterList))));
+    }
+
+    private Map<Integer, Map<String, String>> setup() {
+        Map<Integer, Map<String, String>> expectedMap = new HashMap<>();
+        expectedMap.put(Integer.valueOf(100), new HashMap<String, String>() {
+            {
+                put("Misty Lanes", "Balin");
+            }
+        });
+        expectedMap.put(Integer.valueOf(200), new HashMap<String, String>() {
+            {
+                put("Bag End", "Bilbo Baggins");
+            }
+        });
+        expectedMap.put(Integer.valueOf(156), new HashMap<String, String>() {
+            {
+                put("Brambles Lane", "Bofur");
+            }
+        });
+        expectedMap.put(Integer.valueOf(124), new HashMap<String, String>() {
+            {
+                put("Timbuktoo", "Thorin Oakenshield");
+            }
+        });
+        expectedMap.put(Integer.valueOf(23), new HashMap<String, String>() {
+            {
+                put("Rivendell", "Elrond");
+            }
+        });
+
+        return expectedMap;
+    }
+
+    @Test
+    public void whenCreateNestedHashMapwithStreams_thenNestedMap() {
+
+        Map<Integer, Map<String, String>> expectedMap = setup();
+
+        assertThat(actualEmployeeAddressMap, equalTo(expectedMap));
+    }
+
+    @Test
+    public void whenCompareTwoHashMapswithDifferenctValues_usingEquals_thenFail() {
+        Map<String, Map<Integer, String>> outerBakedGoodsMap2 = new HashMap<>();
+        outerBakedGoodsMap2.put("Eclair", mUtil.buildInnerMap(batterList));
+        outerBakedGoodsMap2.put("Donut", mUtil.buildInnerMap(batterList));
+        assertNotEquals(outerBakedGoodsMap2, actualBakedGoodsMap);
+
+        Map<String, Map<Integer, String>> outerBakedGoodsMap3 = new HashMap<String, Map<Integer, String>>();
+        outerBakedGoodsMap3.put("Cake", mUtil.buildInnerMap(batterList));
+        batterList = new ArrayList<>();
+        batterList = Arrays.asList("Banana", "Red Velvet", "Blackberry", "Passion fruit", "Kiwi");
+
+        outerBakedGoodsMap3.put("Donut", mUtil.buildInnerMap(batterList));
+
+        assertNotEquals(outerBakedGoodsMap2, actualBakedGoodsMap);
+
+        listEmployee.clear();
+        listEmployee.add(new Employee(1, new Address(500, "Timbuktoo"), "Thorin Oakenshield"));
+        listEmployee.add(new Employee(2, new Address(600, "Misty Lanes"), "Balin"));
+        listEmployee.add(new Employee(3, new Address(700, "Bramles Lane"), "Bofur"));
+        listEmployee.add(new Employee(4, new Address(800, "Bag End"), "Bilbo Baggins"));
+        listEmployee.add(new Employee(5, new Address(900, "Rivendell"), "Elrond"));
+
+        Map<Integer, Map<String, String>> employeeAddressMap1 = mUtil.createNestedMapfromStream(listEmployee);
+
+        Map<Integer, Map<Integer, Address>> employeeMap1 = mUtil.createNestedObjectMap(listEmployee);
+
+        assertNotEquals(employeeAddressMap1, actualEmployeeAddressMap);
+
+        assertNotEquals(employeeMap1, actualEmployeeMap);
+    }
+
+    @Test
+    public void whencomparingDifferentObjectValuesUsingEquals_thenFail() {
+        listEmployee.clear();
+        listEmployee.add(new Employee(1, new Address(124, "Timbuktoo"), "Thorin Oakenshield"));
+        listEmployee.add(new Employee(2, new Address(100, "Misty Lanes"), "Balin"));
+        listEmployee.add(new Employee(3, new Address(156, "Brambles Lane"), "Bofur"));
+        listEmployee.add(new Employee(4, new Address(200, "Bag End"), "Bilbo Baggins"));
+        listEmployee.add(new Employee(5, new Address(23, "Rivendell"), "Elrond"));
+
+        Map<Integer, Map<Integer, Object>> employeeMap1 = listEmployee.stream().collect(Collectors.groupingBy(
+                (Employee emp) -> emp.getEmployeeId(),
+                Collectors.toMap((Employee emp) -> emp.getAddress().getAddressId(), fEmpObj -> fEmpObj.getAddress())));
+
+        assertNotSame(employeeMap1, actualEmployeeMap);
+        assertNotEquals(employeeMap1, actualEmployeeMap);
+
+        Map<Integer, Map<Integer, Address>> expectedMap = setupAddressObjectMap();
+        assertNotSame(expectedMap, actualEmployeeMap);
+        assertNotEquals(expectedMap, actualEmployeeMap);
+
+    }
+
+    @Test
+    public void whenCompareTwoHashMapsUsingEquals_thenSuccess() {
+        Map<String, Map<Integer, String>> outerBakedGoodsMap4 = new HashMap<>();
+        outerBakedGoodsMap4.putAll(actualBakedGoodsMap);
+
+        assertEquals(actualBakedGoodsMap, outerBakedGoodsMap4);
+
+        Map<Integer, Map<Integer, Address>> employeeMap1 = new HashMap<>();
+        employeeMap1.putAll(actualEmployeeMap);
+        assertEquals(actualEmployeeMap, employeeMap1);
+    }
+
+    @Test
+    public void whenAddElementinHashMaps_thenSuccess() {
+        assertEquals(actualBakedGoodsMap.get("Cake").size(), 5);
+        actualBakedGoodsMap.get("Cake").put(6, "Cranberry");
+        assertEquals(actualBakedGoodsMap.get("Cake").size(), 6);
+    }
+
+    @Test
+    public void whenDeleteElementinHashMaps_thenSuccess() {
+        assertNotEquals(actualBakedGoodsMap.get("Cake").get(5), null);
+        actualBakedGoodsMap.get("Cake").remove(5);
+        assertEquals(actualBakedGoodsMap.get("Cake").get(5), null);
+
+        actualBakedGoodsMap.put("Eclair", new HashMap<Integer, String>() {
+            {
+                put(1, "Dark Chocolate");
+            }
+        });
+
+        assertNotEquals(actualBakedGoodsMap.get("Eclair").get(1), null);
+        actualBakedGoodsMap.get("Eclair").remove(1);
+        assertEquals(actualBakedGoodsMap.get("Eclair").get(1), null);
+
+        actualBakedGoodsMap.put("Eclair", new HashMap<Integer, String>() {
+            {
+                put(1, "Dark Chocolate");
+            }
+        });
+
+        assertNotEquals(actualBakedGoodsMap.get("Eclair"), null);
+        actualBakedGoodsMap.remove("Eclair");
+        assertEquals(actualBakedGoodsMap.get("Eclair"), null);
+    }
+
+    @Test
+    public void whenFlattenMap_thenRemovesNesting() {
+
+        Map<String, String> flattenedBakedGoodsMap = mUtil.flattenMap(actualBakedGoodsMap);
+        assertThat(flattenedBakedGoodsMap, IsMapContaining.hasKey("Donut.2"));
+
+        Map<String, String> flattenedEmployeeAddressMap = mUtil.flattenMap(actualEmployeeAddressMap);
+        assertThat(flattenedEmployeeAddressMap, IsMapContaining.hasKey("200.Bag End"));
+    }
+
+    @Before
+    public void buildMaps() {
+
+        batterList = Arrays.asList("Mulberry", "Cranberry", "Blackberry", "Mixed fruit", "Orange");
+
+        actualBakedGoodsMap.put("Cake", mUtil.buildInnerMap(batterList));
+
+        batterList = new ArrayList<>();
+        batterList = Arrays.asList("Candy", "Dark Chocolate", "Chocolate", "Jam filled", "Pineapple");
+
+        actualBakedGoodsMap.put("Donut", mUtil.buildInnerMap(batterList));
+
+        listEmployee.add(new Employee(1, new Address(124, "Timbuktoo"), "Thorin Oakenshield"));
+        listEmployee.add(new Employee(2, new Address(100, "Misty Lanes"), "Balin"));
+        listEmployee.add(new Employee(3, new Address(156, "Brambles Lane"), "Bofur"));
+        listEmployee.add(new Employee(4, new Address(200, "Bag End"), "Bilbo Baggins"));
+        listEmployee.add(new Employee(5, new Address(23, "Rivendell"), "Elrond"));
+
+        actualEmployeeAddressMap = mUtil.createNestedMapfromStream(listEmployee);
+
+        actualEmployeeMap = mUtil.createNestedObjectMap(listEmployee);
+
+    }
+
+    private Map<Integer, Map<Integer, Address>> setupAddressObjectMap() {
+
+        Map<Integer, Map<Integer, Address>> expectedMap = new HashMap<>();
+
+        expectedMap.put(1, new HashMap<Integer, Address>() {
+            {
+                put(124, new Address(124, "Timbuktoo"));
+            }
+        });
+        expectedMap.put(2, new HashMap<Integer, Address>() {
+            {
+                put(100, new Address(100, "Misty Lanes"));
+            }
+        });
+        expectedMap.put(3, new HashMap<Integer, Address>() {
+            {
+                put(156, new Address(156, "Brambles Lane"));
+            }
+        });
+        expectedMap.put(4, new HashMap<Integer, Address>() {
+            {
+                put(200, new Address(200, "Bag End"));
+            }
+        });
+        expectedMap.put(5, new HashMap<Integer, Address>() {
+            {
+                put(23, new Address(23, "Rivendell"));
+            }
+        });
+        return expectedMap;
+    }
+
+}

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

@@ -15,11 +15,6 @@
     </parent>
 
     <dependencies>
-        <dependency>
-            <groupId>org.junit.vintage</groupId>
-            <artifactId>junit-vintage-engine</artifactId>
-            <scope>test</scope>
-        </dependency>
         <dependency>
             <groupId>com.googlecode.thread-weaver</groupId>
             <artifactId>threadweaver</artifactId>
@@ -31,6 +26,12 @@
             <artifactId>tempus-fugit</artifactId>
             <version>${tempus-fugit.version}</version>
             <scope>test</scope>
+            <exclusions>
+                <exclusion>
+                    <groupId>junit</groupId>
+                    <artifactId>junit</artifactId>
+                </exclusion>
+            </exclusions>
         </dependency>
         <dependency>
             <groupId>com.googlecode.multithreadedtc</groupId>

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

@@ -2,3 +2,4 @@
 ### Relevant Articles:
 
 - [Java Naming and Directory Interface Overview](https://www.baeldung.com/jndi)
+- [LDAP Authentication Using Pure Java](https://www.baeldung.com/java-ldap-auth)