Merge branch 'eugenp:master' into master

2023-11-26 22:11:31 +02:00
parent 62fbe82afd 951dcdaee8
commit 044e23a7ad
103 changed files with 1777 additions and 171 deletions
@@ -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)
@@ -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)
@@ -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!");
+    }
+
+}
@@ -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,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)
@@ -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)
@@ -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();
+        }
+    }
+}
@@ -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");
+    }
+}
@@ -0,0 +1,77 @@
+package com.baeldung.returnfirstnonnull;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+
+import java.util.Objects;
+import java.util.Optional;
+import java.util.function.Supplier;
+import java.util.stream.Stream;
+
+import org.apache.commons.lang3.ObjectUtils;
+import org.junit.jupiter.api.Test;
+import org.mockito.Mockito;
+
+public class ReturnFirstNonNullLazyEvaluateUnitTest {
+
+    private final LazyEvaluate spy = Mockito.spy(new LazyEvaluate());
+
+    @Test
+    void givenChainOfMethods_whenUsingIfStatements_thenLazilyEvaluateMethodsUntilFirstNonNull() {
+        String object = spy.methodA();
+        if (object == null) {
+            object = spy.methodB();
+        }
+
+        if (object == null) {
+            object = spy.methodC();
+        }
+
+        assertEquals("first non null", object);
+        verify(spy, times(1)).methodA();
+        verify(spy, times(1)).methodB();
+        verify(spy, times(0)).methodC();
+    }
+
+    @Test
+    void givenChainOfMethods_whenUsingApacheCommonsLang3_thenReturnFirstNonNull() {
+        String object = ObjectUtils.getFirstNonNull(spy::methodA, spy::methodB, spy::methodC);
+
+        assertEquals("first non null", object);
+        verify(spy, times(1)).methodA();
+        verify(spy, times(1)).methodB();
+        verify(spy, times(0)).methodC();
+    }
+
+    @Test
+    void givenChainOfMethods_whenUsingSupplierInterface_thenLazilyEvaluateMethodsUntilFirstNonNull() {
+        Optional<String> object = Stream.<Supplier<String>> of(spy::methodA, spy::methodB, spy::methodC)
+            .map(Supplier::get)
+            .filter(Objects::nonNull)
+            .findFirst();
+
+        assertThat(object).contains("first non null");
+        verify(spy, times(1)).methodA();
+        verify(spy, times(1)).methodB();
+        verify(spy, times(0)).methodC();
+    }
+
+    @Test
+    void givenNonNullObjectAndFallbackMethod_whenUsingApacheCommonsLang3_thenReturnFirstNonNull() {
+        String nonNullObject = spy.methodB();
+        String object = ObjectUtils.getIfNull(nonNullObject, spy::methodC);
+
+        assertEquals("first non null", object);
+        verify(spy, times(0)).methodC();
+    }
+
+    @Test
+    void givenNullObjectAndFallbackMethod_whenUsingApacheCommonsLang3_thenReturnFirstNonNull() {
+        String nullObject = null;
+        String object = ObjectUtils.getIfNull(nullObject, spy::methodB);
+
+        assertEquals("first non null", object);
+    }
+}
@@ -0,0 +1,81 @@
+package com.baeldung.returnfirstnonnull;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.Objects;
+import java.util.Optional;
+
+import org.apache.commons.lang3.ObjectUtils;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import com.google.common.base.MoreObjects;
+import com.google.common.base.Predicates;
+import com.google.common.collect.Iterables;
+
+public class ReturnFirstNonNullUnitTest {
+
+    private List<String> objects;
+
+    @BeforeEach
+    public void init() {
+        objects = Arrays.asList(null, "first non null", "second nun null");
+    }
+
+    @Test
+    void givenListOfObjects_whenFilterIsLambdaNullCheckInStream_thenReturnFirstNonNull() {
+        Optional<String> object = objects.stream()
+            .filter(o -> o != null)
+            .findFirst();
+
+        assertThat(object).contains("first non null");
+    }
+
+    @Test
+    void givenListOfObjects_whenFilterIsMethodRefNullCheckInStream_thenReturnFirstNonNull() {
+        Optional<String> object = objects.stream()
+            .filter(Objects::nonNull)
+            .findFirst();
+
+        assertThat(object).contains("first non null");
+    }
+
+    @Test
+    void givenListOfObjects_whenIteratingWithForLoop_thenReturnFirstNonNull() {
+        String object = null;
+        for (int i = 0; i < objects.size(); i++) {
+            if (objects.get(i) != null) {
+                object = objects.get(i);
+                break;
+            }
+        }
+
+        assertEquals("first non null", object);
+    }
+
+    @Test
+    void givenListOfObjects_whenUsingApacheCommonsLang3_thenReturnFirstNonNull() {
+        String object = ObjectUtils.firstNonNull(objects.toArray(new String[0]));
+
+        assertEquals("first non null", object);
+    }
+
+    @Test
+    void givenListOfObjects_whenUsingGoogleGuavaIterables_thenReturnFirstNonNull() {
+        String object = Iterables.find(objects, Predicates.notNull());
+
+        assertEquals("first non null", object);
+    }
+
+    @Test
+    void givenTwoObjects_whenUsingGoogleGuavaMoreObjects_thenReturnFirstNonNull() {
+        String nullObject = null;
+        String nonNullObject = "first non null";
+        String object = MoreObjects.firstNonNull(nullObject, nonNullObject);
+
+        assertEquals("first non null", object);
+    }
+}
@@ -26,13 +26,25 @@ public class Rectangle {
        this.topRight = topRight;
    }

-    public boolean isOverlapping(Rectangle other) {
-        // one rectangle is to the top of the other
-        if (this.topRight.getY() < other.bottomLeft.getY() || this.bottomLeft.getY() > other.topRight.getY()) {
+    public boolean isOverlapping(Rectangle comparedRectangle) {
+        // one rectangle is to the top of the comparedRectangle
+        if (this.topRight.getY() < comparedRectangle.bottomLeft.getY() || this.bottomLeft.getY() > comparedRectangle.topRight.getY()) {
            return false;
        }
-        // one rectangle is to the left of the other
-        if (this.topRight.getX() < other.bottomLeft.getX() || this.bottomLeft.getX() > other.topRight.getX()) {
+        // one rectangle is to the left of the comparedRectangle
+        if (this.topRight.getX() < comparedRectangle.bottomLeft.getX() || this.bottomLeft.getX() > comparedRectangle.topRight.getX()) {
+            return false;
+        }
+        return true;
+    }
+
+    public boolean isOverlappingWithoutBorders(Rectangle comparedRectangle) {
+        // one rectangle is to the top of the comparedRectangle
+        if (this.topRight.getY() <= comparedRectangle.bottomLeft.getY() || this.bottomLeft.getY() >= comparedRectangle.topRight.getY()) {
+            return false;
+        }
+        // one rectangle is to the left of the comparedRectangle
+        if (this.topRight.getX() <= comparedRectangle.bottomLeft.getX() || this.bottomLeft.getX() >= comparedRectangle.topRight.getX()) {
            return false;
        }
        return true;
@@ -1,7 +1,8 @@
 package com.baeldung.algorithms.rectanglesoverlap;

-import static org.junit.Assert.assertTrue;
 import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
 import org.junit.Test;

 public class RectangleUnitTest {
@@ -36,4 +37,18 @@ public class RectangleUnitTest {
        assertFalse(rectangle1.isOverlapping(rectangle2));
    }

+    @Test
+    public void givenAdjacentRectangles_whensOverlappingCalled_shouldReturnTrue() {
+Rectangle rectangle1 = new Rectangle(new Point(0, 0), new Point(5, 14));
+Rectangle rectangle2 = new Rectangle(new Point(5, 0), new Point(17, 14));
+assertTrue(rectangle1.isOverlapping(rectangle2));
+    }
+
+    @Test
+    public void givenAdjacentRectangles_whensOverlappingWithoutBordersCalled_shouldReturnFalse() {
+        Rectangle rectangle1 = new Rectangle(new Point(0, 0), new Point(5, 14));
+        Rectangle rectangle2 = new Rectangle(new Point(5, 0), new Point(17, 14));
+        assertFalse(rectangle1.isOverlappingWithoutBorders(rectangle2));
+    }
+
 }
@@ -10,3 +10,4 @@ This module contains articles about types in Java
 - [Filling a List With All Enum Values in Java](https://www.baeldung.com/java-enum-values-to-list)
 - [Comparing a String to an Enum Value in Java](https://www.baeldung.com/java-comparing-string-to-enum)
 - [Implementing toString() on enums in Java](https://www.baeldung.com/java-enums-tostring)
+- [Checking if an Object’s Type Is Enum](https://www.baeldung.com/java-check-object-enum)
@@ -56,7 +56,7 @@

    <properties>
        <apache.commons-validator.version>1.7</apache.commons-validator.version>
-        <jsoup.version>1.15.4</jsoup.version>
+        <jsoup.version>1.16.2</jsoup.version>
    </properties>

 </project>
@@ -5,3 +5,4 @@
 - [Check if a String Contains Only Unicode Letters](https://www.baeldung.com/java-string-all-unicode-characters)
 - [Create a Mutable String in Java](https://www.baeldung.com/java-mutable-string)
 - [Check if a String Contains a Number Value in Java](https://www.baeldung.com/java-string-number-presence)
+- [Difference Between String isEmpty() and isBlank()](https://www.baeldung.com/java-string-isempty-vs-isblank)
@@ -24,12 +24,6 @@
            <artifactId>commons-text</artifactId>
            <version>${commons-text.version}</version>
        </dependency>
-        <dependency>
-            <groupId>org.liquibase</groupId>
-            <artifactId>liquibase-core</artifactId>
-            <version>4.9.1</version>
-            <scope>test</scope>
-        </dependency>
        <dependency>
            <groupId>org.junit.jupiter</groupId>
            <artifactId>junit-jupiter</artifactId>
@@ -39,7 +33,7 @@
        <dependency>
            <groupId>org.liquibase</groupId>
            <artifactId>liquibase-core</artifactId>
-            <version>4.9.1</version>
+            <version>${liquibase.core.version}</version>
            <scope>test</scope>
        </dependency>
        <dependency>
@@ -67,6 +61,7 @@
        <maven.compiler.target>11</maven.compiler.target>
        <apache.commons.lang3.version>3.13.0</apache.commons.lang3.version>
        <commons-text.version>1.10.0</commons-text.version>
+        <liquibase.core.version>4.25.0</liquibase.core.version>
    </properties>

 </project>
@@ -1,6 +1,6 @@
 package com.baeldung.centertext;

-import liquibase.repackaged.org.apache.commons.lang3.StringUtils;
+import org.apache.commons.lang3.StringUtils;
 import org.junit.Assert;
 import org.junit.jupiter.api.Test;

@@ -0,0 +1,21 @@
+<?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-string-swing</artifactId>
+    <name>core-java-string-swing</name>
+    <packaging>jar</packaging>
+
+    <parent>
+        <groupId>com.baeldung.core-java-modules</groupId>
+        <artifactId>core-java-modules</artifactId>
+        <version>0.0.1-SNAPSHOT</version>
+    </parent>
+    <properties>
+        <maven.compiler.source>20</maven.compiler.source>
+        <maven.compiler.target>20</maven.compiler.target>
+        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+    </properties>
+
+</project>
@@ -0,0 +1,55 @@
+package com.baeldung.customfont;
+
+import javax.swing.*;
+import java.awt.*;
+import java.io.File;
+import java.io.IOException;
+import java.util.Arrays;
+import java.util.List;
+
+public class CustomFonts {
+    public static void main(String[] args) {
+        usingCustomFonts();
+    }
+
+    public static void usingCustomFonts() {
+        final GraphicsEnvironment GE = GraphicsEnvironment.getLocalGraphicsEnvironment();
+        final List<String> AVAILABLE_FONT_FAMILY_NAMES = Arrays.asList(GE.getAvailableFontFamilyNames());
+        try {
+            final List<File> LIST = Arrays.asList(
+                    new File("font/JetBrainsMono/JetBrainsMono-Thin.ttf"),
+                    new File("font/JetBrainsMono/JetBrainsMono-Light.ttf"),
+                    new File("font/Roboto/Roboto-Light.ttf"),
+                    new File("font/Roboto/Roboto-Regular.ttf"),
+                    new File("font/Roboto/Roboto-Medium.ttf")
+            );
+            for (File LIST_ITEM : LIST) {
+                if (LIST_ITEM.exists()) {
+                    Font FONT = Font.createFont(Font.TRUETYPE_FONT, LIST_ITEM);
+                    if (!AVAILABLE_FONT_FAMILY_NAMES.contains(FONT.getFontName())) {
+                        GE.registerFont(FONT);
+                    }
+                }
+            }
+        } catch (FontFormatException | IOException exception) {
+            JOptionPane.showMessageDialog(null, exception.getMessage());
+        }
+
+
+        JFrame frame = new JFrame("Custom Font Example");
+        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
+        frame.setLayout(new FlowLayout());
+
+        JLabel label1 = new JLabel("TEXT1");
+        label1.setFont(new Font("Roboto Medium", Font.PLAIN, 17));
+
+        JLabel label2 = new JLabel("TEXT2");
+        label2.setFont(new Font("JetBrainsMono-Thin", Font.PLAIN, 17));
+
+        frame.add(label1);
+        frame.add(label2);
+
+        frame.pack();
+        frame.setVisible(true);
+    }
+}
@@ -54,6 +54,7 @@
        <module>core-java-concurrency-simple</module>
        <module>core-java-datetime-string</module>
        <module>core-java-io-conversions-2</module>
+        <module>core-java-ipc</module>
        <module>core-java-jpms</module>
        <module>core-java-lang-oop-constructors-2</module>
        <module>core-java-methods</module>
@@ -183,6 +184,7 @@
        <module>core-java-string-algorithms</module>
        <module>core-java-string-algorithms-2</module>
        <module>core-java-string-apis</module>
+        <module>core-java-swing</module>
        <module>core-java-string-apis-2</module>
        <module>core-java-string-conversions</module>
        <module>core-java-string-conversions-2</module>
@@ -0,0 +1,42 @@
+.gradle
+build/
+!gradle/wrapper/gradle-wrapper.jar
+!**/src/main/**/build/
+!**/src/test/**/build/
+
+### IntelliJ IDEA ###
+.idea/modules.xml
+.idea/jarRepositories.xml
+.idea/compiler.xml
+.idea/libraries/
+*.iws
+*.iml
+*.ipr
+out/
+!**/src/main/**/out/
+!**/src/test/**/out/
+
+### Eclipse ###
+.apt_generated
+.classpath
+.factorypath
+.project
+.settings
+.springBeans
+.sts4-cache
+bin/
+!**/src/main/**/bin/
+!**/src/test/**/bin/
+
+### NetBeans ###
+/nbproject/private/
+/nbbuild/
+/dist/
+/nbdist/
+/.nb-gradle/
+
+### VS Code ###
+.vscode/
+
+### Mac OS ###
+.DS_Store
@@ -0,0 +1,20 @@
+plugins {
+    id 'java'
+}
+
+group = 'org.baeldung'
+version = '1.0-SNAPSHOT'
+
+repositories {
+    mavenCentral()
+}
+
+dependencies {
+    testImplementation platform('org.junit:junit-bom:5.9.1')
+    testImplementation 'org.junit.jupiter:junit-jupiter'
+    implementation 'io.micrometer:micrometer-core:1.12.0'
+}
+
+test {
+    useJUnitPlatform()
+}
--- a/Show More
+++ b/Show More