Merge branch 'master' into task/JAVA-26765

2023-11-30 00:58:57 +01:00
parent 179e6e5de2 6ecf4f2bd9
commit f3e865d163
244 changed files with 3134 additions and 379 deletions
@@ -7,14 +7,14 @@ import org.springframework.context.annotation.Configuration;
 import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder;
 import org.springframework.security.config.annotation.web.builders.HttpSecurity;
 import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
-import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
 import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
 import org.springframework.security.crypto.password.PasswordEncoder;
+import org.springframework.security.web.SecurityFilterChain;
 import org.springframework.security.web.authentication.www.BasicAuthenticationFilter;

@Configuration
@EnableWebSecurity
-public class CustomWebSecurityConfigurerAdapter extends WebSecurityConfigurerAdapter {
+public class CustomWebSecurityConfigurerAdapter {

    @Autowired private RestAuthenticationEntryPoint authenticationEntryPoint;

@@ -27,8 +27,8 @@ public class CustomWebSecurityConfigurerAdapter extends WebSecurityConfigurerAda
          .authorities("ROLE_USER");
    }

-    @Override
-    protected void configure(HttpSecurity http) throws Exception {
+    @Bean
+    public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
        http
          .authorizeRequests()
          .antMatchers("/securityNone")
@@ -40,6 +40,8 @@ public class CustomWebSecurityConfigurerAdapter extends WebSecurityConfigurerAda
          .authenticationEntryPoint(authenticationEntryPoint);

        http.addFilterAfter(new CustomFilter(), BasicAuthenticationFilter.class);
+
+        return http.build();
    }
    
    @Bean
@@ -191,7 +191,7 @@
        <bval.version>2.0.6</bval.version>
        <javax.validation.validation-api.version>2.0.1.Final</javax.validation.validation-api.version>
        <meecrowave-junit.version>1.2.15</meecrowave-junit.version>
-        <okhttp.version>3.10.0</okhttp.version>
+        <okhttp.version>4.12.0</okhttp.version>
        <meecrowave-jpa.version>1.2.15</meecrowave-jpa.version>
        <meecrowave-core.version>1.2.15</meecrowave-core.version>
        <meecrowave-maven-plugin.version>1.2.15</meecrowave-maven-plugin.version>
@@ -9,3 +9,4 @@
 - [Migrate From Java 8 to Java 17](https://www.baeldung.com/java-migrate-8-to-17)
 - [Format Multiple ‘or’ Conditions in an If Statement in Java](https://www.baeldung.com/java-multiple-or-conditions-if-statement)
 - [Get All Record Fields and Its Values via Reflection](https://www.baeldung.com/java-reflection-record-fields-values)
+- [Context-Specific Deserialization Filters in Java 17](https://www.baeldung.com/java-context-specific-deserialization-filters)
@@ -0,0 +1,47 @@
+package com.baeldung.array.conversions;
+
+import org.junit.Test;
+
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.nio.ByteBuffer;
+import java.nio.CharBuffer;
+import java.nio.charset.StandardCharsets;
+
+import static org.junit.Assert.assertArrayEquals;
+
+public class ByteToCharArrayUnitTest {
+    public static byte[] byteArray = {65, 66, 67, 68};
+    public static char[] expected = {'A', 'B', 'C', 'D'};
+
+    @Test
+    public void givenByteArray_WhenUsingStandardCharsets_thenConvertToCharArray() {
+        char[] charArray = new String(byteArray, StandardCharsets.UTF_8).toCharArray();
+        assertArrayEquals(expected, charArray);
+    }
+
+    @Test
+    public void givenByteArray_WhenUsingSUsingStreams_thenConvertToCharArray() throws IOException {
+        ByteArrayInputStream inputStream = new ByteArrayInputStream(byteArray);
+        InputStreamReader reader = new InputStreamReader(inputStream);
+        ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
+        int data;
+        while ((data = reader.read()) != -1) {
+            char ch = (char) data;
+            outputStream.write(ch);
+        }
+        char[] charArray = outputStream.toString().toCharArray();
+        assertArrayEquals(expected, charArray);
+    }
+
+    @Test
+    public void givenByteArray_WhenUsingCharBuffer_thenConvertToCharArray() {
+        ByteBuffer byteBuffer = ByteBuffer.wrap(byteArray);
+        CharBuffer charBuffer = StandardCharsets.UTF_8.decode(byteBuffer);
+        char[] charArray = new char[charBuffer.remaining()];
+        charBuffer.get(charArray);
+        assertArrayEquals(expected, charArray);
+    }
+}
@@ -10,4 +10,5 @@
 - [Remove Elements From a Queue Using Loop](https://www.baeldung.com/java-remove-elements-queue)
 - [Intro to Vector Class in Java](https://www.baeldung.com/java-vector-guide)
 - [HashSet toArray() Method in Java](https://www.baeldung.com/java-hashset-toarray)
+- [Time Complexity of Java Collections Sort in Java](https://www.baeldung.com/java-time-complexity-collections-sort)
 - More articles: [[<-- prev]](/core-java-modules/core-java-collections-4)
@@ -4,4 +4,5 @@
 - [How to Write Hashmap to CSV File](https://www.baeldung.com/java-write-hashmap-csv)
 - [How to Get First or Last Entry From a LinkedHashMap in Java](https://www.baeldung.com/java-linkedhashmap-first-last-key-value-pair)
 - [How to Write and Read a File with a Java HashMap](https://www.baeldung.com/java-hashmap-write-read-file)
+- [Limiting the Max Size of a HashMap in Java](https://www.baeldung.com/java-hashmap-max-size)
 - More articles: [[<-- prev]](/core-java-modules/core-java-collections-maps-6)
@@ -38,6 +38,16 @@
            <artifactId>guava</artifactId>
            <version>32.1.2-jre</version>
        </dependency>
+        <dependency>
+            <groupId>org.openjdk.jmh</groupId>
+            <artifactId>jmh-core</artifactId>
+            <version>1.37</version>
+        </dependency>
+        <dependency>
+            <groupId>org.openjdk.jmh</groupId>
+            <artifactId>jmh-generator-annprocess</artifactId>
+            <version>1.37</version>
+        </dependency>
    </dependencies>

    <build>
@@ -0,0 +1,25 @@
+package com.baeldung.map;
+
+import java.util.HashMap;
+
+public class HashMapWithMaxSizeLimit<K, V> extends HashMap<K, V> {
+    private int maxSize = -1;
+    
+    public HashMapWithMaxSizeLimit() {
+        super();
+    }
+
+    public HashMapWithMaxSizeLimit(int maxSize) {
+        super();
+        this.maxSize = maxSize;
+    }
+
+    @Override
+    public V put(K key, V value) {
+        if (this.maxSize == -1 || this.containsKey(key) || this.size() < this.maxSize) {
+            return super.put(key, value);
+        }
+        throw new RuntimeException("Max size exceeded!");
+    }
+
+}
@@ -1,4 +1,4 @@
-package com.baeldung.map;
+package com.baeldung.map.incrementmapkey;

 import java.util.HashMap;
 import java.util.Map;
@@ -0,0 +1,68 @@
+package com.baeldung.map.incrementmapkey;
+
+import java.util.concurrent.TimeUnit;
+
+import org.openjdk.jmh.annotations.Benchmark;
+import org.openjdk.jmh.annotations.BenchmarkMode;
+import org.openjdk.jmh.annotations.Fork;
+import org.openjdk.jmh.annotations.Mode;
+import org.openjdk.jmh.annotations.OutputTimeUnit;
+import org.openjdk.jmh.annotations.Scope;
+import org.openjdk.jmh.annotations.State;
+
+@State(Scope.Benchmark)
+public class BenchmarkMapMethodsJMH {
+    @Benchmark
+    @BenchmarkMode(Mode.AverageTime)
+    @OutputTimeUnit(TimeUnit.NANOSECONDS)
+    @Fork(value = 1, warmups = 1)
+    public void benchMarkGuavaMap() {
+        IncrementMapValueWays im = new IncrementMapValueWays();
+        im.charFrequencyUsingAtomicMap(getString());
+    }
+
+    @Benchmark
+    @BenchmarkMode(Mode.AverageTime)
+    @OutputTimeUnit(TimeUnit.NANOSECONDS)
+    @Fork(value = 1, warmups = 1)
+    public void benchContainsKeyMap() {
+        IncrementMapValueWays im = new IncrementMapValueWays();
+        im.charFrequencyUsingContainsKey(getString());
+    }
+
+    @Benchmark
+    @BenchmarkMode(Mode.AverageTime)
+    @OutputTimeUnit(TimeUnit.NANOSECONDS)
+    @Fork(value = 1, warmups = 1)
+    public void benchMarkComputeMethod() {
+        IncrementMapValueWays im = new IncrementMapValueWays();
+        im.charFrequencyUsingCompute(getString());
+    }
+
+    @Benchmark
+    @BenchmarkMode(Mode.AverageTime)
+    @OutputTimeUnit(TimeUnit.NANOSECONDS)
+    @Fork(value = 1, warmups = 1)
+    public void benchMarkMergeMethod() {
+        IncrementMapValueWays im = new IncrementMapValueWays();
+        im.charFrequencyUsingMerge(getString());
+    }
+
+    public static void main(String[] args) throws Exception {
+        org.openjdk.jmh.Main.main(args);
+    }
+
+    private String getString() {
+        return
+          "Once upon a time in a quaint village nestled between rolling hills and whispering forests, there lived a solitary storyteller named Elias. Elias was known for spinning tales that transported listeners to magical realms and awakened forgotten dreams.\n"
+            + "\n"
+            + "His favorite spot was beneath an ancient oak tree, its sprawling branches offering shade to those who sought refuge from the bustle of daily life. Villagers of all ages would gather around Elias, their faces illuminated by the warmth of his stories.\n"
+            + "\n" + "One evening, as dusk painted the sky in hues of orange and purple, a curious young girl named Lily approached Elias. Her eyes sparkled with wonder as she asked for a tale unlike any other.\n" + "\n"
+            + "Elias smiled, sensing her thirst for adventure, and began a story about a forgotten kingdom veiled by mist, guarded by mystical creatures and enchanted by ancient spells. With each word, the air grew thick with anticipation, and the listeners were transported into a world where magic danced on the edges of reality.\n"
+            + "\n" + "As Elias weaved the story, Lily's imagination took flight. She envisioned herself as a brave warrior, wielding a shimmering sword against dark forces, her heart fueled by courage and kindness.\n" + "\n"
+            + "The night wore on, but the spell of the tale held everyone captive. The villagers laughed, gasped, and held their breaths, journeying alongside the characters through trials and triumphs.\n" + "\n"
+            + "As the final words lingered in the air, a sense of enchantment settled upon the listeners. They thanked Elias for the gift of his storytelling, each carrying a piece of the magical kingdom within their hearts.\n" + "\n"
+            + "Lily, inspired by the story, vowed to cherish the spirit of adventure and kindness in her own life. With a newfound spark in her eyes, she bid Elias goodnight, already dreaming of the countless adventures awaiting her.\n" + "\n"
+            + "Under the star-studded sky, Elias remained beneath the ancient oak, his heart aglow with the joy of sharing tales that ignited imagination and inspired dreams. And as the night embraced the village, whispers of the enchanted kingdom lingered in the breeze, promising endless possibilities to those who dared to believe.";
+    }
+}
@@ -1,4 +1,4 @@
-package com.baeldung.map;
+package com.baeldung.map.incrementmapkey;

 import java.util.HashMap;
 import java.util.Map;
@@ -0,0 +1,60 @@
+package com.baeldung.map;
+
+import static org.junit.Assert.assertTrue;
+import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+import org.junit.jupiter.api.Test;
+
+class LimitMaxSizeHashMapByCustomHashMapUnitTest {
+
+    private final int MAX_SIZE = 4;
+    private HashMapWithMaxSizeLimit<Integer, String> hashMapWithMaxSizeLimit;
+
+    @Test
+    void givenCustomHashMapObject_whenThereIsNoLimit_thenDoesNotThrowException() {
+        hashMapWithMaxSizeLimit = new HashMapWithMaxSizeLimit<Integer, String>();
+        assertDoesNotThrow(() -> {
+            for (int i = 0; i < 10000; i++) {
+                hashMapWithMaxSizeLimit.put(i, i + "");
+            }
+        });
+    }
+
+    @Test
+    void givenCustomHashMapObject_whenLimitNotReached_thenDoesNotThrowException() {
+        hashMapWithMaxSizeLimit = new HashMapWithMaxSizeLimit<Integer, String>(MAX_SIZE);
+        assertDoesNotThrow(() -> {
+            for (int i = 0; i < 4; i++) {
+                hashMapWithMaxSizeLimit.put(i, i + "");
+            }
+        });
+    }
+
+    @Test
+    void givenCustomHashMapObject_whenReplacingValueWhenLimitIsReached_thenDoesNotThrowException() {
+        hashMapWithMaxSizeLimit = new HashMapWithMaxSizeLimit<Integer, String>(MAX_SIZE);
+        assertDoesNotThrow(() -> {
+            hashMapWithMaxSizeLimit.put(1, "One");
+            hashMapWithMaxSizeLimit.put(2, "Two");
+            hashMapWithMaxSizeLimit.put(3, "Three");
+            hashMapWithMaxSizeLimit.put(4, "Four");
+            hashMapWithMaxSizeLimit.put(4, "4");
+        });
+    }
+
+    @Test
+    void givenCustomHashMapObject_whenLimitExceeded_thenThrowsException() {
+        hashMapWithMaxSizeLimit = new HashMapWithMaxSizeLimit<Integer, String>(MAX_SIZE);
+        Exception exception = assertThrows(RuntimeException.class, () -> {
+            for (int i = 0; i < 5; i++) {
+                hashMapWithMaxSizeLimit.put(i, i + "");
+            }
+        });
+
+        String messageThrownWhenSizeExceedsLimit = "Max size exceeded!";
+        String actualMessage = exception.getMessage();
+        assertTrue(actualMessage.equals(messageThrownWhenSizeExceedsLimit));
+    }
+
+}
@@ -0,0 +1,38 @@
+package com.baeldung.map;
+
+import static org.junit.jupiter.api.Assertions.assertArrayEquals;
+
+import java.util.LinkedHashMap;
+import java.util.Map;
+
+import org.junit.jupiter.api.Test;
+
+class LimitMaxSizeHashMapByLinkedHashMapUnitTest {
+
+    @Test
+    void givenLinkedHashMapObject_whenAddingNewEntry_thenEldestEntryIsRemoved() {
+        final int MAX_SIZE = 4;
+        LinkedHashMap<Integer, String> linkedHashMap;
+        linkedHashMap = new LinkedHashMap<Integer, String>() {
+            private static final long serialVersionUID = 1L;
+            
+            @Override
+            protected boolean removeEldestEntry(Map.Entry<Integer, String> eldest) {
+                return size() > MAX_SIZE;
+            }
+        };
+        linkedHashMap.put(1, "One");
+        linkedHashMap.put(2, "Two");
+        linkedHashMap.put(3, "Three");
+        linkedHashMap.put(4, "Four");
+        linkedHashMap.put(5, "Five");
+        String[] expectedArrayAfterFive = { "Two", "Three", "Four", "Five" };
+        assertArrayEquals(expectedArrayAfterFive, linkedHashMap.values()
+            .toArray());
+        linkedHashMap.put(6, "Six");
+        String[] expectedArrayAfterSix = { "Three", "Four", "Five", "Six" };
+        assertArrayEquals(expectedArrayAfterSix, linkedHashMap.values()
+            .toArray());
+    }
+
+}
@@ -0,0 +1,141 @@
+package com.baeldung.map;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+
+import org.junit.jupiter.api.Test;
+
+class Player {
+    private String name;
+    private Integer score = 0;
+
+    public Player(String name, Integer score) {
+        this.name = name;
+        this.score = score;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) {
+            return true;
+        }
+        if (!(o instanceof Player)) {
+            return false;
+        }
+
+        Player player = (Player) o;
+
+        if (!Objects.equals(name, player.name)) {
+            return false;
+        }
+        return Objects.equals(score, player.score);
+    }
+
+    @Override
+    public int hashCode() {
+        int result = name != null ? name.hashCode() : 0;
+        result = 31 * result + (score != null ? score.hashCode() : 0);
+        return result;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public int getScore() {
+        return score;
+    }
+}
+
+public class LinkedHashMapSortByValueUnitTest {
+    private static LinkedHashMap<String, Integer> MY_MAP = new LinkedHashMap<>();
+
+    static {
+        MY_MAP.put("key a", 4);
+        MY_MAP.put("key b", 1);
+        MY_MAP.put("key c", 3);
+        MY_MAP.put("key d", 2);
+        MY_MAP.put("key e", 5);
+    }
+
+    private static LinkedHashMap<String, Integer> EXPECTED_MY_MAP = new LinkedHashMap<>();
+
+    static {
+        EXPECTED_MY_MAP.put("key b", 1);
+        EXPECTED_MY_MAP.put("key d", 2);
+        EXPECTED_MY_MAP.put("key c", 3);
+        EXPECTED_MY_MAP.put("key a", 4);
+        EXPECTED_MY_MAP.put("key e", 5);
+    }
+
+    private static final LinkedHashMap<String, Player> PLAYERS = new LinkedHashMap<>();
+    static {
+        PLAYERS.put("player a", new Player("Eric", 9));
+        PLAYERS.put("player b", new Player("Kai", 7));
+        PLAYERS.put("player c", new Player("Amanda", 20));
+        PLAYERS.put("player d", new Player("Kevin", 4));
+    }
+
+    private static final LinkedHashMap<String, Player> EXPECTED_PLAYERS = new LinkedHashMap<>();
+
+    static {
+        EXPECTED_PLAYERS.put("player d", new Player("Kevin", 4));
+        EXPECTED_PLAYERS.put("player b", new Player("Kai", 7));
+        EXPECTED_PLAYERS.put("player a", new Player("Eric", 9));
+        EXPECTED_PLAYERS.put("player c", new Player("Amanda", 20));
+    }
+
+    @Test
+    void whenUsingCollectionSort_thenGetExpectedResult() {
+        List<Map.Entry<String, Integer>> entryList = new ArrayList<>(MY_MAP.entrySet());
+        Collections.sort(entryList, new Comparator<Map.Entry<String, Integer>>() {
+            @Override
+            public int compare(Map.Entry<String, Integer> o1, Map.Entry<String, Integer> o2) {
+                return o1.getValue()
+                  .compareTo(o2.getValue());
+            }
+        });
+
+        LinkedHashMap<String, Integer> result = new LinkedHashMap<>();
+        for (Map.Entry<String, Integer> e : entryList) {
+            result.put(e.getKey(), e.getValue());
+        }
+        assertEquals(EXPECTED_MY_MAP, result);
+    }
+
+    @Test
+    void whenUsingEntrycomparingByValueAndFillAMap_thenGetExpectedResult() {
+        LinkedHashMap<String, Integer> result = new LinkedHashMap<>();
+        MY_MAP.entrySet()
+          .stream()
+          .sorted(Map.Entry.comparingByValue())
+          .forEachOrdered(entry -> result.put(entry.getKey(), entry.getValue()));
+        assertEquals(EXPECTED_MY_MAP, result);
+    }
+
+    @Test
+    void whenUsingEntrycomparingByValueAndCollect_thenGetExpectedResult() {
+        LinkedHashMap<String, Integer> result = MY_MAP.entrySet()
+          .stream()
+          .sorted(Map.Entry.comparingByValue())
+          .collect(LinkedHashMap::new, (map, entry) -> map.put(entry.getKey(), entry.getValue()), Map::putAll);
+        assertEquals(EXPECTED_MY_MAP, result);
+    }
+
+    @Test
+    void whenUsingEntrycomparingByValueAndComparator_thenGetExpectedResult() {
+        LinkedHashMap<String, Player> result = PLAYERS.entrySet()
+          .stream()
+          .sorted(Map.Entry.comparingByValue(Comparator.comparing(Player::getScore)))
+          .collect(LinkedHashMap::new, (map, entry) -> map.put(entry.getKey(), entry.getValue()), Map::putAll);
+        assertEquals(EXPECTED_PLAYERS, result);
+    }
+
+}
@@ -1,4 +1,4 @@
-package com.baeldung.map;
+package com.baeldung.map.incrementmapkey;

 import java.util.Map;
 import java.util.concurrent.ConcurrentHashMap;
@@ -9,6 +9,8 @@ import java.util.stream.Stream;
 import org.junit.Assert;
 import org.junit.Test;

+import com.baeldung.map.incrementmapkey.IncrementMapValueWays;
+
 public class IncrementMapValueUnitTest {

    @Test
@@ -1,3 +1,4 @@

 ### Relevant Articles:
 - [Why wait() Requires Synchronization?](https://www.baeldung.com/java-wait-necessary-synchronization)
+- [Working with Exceptions in Java CompletableFuture](https://www.baeldung.com/java-exceptions-completablefuture)
@@ -2,7 +2,7 @@ package com.baeldung.wait_synchronization;

 public class ConditionChecker {

-    private volatile Boolean jobIsDone;
+    private volatile boolean jobIsDone;
    private final Object lock = new Object();

    public void ensureCondition() {
@@ -21,4 +21,4 @@ public class ConditionChecker {
            lock.notify();
        }
    }
-}
+}
@@ -159,7 +159,7 @@
    </profiles>

    <properties>
-        <maven-javadoc-plugin.version>3.0.0-M1</maven-javadoc-plugin.version>
+        <maven-javadoc-plugin.version>3.6.2</maven-javadoc-plugin.version>
        <source.version>1.8</source.version>
        <target.version>1.8</target.version>
        <ascii.version>0.3.2</ascii.version>
@@ -10,3 +10,4 @@ This module contains articles about converting between Java date and time object
 - [Convert Between LocalDateTime and ZonedDateTime](https://www.baeldung.com/java-localdatetime-zoneddatetime)
 - [Conversion From 12-Hour Time to 24-Hour Time in Java](https://www.baeldung.com/java-convert-time-format)
 - [Convert Epoch Time to LocalDate and LocalDateTime](https://www.baeldung.com/java-convert-epoch-localdate)
+- [Convert Timestamp String to Long in Java](https://www.baeldung.com/java-convert-timestamp-string-long)
@@ -33,7 +33,7 @@

    <properties>
        <!-- maven plugins -->
-        <maven-javadoc-plugin.version>3.0.0-M1</maven-javadoc-plugin.version>
+        <maven-javadoc-plugin.version>3.6.2</maven-javadoc-plugin.version>
        <source.version>1.8</source.version>
        <target.version>1.8</target.version>
    </properties>
@@ -61,7 +61,7 @@
    </build>

    <properties>
-        <maven-javadoc-plugin.version>3.0.0-M1</maven-javadoc-plugin.version>
+        <maven-javadoc-plugin.version>3.6.2</maven-javadoc-plugin.version>
        <wiremock.version>3.3.1</wiremock.version>
    </properties>

@@ -12,6 +12,10 @@ public class WriteCsvFileExample {
    }

    public String escapeSpecialCharacters(String data) {
+        if (data == null) {
+            throw new IllegalArgumentException("Input data cannot be null");
+        }
+        
        String escapedData = data.replaceAll("\\R", " ");
        if (data.contains(",") || data.contains("\"") || data.contains("'")) {
            data = data.replace("\"", "\"\"");
@@ -134,7 +134,7 @@

    <properties>
        <!-- maven plugins -->
-        <maven-javadoc-plugin.version>3.5.0</maven-javadoc-plugin.version>
+        <maven-javadoc-plugin.version>3.6.2</maven-javadoc-plugin.version>
        <hsqldb.version>2.7.1</hsqldb.version>
        <!-- Mime Type Libraries -->
        <tika.version>2.8.0</tika.version>
@@ -0,0 +1,16 @@
+<?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-ipc</artifactId>
+    <name>core-java-ipc</name>
+    <packaging>jar</packaging>
+
+    <parent>
+        <groupId>com.baeldung.core-java-modules</groupId>
+        <artifactId>core-java-modules</artifactId>
+        <version>0.0.1-SNAPSHOT</version>
+    </parent>
+
+</project>
@@ -0,0 +1,32 @@
+package com.baeldung.ipc;
+
+import org.junit.jupiter.api.Test;
+
+import java.nio.file.FileSystems;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.nio.file.StandardWatchEventKinds;
+import java.nio.file.WatchKey;
+import java.nio.file.WatchEvent;
+import java.nio.file.WatchService;
+
+
+public class DirectoryLiveTest {
+    @Test
+    public void consumer() throws Exception {
+        WatchService watchService = FileSystems.getDefault().newWatchService();
+        // Set this to an appropriate directory.
+        Path path = Paths.get("/tmp/ipc");
+
+        path.register(watchService, StandardWatchEventKinds.ENTRY_CREATE);
+
+        WatchKey key;
+        while ((key = watchService.take()) != null) {
+            for (WatchEvent<?> event : key.pollEvents()) {
+                // React to new file.
+                System.out.println(event);
+            }
+            key.reset();
+        }
+    }
+}
@@ -0,0 +1,52 @@
+package com.baeldung.ipc;
+
+import org.junit.jupiter.api.Test;
+
+import javax.management.JMX;
+import javax.management.MBeanServer;
+import javax.management.ObjectName;
+import javax.management.remote.JMXConnector;
+import javax.management.remote.JMXConnectorFactory;
+import javax.management.remote.JMXServiceURL;
+import java.lang.management.ManagementFactory;
+import java.util.concurrent.TimeUnit;
+
+public class JmxLiveTest {
+    /*
+     * This test needs to be run with the following system properties defined:
+     * -Dcom.sun.management.jmxremote=true
+     * -Dcom.sun.management.jmxremote.port=1234
+     * -Dcom.sun.management.jmxremote.authenticate=false
+     * -Dcom.sun.management.jmxremote.ssl=false
+     */
+    @Test
+    public void consumer() throws Exception {
+        ObjectName objectName = new ObjectName("com.baeldung.ipc:type=basic,name=test");
+        MBeanServer server = ManagementFactory.getPlatformMBeanServer();
+        server.registerMBean(new IPCTest(), objectName);
+
+        TimeUnit.MINUTES.sleep(50);
+    }
+
+    @Test
+    public void producer() throws Exception {
+        JMXServiceURL url = new JMXServiceURL("service:jmx:rmi:///jndi/rmi://localhost:1234/jmxrmi");
+        try (JMXConnector jmxc = JMXConnectorFactory.connect(url, null)) {
+            ObjectName objectName = new ObjectName("com.baeldung.ipc:type=basic,name=test");
+
+            IPCTestMBean mbeanProxy = JMX.newMBeanProxy(jmxc.getMBeanServerConnection(), objectName, IPCTestMBean.class, true);
+            mbeanProxy.sendMessage("Hello");
+        }
+    }
+
+    public interface IPCTestMBean {
+        void sendMessage(String message);
+    }
+
+    class IPCTest implements IPCTestMBean {
+        @Override
+        public void sendMessage(String message) {
+            System.out.println("Received message: " + message);
+        }
+    }
+}
@@ -0,0 +1,38 @@
+package com.baeldung.ipc;
+
+import org.junit.jupiter.api.Test;
+
+import java.io.BufferedReader;
+import java.io.InputStreamReader;
+import java.io.PrintWriter;
+import java.net.ServerSocket;
+import java.net.Socket;
+
+public class SocketsLiveTest {
+    @Test
+    public void consumer() throws Exception {
+        try (ServerSocket serverSocket = new ServerSocket(1234)) {
+            Socket clientSocket = serverSocket.accept();
+
+            PrintWriter out = new PrintWriter(clientSocket.getOutputStream(), true);
+            BufferedReader in = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));
+
+            String line;
+            while ((line = in.readLine()) != null) {
+                System.out.println("Received message: " + line);
+            }
+        }
+    }
+
+    @Test
+    public void producer() throws Exception {
+        try (Socket clientSocket = new Socket("localhost", 1234)) {
+            PrintWriter out = new PrintWriter(clientSocket.getOutputStream(), true);
+            BufferedReader in = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));
+
+            out.println("Hello");
+            
+            String response = in.readLine();
+        }
+    }
+}
@@ -274,7 +274,7 @@
        <mockito.version>4.6.1</mockito.version>
        <!-- maven plugins -->
        <javamoney.moneta.version>1.1</javamoney.moneta.version>
-        <maven-javadoc-plugin.version>3.0.0-M1</maven-javadoc-plugin.version>
+        <maven-javadoc-plugin.version>3.6.2</maven-javadoc-plugin.version>
        <onejar-maven-plugin.version>1.4.4</onejar-maven-plugin.version>
        <maven-shade-plugin.version>3.1.1</maven-shade-plugin.version>
        <maven-assembly-plugin.version>3.3.0</maven-assembly-plugin.version>
@@ -0,0 +1,16 @@
+package com.baeldung.returnfirstnonnull;
+
+class LazyEvaluate {
+
+    String methodA() {
+        return null;
+    }
+
+    String methodB() {
+        return "first non null";
+    }
+
+    String methodC() {
+        return "second non null";
+    }
+}
@@ -0,0 +1,30 @@
+package com.baeldung.returnfirstnonempty;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.Optional;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+public class ReturnFirstNonEmptyOptionalUnitTest {
+
+    private List<Optional<String>> optionals;
+
+    @BeforeEach
+    public void init() {
+        optionals = Arrays.asList(Optional.<String> empty(), Optional.of("first non empty"), Optional.of("second non empty"));
+    }
+
+    @Test
+    void givenListOfOptionals_whenStreaming_thenReturnFirstNonEmpty() {
+        Optional<String> object = optionals.stream()
+            .filter(Optional::isPresent)
+            .map(Optional::get)
+            .findFirst();
+
+        assertThat(object).contains("first non empty");
+    }
+}
--- a/Show More
+++ b/Show More