Merge pull request #34 from eugenp/master

update
2020-02-14 12:13:39 +01:00
parent 307205ce04 f81a203765
commit 5d4cec78a6
240 changed files with 26578 additions and 411 deletions
@@ -65,6 +65,7 @@ core-java-io/target_link.txt
 core-java/src/main/java/com/baeldung/manifest/MANIFEST.MF
 ethereum/logs/
 jmeter/src/main/resources/*-JMeter.csv
+ninja/devDb.mv.db

 **/node_modules/
 **/dist
@@ -13,4 +13,11 @@ This module contains articles about algorithms. Some classes of algorithms, e.g.
 - [The Caesar Cipher in Java](https://www.baeldung.com/java-caesar-cipher)
 - [Overview of Combinatorial Problems in Java](https://www.baeldung.com/java-combinatorial-algorithms)
 - [Prim’s Algorithm](https://www.baeldung.com/java-prim-algorithm)
+- [Maximum Subarray Problem](https://www.baeldung.com/java-maximum-subarray)
+- [How to Merge Two Sorted Arrays](https://www.baeldung.com/java-merge-sorted-arrays)
+- [Median of Stream of Integers using Heap](https://www.baeldung.com/java-stream-integers-median-using-heap)
+- [Kruskal’s Algorithm for Spanning Trees](https://www.baeldung.com/java-spanning-trees-kruskal)
+- [Balanced Brackets Algorithm in Java](https://www.baeldung.com/java-balanced-brackets-algorithm)
+- [Efficiently Merge Sorted Java Sequences](https://www.baeldung.com/java-merge-sorted-sequences)
+- [Introduction to Greedy Algorithms with Java](https://www.baeldung.com/java-greedy-algorithms)
 - More articles: [[<-- prev]](/../algorithms-miscellaneous-4)
@@ -0,0 +1,141 @@
+package com.baeldung.algorithms.balancedbinarytree;
+
+public class AVLTree {
+
+    public class Node {
+        int key;
+        int height;
+        Node left;
+        Node right;
+
+        Node(int key) {
+            this.key = key;
+        }
+    }
+
+    private Node root;
+
+    public Node find(int key) {
+        Node current = root;
+        while (current != null) {
+            if (current.key == key) {
+               break;
+            }
+            current = current.key < key ? current.right : current.left;
+        }
+        return current;
+    }
+
+    public void insert(int key) {
+        root = insert(root, key);
+    }
+
+    public void delete(int key) {
+        root = delete(root, key);
+    }
+
+    public Node getRoot() {
+        return root;
+    }
+
+    public int height() {
+        return root == null ? -1 : root.height;
+    }
+
+    private Node insert(Node node, int key) {
+        if (node == null) {
+            return new Node(key);
+        } else if (node.key > key) {
+            node.left = insert(node.left, key);
+        } else if (node.key < key) {
+            node.right = insert(node.right, key);
+        } else {
+            throw new RuntimeException("duplicate Key!");
+        }
+        return rebalance(node);
+    }
+
+    private Node delete(Node node, int key) {
+        if (node == null) {
+            return node;
+        } else if (node.key > key) {
+            node.left = delete(node.left, key);
+        } else if (node.key < key) {
+            node.right = delete(node.right, key);
+        } else {
+            if (node.left == null || node.right == null) {
+                node = (node.left == null) ? node.right : node.left;
+            } else {
+                Node mostLeftChild = mostLeftChild(node.right);
+                node.key = mostLeftChild.key;
+                node.right = delete(node.right, node.key);
+            }
+        }
+        if (node != null) {
+            node = rebalance(node);
+        }
+        return node;
+    }
+
+    private Node mostLeftChild(Node node) {
+        Node current = node;
+        /* loop down to find the leftmost leaf */
+        while (current.left != null) {
+            current = current.left;
+        }
+        return current;
+    }
+
+    private Node rebalance(Node z) {
+        updateHeight(z);
+        int balance = getBalance(z);
+        if (balance > 1) {
+            if (height(z.right.right) > height(z.right.left)) {
+                z = rotateLeft(z);
+            } else {
+                z.right = rotateRight(z.right);
+                z = rotateLeft(z);
+            }
+        } else if (balance < -1) {
+            if (height(z.left.left) > height(z.left.right)) {
+                z = rotateRight(z);
+            } else {
+                z.left = rotateLeft(z.left);
+                z = rotateRight(z);
+            }
+        }
+        return z;
+    }
+
+    private Node rotateRight(Node y) {
+        Node x = y.left;
+        Node z = x.right;
+        x.right = y;
+        y.left = z;
+        updateHeight(y);
+        updateHeight(x);
+        return x;
+    }
+
+    private Node rotateLeft(Node y) {
+        Node x = y.right;
+        Node z = x.left;
+        x.left = y;
+        y.right = z;
+        updateHeight(y);
+        updateHeight(x);
+        return x;
+    }
+
+    private void updateHeight(Node n) {
+        n.height = 1 + Math.max(height(n.left), height(n.right));
+    }
+
+    private int height(Node n) {
+        return n == null ? -1 : n.height;
+    }
+
+    public int getBalance(Node n) {
+        return (n == null) ? 0 : height(n.right) - height(n.left);
+    }
+}
@@ -0,0 +1,83 @@
+package com.baeldung.algorithms.balancedbinarytree;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+public class AVLTreeUnitTest {
+
+    @Test
+    public void givenEmptyTree_whenHeightCalled_shouldReturnMinus1() {
+        AVLTree tree = new AVLTree();
+        Assert.assertEquals(-1, tree.height());
+    }
+
+    @Test
+    public void givenEmptyTree_whenInsertCalled_heightShouldBeZero() {
+        AVLTree tree = new AVLTree();
+        tree.insert(1);
+        Assert.assertEquals(0, tree.height());
+    }
+
+    @Test
+    public void givenEmptyTree_whenInsertCalled_treeShouldBeAvl() {
+        AVLTree tree = new AVLTree();
+        tree.insert(1);
+        Assert.assertTrue(isAVL(tree));
+    }
+
+    @Test
+    public void givenSampleTree_whenInsertCalled_treeShouldBeAvl() {
+        AVLTree tree = getSampleAVLTree();
+        int newKey = 11;
+        tree.insert(newKey);
+        Assert.assertTrue(isAVL(tree));
+    }
+
+    @Test
+    public void givenSampleTree_whenFindExistingKeyCalled_shouldReturnMatchedNode() {
+        AVLTree tree = getSampleAVLTree();
+        int existingKey = 2;
+        AVLTree.Node result = tree.find(existingKey);
+        Assert.assertEquals(result.key, existingKey);
+    }
+
+    @Test
+    public void givenSampleTree_whenFindNotExistingKeyCalled_shouldReturnNull() {
+        AVLTree tree = getSampleAVLTree();
+        int notExistingKey = 11;
+        AVLTree.Node result = tree.find(notExistingKey);
+        Assert.assertNull(result);
+    }
+
+    @Test
+    public void givenEmptyTree_whenDeleteCalled_treeShouldBeAvl() {
+        AVLTree tree = new AVLTree();
+        tree.delete(1);
+        Assert.assertTrue(isAVL(tree));
+    }
+
+    @Test
+    public void givenSampleTree_whenDeleteCalled_treeShouldBeAvl() {
+        AVLTree tree = getSampleAVLTree();
+        tree.delete(1);
+        Assert.assertTrue(isAVL(tree, tree.getRoot()));
+    }
+
+    private boolean isAVL(AVLTree tree) {
+       return isAVL(tree, tree.getRoot());
+    }
+
+    private boolean isAVL(AVLTree tree, AVLTree.Node node) {
+        if ( node == null )
+            return true;
+        int balance = tree.getBalance(node);
+        return (balance <= 1 && balance >= -1) && isAVL(tree, node.left) && isAVL(tree, node.right);
+    }
+
+    private AVLTree getSampleAVLTree() {
+        AVLTree avlTree = new AVLTree();
+        for (int i = 0; i < 10; i++)
+            avlTree.insert(i);
+        return avlTree;
+    }
+}
@@ -0,0 +1,3 @@
+### Relevant Articles:
+
+- [Partitioning and Sorting Arrays with Many Repeated Entries](https://www.baeldung.com/java-sorting-arrays-with-repeated-entries)
@@ -6,3 +6,6 @@ This module contains articles about Apache POI
 - [Microsoft Word Processing in Java with Apache POI](https://www.baeldung.com/java-microsoft-word-with-apache-poi)
 - [Working with Microsoft Excel in Java](https://www.baeldung.com/java-microsoft-excel)
 - [Creating a MS PowerPoint Presentation in Java](https://www.baeldung.com/apache-poi-slideshow)
+- [Merge Cells in Excel Using Apache POI](https://www.baeldung.com/java-apache-poi-merge-cells)
+- [Get String Value of Excel Cell with Apache POI](https://www.baeldung.com/java-apache-poi-cell-string-value)
+- [Read Excel Cell Value Rather Than Formula With Apache POI](https://github.com/eugenp/tutorials/tree/master/apache-poi)
@@ -1,4 +1,4 @@
-package com.baeldung.poi.excel;
+package com.baeldung.poi.excel.merge;

 import static org.junit.Assert.assertEquals;

@@ -3,3 +3,5 @@
 This module contains articles about Apache RocketMQ

 ### Relevant Articles: 
+
+- [Apache RocketMQ with Spring Boot](https://www.baeldung.com/apache-rocketmq-spring-boot)
@@ -0,0 +1,3 @@
+### Relevant Articles:
+
+- [AWS S3 with Java – Reactive Support](https://www.baeldung.com/java-aws-s3-reactive)
@@ -13,3 +13,4 @@ This module contains articles about Java 11 core features
 - [Guide to jlink](https://www.baeldung.com/jlink)
 - [Negate a Predicate Method Reference with Java 11](https://www.baeldung.com/java-negate-predicate-method-reference)
 - [Benchmark JDK Collections vs Eclipse Collections](https://www.baeldung.com/jdk-collections-vs-eclipse-collections)
+- [Pre-compile Regex Patterns Into Pattern Objects](https://www.baeldung.com/java-regex-pre-compile)
@@ -1,3 +1,4 @@
 ### Relevant articles:

 - [Java Switch Statement](https://www.baeldung.com/java-switch)
+- [New Java 13 Features](https://www.baeldung.com/java-13-new-features)
@@ -0,0 +1 @@
+--enable-preview
@@ -0,0 +1,7 @@
+## Core Java 14
+
+This module contains articles about Java 14. 
+
+### Relevant articles
+
+- [Guide to the @Serial Annotation in Java 14](https://www.baeldung.com/java-14-serial-annotation)
@@ -1,53 +1,66 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <project xmlns="http://maven.apache.org/POM/4.0.0"
-	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
-	<modelVersion>4.0.0</modelVersion>
-	<groupId>com.baeldung</groupId>
-	<artifactId>core-java-14</artifactId>
-	<version>1.0.0-SNAPSHOT</version>
-	<name>core-java-14</name>
-	<packaging>jar</packaging>
-	<url>http://maven.apache.org</url>
+         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-14</artifactId>
+    <name>core-java-14</name>
+    <packaging>jar</packaging>
+    <url>http://maven.apache.org</url>

-	<parent>
-		<groupId>com.baeldung</groupId>
-		<artifactId>parent-modules</artifactId>
-		<version>1.0.0-SNAPSHOT</version>
-		<relativePath>../../</relativePath>
-	</parent>
+    <parent>
+        <groupId>com.baeldung</groupId>
+        <artifactId>parent-modules</artifactId>
+        <version>1.0.0-SNAPSHOT</version>
+        <relativePath>../../</relativePath>
+    </parent>
+    <dependencies>
+        <dependency>
+            <groupId>org.assertj</groupId>
+            <artifactId>assertj-core</artifactId>
+            <version>${assertj.version}</version>
+            <scope>test</scope>
+        </dependency>
+        <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>
+        <plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-compiler-plugin</artifactId>
+                <version>${maven-compiler-plugin.version}</version>
+                <configuration>
+                    <release>${maven.compiler.release}</release>
+                    <compilerArgs>--enable-preview</compilerArgs>
+                </configuration>
+            </plugin>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-surefire-plugin</artifactId>
+                <version>${surefire.plugin.version}</version>
+                <configuration>
+                    <argLine>--enable-preview</argLine>
+                </configuration>
+            </plugin>
+        </plugins>
+    </build>

-	<build>
-		<plugins>
-			<plugin>
-				<groupId>org.apache.maven.plugins</groupId>
-				<artifactId>maven-compiler-plugin</artifactId>
-				<version>${maven-compiler-plugin.version}</version>
-				<configuration>
-					<source>${maven.compiler.source.version}</source>
-					<target>${maven.compiler.target.version}</target>
-					<compilerArgs>
-						<compilerArg>
-							--enable-preview
-						</compilerArg>
-					</compilerArgs>
-				</configuration>
-			</plugin>
-			<plugin>
-				<groupId>org.apache.maven.plugins</groupId>
-				<artifactId>maven-surefire-plugin</artifactId>
-				<version>${surefire.plugin.version}</version>
-				<configuration>
-					<argLine>--enable-preview</argLine>
-				</configuration>
-			</plugin>
-		</plugins>
-	</build>
-
-	<properties>
-		<maven.compiler.source.version>14</maven.compiler.source.version>
-		<maven.compiler.target.version>14</maven.compiler.target.version>
+    <properties>
+        <maven.compiler.release>14</maven.compiler.release>
+        <assertj.version>3.6.1</assertj.version>
+        <maven-compiler-plugin.version>3.8.1</maven-compiler-plugin.version>
        <surefire.plugin.version>3.0.0-M3</surefire.plugin.version>
-	</properties>
+    </properties>

 </project>
@@ -0,0 +1,46 @@
+package com.baeldung.java14.textblocks;
+
+public class TextBlocks13 {
+    public String getBlockOfHtml() {
+        return """
+            <html>
+
+                <body>
+                    <span>example text</span>
+                </body>
+            </html>""";
+    }
+
+    public String getNonStandardIndent() {
+        return """
+                Indent
+            """;
+    }
+
+    public String getQuery() {
+        return """
+            select "id", "user"
+            from "table"
+            """;
+    }
+
+    public String getTextWithCarriageReturns() {
+        return """
+            separated with\r
+            carriage returns""";
+    }
+
+    public String getTextWithEscapes() {
+        return """
+            fun with\n
+            whitespace\t\r
+            and other escapes \"""
+            """;
+    }
+
+    public String getFormattedText(String parameter) {
+        return """
+            Some parameter: %s
+            """.formatted(parameter);
+    }
+}
@@ -0,0 +1,16 @@
+package com.baeldung.java14.textblocks;
+
+public class TextBlocks14 {
+    public String getIgnoredNewLines() {
+        return """
+            This is a long test which looks to \
+            have a newline but actually does not""";
+    }
+
+    public String getEscapedSpaces() {
+        return """
+            line 1
+            line 2       \s
+            """;
+    }
+}
@@ -10,41 +10,41 @@ import java.io.Serializable;

 /**
 * Class showcasing the usage of the Java 14 @Serial annotation.
- * 
+ *
 * @author Donato Rimenti
 */
 public class MySerialClass implements Serializable {
-	
-	@Serial
-	private static final ObjectStreamField[] serialPersistentFields = null;
-	
-	@Serial
-	private static final long serialVersionUID = 1;

-	@Serial
-	private void writeObject(ObjectOutputStream stream) throws IOException {
-		// ...
-	}
+    @Serial
+    private static final ObjectStreamField[] serialPersistentFields = null;

-	@Serial
-	private void readObject(ObjectInputStream stream) throws IOException, ClassNotFoundException {
-		// ...
-	}
+    @Serial
+    private static final long serialVersionUID = 1;

-	@Serial
-	private void readObjectNoData() throws ObjectStreamException {
-		// ...
-	}
+    @Serial
+    private void writeObject(ObjectOutputStream stream) throws IOException {
+        // ...
+    }

-	@Serial
-	private Object writeReplace() throws ObjectStreamException {
-		// ...
-		return null;
-	}
+    @Serial
+    private void readObject(ObjectInputStream stream) throws IOException, ClassNotFoundException {
+        // ...
+    }

-	@Serial
-	private Object readResolve() throws ObjectStreamException {
-		// ...
-		return null;
-	}
+    @Serial
+    private void readObjectNoData() throws ObjectStreamException {
+        // ...
+    }
+
+    @Serial
+    private Object writeReplace() throws ObjectStreamException {
+        // ...
+        return null;
+    }
+
+    @Serial
+    private Object readResolve() throws ObjectStreamException {
+        // ...
+        return null;
+    }
 }
@@ -0,0 +1,58 @@
+package com.baeldung.java14.textblocks;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import org.junit.jupiter.api.Test;
+
+class TextBlocks13UnitTest {
+    private TextBlocks13 subject = new TextBlocks13();
+
+    @Test
+    void givenAnOldStyleMultilineString_whenComparing_thenEqualsTextBlock() {
+        String expected = "<html>\n"
+          + "\n"
+          + "    <body>\n"
+          + "        <span>example text</span>\n"
+          + "    </body>\n"
+          + "</html>";
+        assertThat(subject.getBlockOfHtml()).isEqualTo(expected);
+    }
+
+    @Test
+    void givenAnOldStyleString_whenComparing_thenEqualsTextBlock() {
+        String expected = "<html>\n\n    <body>\n        <span>example text</span>\n    </body>\n</html>";
+        assertThat(subject.getBlockOfHtml()).isEqualTo(expected);
+    }
+
+    @Test
+    void givenAnIndentedString_thenMatchesIndentedOldStyle() {
+        assertThat(subject.getNonStandardIndent()).isEqualTo("    Indent\n");
+    }
+
+    @Test
+    void givenAMultilineQuery_thenItCanContainUnescapedQuotes() {
+        assertThat(subject.getQuery()).contains("select \"id\", \"user\"");
+    }
+
+    @Test
+    void givenAMultilineQuery_thenItEndWithANewline() {
+        assertThat(subject.getQuery()).endsWith("\n");
+    }
+
+    @Test
+    void givenATextWithCarriageReturns_thenItContainsBoth() {
+        assertThat(subject.getTextWithCarriageReturns()).isEqualTo("separated with\r\ncarriage returns");
+    }
+
+    @Test
+    void givenAStringWithEscapedWhitespace_thenItAppearsInTheResultingString() {
+        assertThat(subject.getTextWithEscapes()).contains("fun with\n\n")
+            .contains("whitespace\t\r\n")
+            .contains("and other escapes \"\"\"");
+    }
+
+    @Test
+    void givenAFormattedString_thenTheParameterIsReplaced() {
+        assertThat(subject.getFormattedText("parameter")).contains("Some parameter: parameter");
+    }
+}
@@ -0,0 +1,21 @@
+package com.baeldung.java14.textblocks;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import org.junit.jupiter.api.Test;
+
+class TextBlocks14UnitTest {
+    private TextBlocks14 subject = new TextBlocks14();
+
+    @Test
+    void givenAStringWithEscapedNewLines_thenTheResultHasNoNewLines() {
+        String expected = "This is a long test which looks to have a newline but actually does not";
+        assertThat(subject.getIgnoredNewLines()).isEqualTo(expected);
+    }
+
+    @Test
+    void givenAStringWithEscapesSpaces_thenTheResultHasLinesEndingWithSpaces() {
+        String expected = "line 1\nline 2        \n";
+        assertThat(subject.getEscapedSpaces()).isEqualTo(expected);
+    }
+}
@@ -13,4 +13,5 @@ This module contains articles about Java arrays
 - [Removing an Element from an Array in Java](https://www.baeldung.com/java-array-remove-element)
 - [Removing the First Element of an Array](https://www.baeldung.com/java-array-remove-first-element)
 - [Adding an Element to a Java Array vs an ArrayList](https://www.baeldung.com/java-add-element-to-array-vs-list)
+- [Arrays.sort vs Arrays.parallelSort](https://www.baeldung.com/java-arrays-sort-vs-parallelsort)
 - [[<-- Prev]](/core-java-modules/core-java-arrays)
@@ -69,7 +69,7 @@ public class SortComparisonUnitTest {
    }

    @Test
-    public void givenArrayOfIntegers_whenUsingArraysSortMethodWithRange_thenSortRangeOfArrayInAscendingOrder() {
+    public void givenArrayOfIntegers_whenUsingArraysSortWithRange_thenSortRangeOfArrayAsc() {
        int[] array = { 10, 4, 6, 2, 1, 9, 7, 8, 3, 5 };
        int[] expected = { 10, 4, 1, 2, 6, 7, 8, 9, 3, 5 };

@@ -89,7 +89,7 @@ public class SortComparisonUnitTest {
    }

    @Test
-    public void givenArrayOfIntegers_whenUsingArraysParallelSortMethodWithRange_thenSortRangeOfArrayInAscendingOrder() {
+    public void givenArrayOfIntegers_whenUsingArraysParallelSortWithRange_thenSortRangeOfArrayAsc() {
        int[] array = { 10, 4, 6, 2, 1, 9, 7, 8, 3, 5 };
        int[] expected = { 10, 4, 1, 2, 6, 7, 8, 9, 3, 5 };

@@ -8,4 +8,6 @@ This module contains articles about advanced topics about multithreading with co

 - [Common Concurrency Pitfalls in Java](https://www.baeldung.com/java-common-concurrency-pitfalls)
 - [Guide to RejectedExecutionHandler](https://www.baeldung.com/java-rejectedexecutionhandler)
-[[<-- previous]](/core-java-modules/core-java-concurrency-advanced-2)
+- [Guide to Work Stealing in Java](https://www.baeldung.com/java-work-stealing)
+- [Asynchronous Programming in Java](https://www.baeldung.com/java-asynchronous-programming)
+- [[<-- previous]](/core-java-modules/core-java-concurrency-advanced-2)
@@ -4,7 +4,7 @@ package com.baeldung.concurrent.volatilekeyword;
 public class SharedObject {
    private volatile int count=0;

-    void increamentCount(){
+    void incrementCount(){
        count++;
    }
    public int  getCount(){
@@ -10,7 +10,7 @@ public class SharedObjectManualTest {
    public void whenOneThreadWrites_thenVolatileReadsFromMainMemory() throws InterruptedException {
        SharedObject sharedObject = new SharedObject();

-        Thread writer = new Thread(() -> sharedObject.increamentCount());
+        Thread writer = new Thread(() -> sharedObject.incrementCount());
        writer.start();
        Thread.sleep(100);

@@ -31,11 +31,11 @@ public class SharedObjectManualTest {
    @Test
    public void whenTwoThreadWrites_thenVolatileReadsFromMainMemory() throws InterruptedException {
        SharedObject sharedObject = new SharedObject();
-        Thread writerOne = new Thread(() -> sharedObject.increamentCount());
+        Thread writerOne = new Thread(() -> sharedObject.incrementCount());
        writerOne.start();
        Thread.sleep(100);

-        Thread writerTwo = new Thread(() -> sharedObject.increamentCount());
+        Thread writerTwo = new Thread(() -> sharedObject.incrementCount());
        writerTwo.start();
        Thread.sleep(100);

@@ -6,4 +6,5 @@ This module contains articles about date operations in Java.
 - [Skipping Weekends While Adding Days to LocalDate in Java 8](https://www.baeldung.com/java-localdate-add-days-skip-weekends)
 - [Checking If Two Java Dates Are on the Same Day](https://www.baeldung.com/java-check-two-dates-on-same-day)
 - [Converting Java Date to OffsetDateTime](https://www.baeldung.com/java-convert-date-to-offsetdatetime)
+- [How to Set the JVM Time Zone](https://www.baeldung.com/java-jvm-time-zone)
 - [[<-- Prev]](/core-java-modules/core-java-date-operations-1)
@@ -0,0 +1,3 @@
+### Relevant Articles:
+
+- [Creating a LocalDate with Values in Java](https://www.baeldung.com/java-creating-localdate-with-values)
@@ -5,3 +5,5 @@ This module contains articles about core java exceptions
 ### Relevant Articles:

 - [Is It a Bad Practice to Catch Throwable?](https://www.baeldung.com/java-catch-throwable-bad-practice)
+- [Wrapping vs Rethrowing Exceptions in Java](https://www.baeldung.com/java-wrapping-vs-rethrowing-exceptions)
+- [java.net.UnknownHostException: Invalid Hostname for Server](https://www.baeldung.com/java-unknownhostexception)
@@ -0,0 +1,32 @@
+package com.baeldung.socketexception;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.PrintWriter;
+import java.net.Socket;
+
+public class SocketClient {
+
+    private Socket clientSocket;
+    private PrintWriter out;
+    private BufferedReader in;
+
+    public void startConnection(String ip, int port) throws IOException {
+        clientSocket = new Socket(ip, port);
+        out = new PrintWriter(clientSocket.getOutputStream(), true);
+        in = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));
+    }
+
+    public String sendMessage(String msg) throws IOException {
+        out.println(msg);
+        return in.readLine();
+    }
+
+    public void stopConnection() throws IOException {
+        in.close();
+        out.close();
+        clientSocket.close();
+    }
+
+}
@@ -0,0 +1,45 @@
+package com.baeldung.socketexception;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.PrintWriter;
+import java.net.ServerSocket;
+import java.net.Socket;
+
+public class SocketServer {
+
+    private ServerSocket serverSocket;
+    private Socket clientSocket;
+    private PrintWriter out;
+    private BufferedReader in;
+
+    public void start(int port) {
+        try {
+            serverSocket = new ServerSocket(port);
+            clientSocket = serverSocket.accept();
+            out = new PrintWriter(clientSocket.getOutputStream(), true);
+            in = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));
+            String msg = in.readLine();
+            if (msg.contains("hi"))
+                out.println("hi");
+            else
+                out.println("didn't understand");
+            close();
+            stop();
+        } catch (IOException e) {
+            
+        }
+    }
+
+    private void close() throws IOException {
+        in.close();
+        out.close();
+    }
+
+    private void stop() throws IOException {
+        clientSocket.close();
+        serverSocket.close();
+    }
+
+}
@@ -0,0 +1,31 @@
+package com.baeldung.socketexception;
+
+import java.io.IOException;
+import java.net.SocketException;
+import java.util.concurrent.Executors;
+
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+public class SocketExceptionHandlingUnitTest {
+
+    @BeforeClass
+    public static void runServer() throws IOException, InterruptedException {
+        Executors.newSingleThreadExecutor()
+            .submit(() -> new SocketServer().start(6699));
+        Thread.sleep(100);
+    }
+
+    @Test
+    public void givenRunningServer_whenConnectToClosedSocket_thenHandleException() throws IOException {
+        SocketClient client = new SocketClient();
+        client.startConnection("127.0.0.1", 6699);
+        try {
+            client.sendMessage("hi");
+            client.sendMessage("hi again");
+        } catch (SocketException e) {
+            client.stopConnection();
+        }
+    }
+
+}
--- a/Show More
+++ b/Show More