Merge remote-tracking branch 'eugenp/master'

README.md

@@ -26,3 +26,13 @@ To do the full build, do: `mvn install -Pdefault -Dgib.enabled=false`
 Building a single module
 ====================
 To build a specific module run the command: `mvn clean install -Dgib.enabled=false` in the module directory
+
+
+Running a Spring Boot module
+====================
+To run a Spring Boot module run the command: `mvn spring-boot:run -Dgib.enabled=false` in the module directory
+
+
+
+
+

algorithms/README.md

@@ -31,3 +31,6 @@
 - [Round Up to the Nearest Hundred](https://www.baeldung.com/java-round-up-nearest-hundred)
 - [Merge Sort in Java](https://www.baeldung.com/java-merge-sort)
 - [Calculate Percentage in Java](https://www.baeldung.com/java-calculate-percentage)
+- [Quicksort Algorithm Implementation in Java](https://www.baeldung.com/java-quicksort)
+- [Insertion Sort in Java](https://www.baeldung.com/java-insertion-sort)
+- [Converting Between Byte Arrays and Hexadecimal Strings in Java](https://www.baeldung.com/java-byte-arrays-hex-strings)

algorithms/src/main/java/com/baeldung/algorithms/bubblesort/BubbleSort.java

@@ -7,7 +7,7 @@ public class BubbleSort {
     void bubbleSort(Integer[] arr) {
         int n = arr.length;
         IntStream.range(0, n - 1)
-          .flatMap(i -> IntStream.range(i + 1, n - i))
+          .flatMap(i -> IntStream.range(1, n - i))
           .forEach(j -> {
               if (arr[j - 1] > arr[j]) {
                   int temp = arr[j];

algorithms/src/test/java/com/baeldung/algorithms/bubblesort/BubbleSortUnitTest.java

@@ -1,8 +1,8 @@
 package com.baeldung.algorithms.bubblesort;
 
-import static org.junit.Assert.*;
+import static org.junit.jupiter.api.Assertions.assertArrayEquals;
 
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 public class BubbleSortUnitTest {
 

apache-geode/README.md

@@ -0,0 +1,3 @@
+### Relevant Articles: 
+
+- [A Quick Guide to Apache Geode](https://www.baeldung.com/apache-geode)

apache-pulsar/.gitignore

@@ -0,0 +1,8 @@
+.classpath
+.project
+.settings
+target
+.idea
+*.iml
+.gradle/
+build/

apache-pulsar/pom.xml

@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd" xmlns="http://maven.apache.org/POM/4.0.0"
+    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
+  <modelVersion>4.0.0</modelVersion>
+  <groupId>com.baeldung.pulsar</groupId>
+  <artifactId>pulsar-java</artifactId>
+  <version>0.0.1</version>
+
+  <dependencies>
+    <dependency>
+      <groupId>org.apache.pulsar</groupId>
+      <artifactId>pulsar-client</artifactId>
+      <version>2.1.1-incubating</version>
+      <scope>compile</scope>
+    </dependency>
+  </dependencies>
+  <properties>
+    <maven.compiler.target>1.8</maven.compiler.target>
+    <maven.compiler.source>1.8</maven.compiler.source>
+  </properties>
+</project>

apache-pulsar/src/main/java/com/baeldung/ConsumerTest.java

@@ -0,0 +1,48 @@
+package com.baeldung;
+
+import java.io.IOException;
+
+import org.apache.pulsar.client.api.Consumer;
+import org.apache.pulsar.client.api.Message;
+import org.apache.pulsar.client.api.PulsarClient;
+import org.apache.pulsar.client.api.SubscriptionType;
+
+public class ConsumerTest {
+
+    private static final String SERVICE_URL = "pulsar://localhost:6650";
+    private static final String TOPIC_NAME = "test-topic";
+    private static final String SUBSCRIPTION_NAME = "test-subscription";
+
+    public static void main(String[] args) throws IOException {
+        // Create a Pulsar client instance. A single instance can be shared across many
+        // producers and consumer within the same application
+        PulsarClient client = PulsarClient.builder()
+                .serviceUrl(SERVICE_URL)
+                .build();
+
+        //Configure consumer specific settings.
+        Consumer<byte[]> consumer = client.newConsumer()
+                .topic(TOPIC_NAME)
+                // Allow multiple consumers to attach to the same subscription
+                // and get messages dispatched as a queue
+                .subscriptionType(SubscriptionType.Shared)
+                .subscriptionName(SUBSCRIPTION_NAME)
+                .subscribe();
+
+
+        // Once the consumer is created, it can be used for the entire application lifecycle
+        System.out.println("Created consumer for the topic "+ TOPIC_NAME);
+
+        do {
+            // Wait until a message is available
+            Message<byte[]> msg = consumer.receive();
+
+            // Extract the message as a printable string and then log
+            String content = new String(msg.getData());
+            System.out.println("Received message '"+content+"' with ID "+msg.getMessageId());
+
+            // Acknowledge processing of the message so that it can be deleted
+            consumer.acknowledge(msg);
+        } while (true);
+    }
+}

apache-pulsar/src/main/java/com/baeldung/ProducerTest.java

@@ -0,0 +1,58 @@
+package com.baeldung;
+
+import org.apache.pulsar.client.api.CompressionType;
+import org.apache.pulsar.client.api.Message;
+import org.apache.pulsar.client.api.MessageBuilder;
+import org.apache.pulsar.client.api.MessageId;
+import org.apache.pulsar.client.api.Producer;
+import org.apache.pulsar.client.api.PulsarClient;
+import org.apache.pulsar.client.api.PulsarClientException;
+
+import java.io.IOException;
+import java.util.stream.IntStream;
+
+public class ProducerTest {
+
+    private static final String SERVICE_URL = "pulsar://localhost:6650";
+    private static final String TOPIC_NAME = "test-topic";
+
+    public static void main(String[] args) throws IOException {
+        // Create a Pulsar client instance. A single instance can be shared across many
+        // producers and consumer within the same application
+        PulsarClient client = PulsarClient.builder()
+                .serviceUrl(SERVICE_URL)
+                .build();
+
+        // Configure producer specific settings
+        Producer<byte[]> producer = client.newProducer()
+                // Set the topic
+                .topic(TOPIC_NAME)
+                // Enable compression
+                .compressionType(CompressionType.LZ4)
+                .create();
+
+        // Once the producer is created, it can be used for the entire application life-cycle
+        System.out.println("Created producer for the topic "+TOPIC_NAME);
+
+        // Send 5 test messages
+        IntStream.range(1, 5).forEach(i -> {
+            String content = String.format("hi-pulsar-%d", i);
+
+            // Build a message object
+            Message<byte[]> msg = MessageBuilder.create()
+                    .setContent(content.getBytes())
+                    .build();
+
+            // Send each message and log message content and ID when successfully received
+            try {
+                MessageId msgId = producer.send(msg);
+
+                System.out.println("Published message '"+content+"' with the ID "+msgId);
+            } catch (PulsarClientException e) {
+                System.out.println(e.getMessage());
+            }
+        });
+
+        client.close();
+    }
+}

apache-pulsar/src/main/java/com/baeldung/subscriptions/ExclusiveSubscriptionTest.java

@@ -0,0 +1,59 @@
+package com.baeldung.subscriptions;
+
+import org.apache.pulsar.client.api.ConsumerBuilder;
+import org.apache.pulsar.client.api.Message;
+import org.apache.pulsar.client.api.MessageBuilder;
+import org.apache.pulsar.client.api.Producer;
+import org.apache.pulsar.client.api.PulsarClient;
+import org.apache.pulsar.client.api.PulsarClientException;
+import org.apache.pulsar.client.api.SubscriptionType;
+
+import java.util.stream.IntStream;
+
+public class ExclusiveSubscriptionTest {
+    private static final String SERVICE_URL = "pulsar://localhost:6650";
+    private static final String TOPIC_NAME = "test-topic";
+    private static final String SUBSCRIPTION_NAME = "test-subscription";
+    private static final SubscriptionType SUBSCRIPTION_TYPE = SubscriptionType.Exclusive;
+
+    public static void main(String[] args) throws PulsarClientException {
+        PulsarClient client = PulsarClient.builder()
+                .serviceUrl(SERVICE_URL)
+                .build();
+
+        Producer<byte[]> producer = client.newProducer()
+                .topic(TOPIC_NAME)
+                .create();
+
+        ConsumerBuilder<byte[]> consumer1 = client.newConsumer()
+                .topic(TOPIC_NAME)
+                .subscriptionName(SUBSCRIPTION_NAME)
+                .subscriptionType(SUBSCRIPTION_TYPE);
+
+        ConsumerBuilder<byte[]> consumer2 = client.newConsumer()
+                .topic(TOPIC_NAME)
+                .subscriptionName(SUBSCRIPTION_NAME)
+                .subscriptionType(SUBSCRIPTION_TYPE);
+
+        IntStream.range(0, 999).forEach(i -> {
+            Message<byte[]> msg = MessageBuilder.create()
+                    .setContent(String.format("message-%d", i).getBytes())
+                    .build();
+            try {
+                producer.send(msg);
+            } catch (PulsarClientException e) {
+                System.out.println(e.getMessage());
+            }
+        });
+
+        // Consumer 1 can subscribe to the topic
+        consumer1.subscribe();
+
+        // Consumer 2 cannot due to the exclusive subscription held by consumer 1
+        consumer2.subscribeAsync()
+                .handle((consumer, exception) -> {
+                    System.out.println(exception.getMessage());
+                    return null;
+                });
+    }
+}

apache-pulsar/src/main/java/com/baeldung/subscriptions/FailoverSubscriptionTest.java

@@ -0,0 +1,76 @@
+package com.baeldung.subscriptions;
+
+import org.apache.pulsar.client.api.Consumer;
+import org.apache.pulsar.client.api.ConsumerBuilder;
+import org.apache.pulsar.client.api.Message;
+import org.apache.pulsar.client.api.MessageBuilder;
+import org.apache.pulsar.client.api.Producer;
+import org.apache.pulsar.client.api.PulsarClient;
+import org.apache.pulsar.client.api.PulsarClientException;
+import org.apache.pulsar.client.api.SubscriptionType;
+
+import java.util.stream.IntStream;
+
+public class FailoverSubscriptionTest {
+    private static final String SERVICE_URL = "pulsar://localhost:6650";
+    private static final String TOPIC_NAME = "failover-subscription-test-topic";
+    private static final String SUBSCRIPTION_NAME = "test-subscription";
+    private static final SubscriptionType SUBSCRIPTION_TYPE = SubscriptionType.Failover;
+    private static final int NUM_MSGS = 10;
+
+    public static void main(String[] args) throws PulsarClientException {
+        PulsarClient client = PulsarClient.builder()
+                .serviceUrl(SERVICE_URL)
+                .build();
+
+        Producer<byte[]> producer = client.newProducer()
+                .topic(TOPIC_NAME)
+                .create();
+
+        ConsumerBuilder<byte[]> consumerBuilder = client.newConsumer()
+                .topic(TOPIC_NAME)
+                .subscriptionName(SUBSCRIPTION_NAME)
+                .subscriptionType(SUBSCRIPTION_TYPE);
+
+        Consumer<byte[]> mainConsumer = consumerBuilder
+                .consumerName("consumer-a")
+                .messageListener((consumer, msg) -> {
+                    System.out.println("Message received by main consumer");
+
+                    try {
+                        consumer.acknowledge(msg);
+                    } catch (PulsarClientException e) {
+                        System.out.println(e.getMessage());
+                    }
+                })
+                .subscribe();
+
+        Consumer<byte[]> failoverConsumer = consumerBuilder
+                .consumerName("consumer-b")
+                .messageListener((consumer, msg) -> {
+                    System.out.println("Message received by failover consumer");
+
+                    try {
+                        consumer.acknowledge(msg);
+                    } catch (PulsarClientException e) {
+                        System.out.println(e.getMessage());
+                    }
+                })
+                .subscribe();
+
+        IntStream.range(0, NUM_MSGS).forEach(i -> {
+            Message<byte[]> msg = MessageBuilder.create()
+                    .setContent(String.format("message-%d", i).getBytes())
+                    .build();
+            try {
+                producer.send(msg);
+
+                Thread.sleep(100);
+
+                if (i > 5) mainConsumer.close();
+            } catch (InterruptedException | PulsarClientException e) {
+                System.out.println(e.getMessage());
+            }
+        });
+    }
+}

core-java-collections/README.md

@@ -4,37 +4,23 @@
 
 ### Relevant Articles: 
 - [Immutable ArrayList in Java](http://www.baeldung.com/java-immutable-list)
-- [Converting between an Array and a List in Java](http://www.baeldung.com/convert-array-to-list-and-list-to-array)
-- [Converting between an Array and a Set in Java](http://www.baeldung.com/convert-array-to-set-and-set-to-array)
-- [Converting between a List and a Set in Java](http://www.baeldung.com/convert-list-to-set-and-set-to-list)
-- [Convert a Map to an Array, List or Set in Java](http://www.baeldung.com/convert-map-values-to-array-list-set)
 - [Guide to the Java ArrayList](http://www.baeldung.com/java-arraylist)
 - [Random List Element](http://www.baeldung.com/java-random-list-element)
 - [Java - Combine Multiple Collections](http://www.baeldung.com/java-combine-multiple-collections)
-- [Guide to WeakHashMap in Java](http://www.baeldung.com/java-weakhashmap)
-- [Guide to the Guava BiMap](http://www.baeldung.com/guava-bimap)
-- [The Java HashMap Under the Hood](http://www.baeldung.com/java-hashmap)
-- [A Guide to LinkedHashMap in Java](http://www.baeldung.com/java-linked-hashmap)
-- [A Guide to TreeMap in Java](http://www.baeldung.com/java-treemap)
 - [Removing all nulls from a List in Java](http://www.baeldung.com/java-remove-nulls-from-list)
 - [Removing all duplicates from a List in Java](http://www.baeldung.com/java-remove-duplicates-from-list)
 - [Flattening Nested Collections in Java](http://www.baeldung.com/java-flatten-nested-collections)
 - [HashSet and TreeSet Comparison](http://www.baeldung.com/java-hashset-vs-treeset)
-- [Iterate over a Map in Java](http://www.baeldung.com/java-iterate-map)
 - [Collect a Java Stream to an Immutable Collection](http://www.baeldung.com/java-stream-immutable-collection)
-- [Converting a List to String in Java](http://www.baeldung.com/java-list-to-string)
 - [Introduction to the Java ArrayDeque](http://www.baeldung.com/java-array-deque)
 - [A Guide to HashSet in Java](http://www.baeldung.com/java-hashset)
 - [A Guide to TreeSet in Java](http://www.baeldung.com/java-tree-set)
-- [Java TreeMap vs HashMap](http://www.baeldung.com/java-treemap-vs-hashmap)
 - [How to TDD a List Implementation in Java](http://www.baeldung.com/java-test-driven-list)
-- [How to Store Duplicate Keys in a Map in Java?](http://www.baeldung.com/java-map-duplicate-keys)
 - [Getting the Size of an Iterable in Java](http://www.baeldung.com/java-iterable-size)
 - [Iterating Backward Through a List](http://www.baeldung.com/java-list-iterate-backwards)
 - [How to Filter a Collection in Java](http://www.baeldung.com/java-collection-filtering)
 - [Add Multiple Items to an Java ArrayList](http://www.baeldung.com/java-add-items-array-list)
 - [Remove the First Element from a List](http://www.baeldung.com/java-remove-first-element-from-list)
-- [How to Convert List to Map in Java](http://www.baeldung.com/java-list-to-map)
 - [Initializing HashSet at the Time of Construction](http://www.baeldung.com/java-initialize-hashset)
 - [Removing the First Element of an Array](https://www.baeldung.com/java-array-remove-first-element)
 - [Fail-Safe Iterator vs Fail-Fast Iterator](http://www.baeldung.com/java-fail-safe-vs-fail-fast-iterator)
@@ -47,12 +33,9 @@
 - [Remove All Occurrences of a Specific Value from a List](https://www.baeldung.com/java-remove-value-from-list)
 - [Thread Safe LIFO Data Structure Implementations](https://www.baeldung.com/java-lifo-thread-safe)
 - [Collections.emptyList() vs. New List Instance](https://www.baeldung.com/java-collections-emptylist-new-list)
-- [Initialize a HashMap in Java](https://www.baeldung.com/java-initialize-hashmap)
 - [Differences Between Collection.clear() and Collection.removeAll()](https://www.baeldung.com/java-collection-clear-vs-removeall)
 - [Performance of contains() in a HashSet vs ArrayList](https://www.baeldung.com/java-hashset-arraylist-contains-performance)
-- [Get the Key for a Value from a Java Map](https://www.baeldung.com/java-map-key-from-value)
 - [Time Complexity of Java Collections](https://www.baeldung.com/java-collections-complexity)
-- [Sort a HashMap in Java](https://www.baeldung.com/java-hashmap-sort)
-- [Finding the Highest Value in a Java Map](https://www.baeldung.com/java-find-map-max)
 - [Operating on and Removing an Item from Stream](https://www.baeldung.com/java-use-remove-item-stream)
 - [An Introduction to Synchronized Java Collections](https://www.baeldung.com/java-synchronized-collections)
+- [Guide to EnumSet](https://www.baeldung.com/java-enumset)

core-java-collections/pom.xml

@@ -14,22 +14,11 @@
     </parent>
 
     <dependencies>
-        <dependency>
-            <groupId>net.sourceforge.collections</groupId>
-            <artifactId>collections-generic</artifactId>
-            <version>${collections-generic.version}</version>
-        </dependency>
         <dependency>
             <groupId>org.apache.commons</groupId>
             <artifactId>commons-collections4</artifactId>
             <version>${commons-collections4.version}</version>
         </dependency>
-        <dependency>
-            <groupId>com.jayway.awaitility</groupId>
-            <artifactId>awaitility</artifactId>
-            <version>${avaitility.version}</version>
-            <scope>test</scope>
-        </dependency>
         <dependency>
             <groupId>org.apache.commons</groupId>
             <artifactId>commons-lang3</artifactId>
@@ -67,12 +56,6 @@
             <artifactId>commons-exec</artifactId>
             <version>1.3</version>
         </dependency>
-        
-        <dependency>
-            <groupId>one.util</groupId>
-            <artifactId>streamex</artifactId>
-            <version>0.6.5</version>
-        </dependency>
     </dependencies>
 
     <properties>

core-java-io/README.md

@@ -31,4 +31,5 @@
 - [Create a Symbolic Link with Java](http://www.baeldung.com/java-symlink)
 - [Quick Use of FilenameFilter](http://www.baeldung.com/java-filename-filter)
 - [Initialize a HashMap in Java](https://www.baeldung.com/java-initialize-hashmap)
-- [ Read a File into an ArrayList](https://www.baeldung.com/java-file-to-arraylist)
+- [Read a File into an ArrayList](https://www.baeldung.com/java-file-to-arraylist)
+- [Guide to Java OutputStream](https://www.baeldung.com/java-outputstream)

core-java-io/pom.xml

@@ -154,6 +154,12 @@
             <artifactId>async-http-client</artifactId>
             <version>${async-http-client.version}</version>
         </dependency>
+        <dependency>
+            <groupId>com.opencsv</groupId>
+            <artifactId>opencsv</artifactId>
+            <version>${opencsv.version}</version>
+            <scope>test</scope>
+        </dependency>
     </dependencies>
 
     <build>
@@ -247,7 +253,7 @@
         <protonpack.version>1.13</protonpack.version>
         <streamex.version>0.6.5</streamex.version>
         <vavr.version>0.9.0</vavr.version>
-
+        <opencsv.version>4.1</opencsv.version>
         <!-- testing -->
         <assertj.version>3.6.1</assertj.version>
         <avaitility.version>1.7.0</avaitility.version>

core-java-io/src/test/java/com/baeldung/csv/ReadCSVInArrayUnitTest.java

@@ -0,0 +1,106 @@
+package com.baeldung.csv;
+
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.FileReader;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.Scanner;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+import com.opencsv.CSVReader;
+
+public class ReadCSVInArrayUnitTest {
+    public static final String COMMA_DELIMITER = ",";
+    public static final String CSV_FILE = "src/test/resources/book.csv";
+    public static final List<List<String>> EXPECTED_ARRAY = Collections.unmodifiableList(new ArrayList<List<String>>() {
+        {
+            add(new ArrayList<String>() {
+                {
+                    add("Mary Kom");
+                    add("Unbreakable");
+                }
+            });
+            add(new ArrayList<String>() {
+                {
+                    add("Kapil Isapuari");
+                    add("Farishta");
+                }
+            });
+        }
+    });
+
+    @Test
+    public void givenCSVFile_whenBufferedReader_thenContentsAsExpected() throws IOException {
+        List<List<String>> records = new ArrayList<List<String>>();
+        try (BufferedReader br = new BufferedReader(new FileReader(CSV_FILE))) {
+            String line = "";
+            while ((line = br.readLine()) != null) {
+                String[] values = line.split(COMMA_DELIMITER);
+                records.add(Arrays.asList(values));
+            }
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+        for (int i = 0; i < EXPECTED_ARRAY.size(); i++) {
+            Assert.assertArrayEquals(EXPECTED_ARRAY.get(i)
+                .toArray(),
+                records.get(i)
+                    .toArray());
+        }
+    }
+
+    @Test
+    public void givenCSVFile_whenScanner_thenContentsAsExpected() throws IOException {
+        List<List<String>> records = new ArrayList<List<String>>();
+        try (Scanner scanner = new Scanner(new File(CSV_FILE));) {
+            while (scanner.hasNextLine()) {
+                records.add(getRecordFromLine(scanner.nextLine()));
+            }
+        } catch (FileNotFoundException e) {
+            e.printStackTrace();
+        }
+        for (int i = 0; i < EXPECTED_ARRAY.size(); i++) {
+            Assert.assertArrayEquals(EXPECTED_ARRAY.get(i)
+                .toArray(),
+                records.get(i)
+                    .toArray());
+        }
+    }
+
+    private List<String> getRecordFromLine(String line) {
+        List<String> values = new ArrayList<String>();
+        try (Scanner rowScanner = new Scanner(line)) {
+            rowScanner.useDelimiter(COMMA_DELIMITER);
+            while (rowScanner.hasNext()) {
+                values.add(rowScanner.next());
+            }
+        }
+        return values;
+    }
+
+    @Test
+    public void givenCSVFile_whenOpencsv_thenContentsAsExpected() throws IOException {
+        List<List<String>> records = new ArrayList<List<String>>();
+        try (CSVReader csvReader = new CSVReader(new FileReader(CSV_FILE));) {
+            String[] values = null;
+            while ((values = csvReader.readNext()) != null) {
+                records.add(Arrays.asList(values));
+            }
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+        for (int i = 0; i < EXPECTED_ARRAY.size(); i++) {
+            Assert.assertArrayEquals(EXPECTED_ARRAY.get(i)
+                .toArray(),
+                records.get(i)
+                    .toArray());
+        }
+    }
+}

core-java-io/src/test/resources/book.csv

@@ -0,0 +1,2 @@
+Mary Kom,Unbreakable
+Kapil Isapuari,Farishta

core-java/README.md

@@ -157,3 +157,4 @@
 - [Hashing a Password in Java](https://www.baeldung.com/java-password-hashing)
 - [Java Switch Statement](https://www.baeldung.com/java-switch)
 - [The Modulo Operator in Java](https://www.baeldung.com/modulo-java)
+- [Ternary Operator In Java](https://www.baeldung.com/java-ternary-operator)

core-java/src/main/java/com/baeldung/string/DoubleToString.java

@@ -0,0 +1,41 @@
+package com.baeldung.string;
+
+import java.math.RoundingMode;
+import java.text.DecimalFormat;
+import java.text.NumberFormat;
+
+public class DoubleToString {
+
+    public static String truncateByCast(double d) {
+        return String.valueOf((int) d);
+    }
+
+    public static String roundWithStringFormat(double d) {
+        return String.format("%.0f", d);
+    }
+
+    public static String truncateWithNumberFormat(double d) {
+        NumberFormat nf = NumberFormat.getInstance();
+        nf.setMaximumFractionDigits(0);
+        nf.setRoundingMode(RoundingMode.FLOOR);
+        return nf.format(d);
+    }
+
+    public static String roundWithNumberFormat(double d) {
+        NumberFormat nf = NumberFormat.getInstance();
+        nf.setMaximumFractionDigits(0);
+        return nf.format(d);
+    }
+
+    public static String truncateWithDecimalFormat(double d) {
+        DecimalFormat df = new DecimalFormat("#,###");
+        df.setRoundingMode(RoundingMode.FLOOR);
+        return df.format(d);
+    }
+
+    public static String roundWithDecimalFormat(double d) {
+        DecimalFormat df = new DecimalFormat("#,###");
+        return df.format(d);
+    }
+
+}

core-java/src/test/java/com/baeldung/simpledateformat/SimpleDateFormatUnitTest.java

@@ -0,0 +1,59 @@
+package com.baeldung;
+
+import org.junit.Test;
+
+import java.text.DateFormat;
+import java.text.SimpleDateFormat;
+import java.util.Date;
+import java.util.Locale;
+import java.util.TimeZone;
+import java.util.logging.Logger;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+
+public class SimpleDateFormatUnitTest {
+
+  private static final Logger logger = Logger.getLogger(SimpleDateFormatUnitTest.class.getName());
+
+  @Test
+  public void givenSpecificDate_whenFormatted_thenCheckFormatCorrect() throws Exception {
+    SimpleDateFormat formatter = new SimpleDateFormat("dd-MM-yyyy");
+    assertEquals("24-05-1977", formatter.format(new Date(233345223232L)));
+  }
+
+  @Test
+  public void givenSpecificDate_whenFormattedUsingDateFormat_thenCheckFormatCorrect() throws Exception {
+    DateFormat formatter = DateFormat.getDateInstance(DateFormat.SHORT);
+    assertEquals("5/24/77", formatter.format(new Date(233345223232L)));
+  }
+
+  @Test
+  public void givenStringDate_whenParsed_thenCheckDateCorrect() throws Exception{
+    SimpleDateFormat formatter = new SimpleDateFormat("dd-MM-yyyy");
+    Date myDate = new Date(233276400000L);
+    Date parsedDate = formatter.parse("24-05-1977");
+    assertEquals(myDate.getTime(), parsedDate.getTime());
+  }
+
+  @Test
+  public void givenFranceLocale_whenFormatted_thenCheckFormatCorrect() throws Exception{
+    SimpleDateFormat franceDateFormatter = new SimpleDateFormat("EEEEE dd-MMMMMMM-yyyy", Locale.FRANCE);
+    Date myWednesday = new Date(1539341312904L);
+    assertTrue(franceDateFormatter.format(myWednesday).startsWith("vendredi"));
+  }
+
+  @Test
+  public void given2TimeZones_whenFormatted_thenCheckTimeDifference() throws Exception {
+    Date now = new Date();
+
+    SimpleDateFormat simpleDateFormat = new SimpleDateFormat("EEEE dd-MMM-yy HH:mm:ssZ");
+
+    simpleDateFormat.setTimeZone(TimeZone.getTimeZone("Europe/London"));
+    logger.info(simpleDateFormat.format(now));
+    //change the date format
+    simpleDateFormat.setTimeZone(TimeZone.getTimeZone("America/New_York"));
+    logger.info(simpleDateFormat.format(now));
+  }
+}

core-java/src/test/java/com/baeldung/string/DoubleToStringUnitTest.java

@@ -0,0 +1,45 @@
+package com.baeldung.string;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import org.junit.Test;
+
+public class DoubleToStringUnitTest {
+    
+    private static final double DOUBLE_VALUE = 3.56;
+    private static final String TRUNCATED_DOUBLE = "3";
+    private static final String ROUNDED_UP_DOUBLE = "4";
+    
+    
+    @Test
+    public void truncateByCastTest() {
+        assertThat(DoubleToString.truncateByCast(DOUBLE_VALUE)).isEqualTo(TRUNCATED_DOUBLE);
+    }
+    
+    @Test
+    public void roundingWithStringFormatTest() {
+        assertThat(DoubleToString.roundWithStringFormat(DOUBLE_VALUE)).isEqualTo(ROUNDED_UP_DOUBLE);
+    }
+
+    @Test
+    public void truncateWithNumberFormatTest() {
+        assertThat(DoubleToString.truncateWithNumberFormat(DOUBLE_VALUE)).isEqualTo(TRUNCATED_DOUBLE);
+    }
+    
+    @Test
+    public void roundWithNumberFormatTest() {
+        assertThat(DoubleToString.roundWithNumberFormat(DOUBLE_VALUE)).isEqualTo(ROUNDED_UP_DOUBLE);
+    }
+
+    @Test
+    public void truncateWithDecimalFormatTest() {
+        assertThat(DoubleToString.truncateWithDecimalFormat(DOUBLE_VALUE)).isEqualTo(TRUNCATED_DOUBLE);
+    }
+    
+    @Test
+    public void roundWithDecimalFormatTest() {
+        assertThat(DoubleToString.roundWithDecimalFormat(DOUBLE_VALUE)).isEqualTo(ROUNDED_UP_DOUBLE);
+    }
+
+
+}

core-kotlin/README.md

@@ -39,3 +39,4 @@
 - [Introduction to Kovenant Library for Kotlin](https://www.baeldung.com/kotlin-kovenant)
 - [Converting Kotlin Data Class from JSON using GSON](https://www.baeldung.com/kotlin-json-convert-data-class)
 - [Concatenate Strings in Kotlin](https://www.baeldung.com/kotlin-concatenate-strings)
+- [Kotlin return, break, continue Keywords](https://www.baeldung.com/kotlin-return-break-continue)

hibernate5/README.md

@@ -17,3 +17,4 @@
 - [Mapping A Hibernate Query to a Custom Class](https://www.baeldung.com/hibernate-query-to-custom-class)
 - [@JoinColumn Annotation Explained](https://www.baeldung.com/jpa-join-column)
 - [Hibernate 5 Naming Strategy Configuration](https://www.baeldung.com/hibernate-naming-strategy)
+- [Proxy in Hibernate load() Method](https://www.baeldung.com/hibernate-proxy-load-method)

hibernate5/pom.xml

@@ -44,6 +44,11 @@
             <artifactId>mariaDB4j</artifactId>
             <version>${mariaDB4j.version}</version>
         </dependency>
+        <dependency>
+            <groupId>org.hibernate</groupId>
+            <artifactId>hibernate-testing</artifactId>
+            <version>5.2.2.Final</version>
+        </dependency>
     </dependencies>
 
     <build>
@@ -57,7 +62,7 @@
     </build>
 
     <properties>
-        <hibernate.version>5.3.2.Final</hibernate.version>
+        <hibernate.version>5.3.6.Final</hibernate.version>
         <mysql.version>6.0.6</mysql.version>
         <mariaDB4j.version>2.2.3</mariaDB4j.version>
         <h2database.version>1.4.196</h2database.version>

hibernate5/src/main/java/com/baeldung/hibernate/HibernateUtil.java

@@ -5,6 +5,8 @@ import java.io.IOException;
 import java.net.URL;
 import java.util.Properties;
 
+import com.baeldung.hibernate.customtypes.LocalDateStringType;
+import com.baeldung.hibernate.customtypes.OfficeEmployee;
 import com.baeldung.hibernate.entities.DeptEmployee;
 import com.baeldung.hibernate.optimisticlocking.OptimisticLockingCourse;
 import com.baeldung.hibernate.optimisticlocking.OptimisticLockingStudent;
@@ -18,8 +20,10 @@ import com.baeldung.hibernate.pojo.inheritance.*;
 import org.apache.commons.lang3.StringUtils;
 import org.hibernate.SessionFactory;
 import org.hibernate.boot.Metadata;
+import org.hibernate.boot.MetadataBuilder;
 import org.hibernate.boot.MetadataSources;
 import org.hibernate.boot.registry.StandardServiceRegistryBuilder;
+import org.hibernate.cfg.Configuration;
 import org.hibernate.service.ServiceRegistry;
 
 import com.baeldung.hibernate.pojo.Course;
@@ -66,6 +70,7 @@ public class HibernateUtil {
 
     private static SessionFactory makeSessionFactory(ServiceRegistry serviceRegistry) {
         MetadataSources metadataSources = new MetadataSources(serviceRegistry);
+
         metadataSources.addPackage("com.baeldung.hibernate.pojo");
         metadataSources.addAnnotatedClass(Employee.class);
         metadataSources.addAnnotatedClass(Phone.class);
@@ -102,8 +107,12 @@ public class HibernateUtil {
         metadataSources.addAnnotatedClass(com.baeldung.hibernate.entities.Department.class);
         metadataSources.addAnnotatedClass(OptimisticLockingCourse.class);
         metadataSources.addAnnotatedClass(OptimisticLockingStudent.class);
+        metadataSources.addAnnotatedClass(OfficeEmployee.class);
+
+        Metadata metadata = metadataSources.getMetadataBuilder()
+                .applyBasicType(LocalDateStringType.INSTANCE)
+                .build();
 
-        Metadata metadata = metadataSources.buildMetadata();
         return metadata.getSessionFactoryBuilder()
                 .build();
 

hibernate5/src/main/java/com/baeldung/hibernate/customtypes/Address.java

@@ -0,0 +1,69 @@
+package com.baeldung.hibernate.customtypes;
+
+import java.util.Objects;
+
+public class Address {
+
+    private String addressLine1;
+    private String addressLine2;
+    private String city;
+    private String country;
+    private int zipCode;
+
+    public String getAddressLine1() {
+        return addressLine1;
+    }
+
+    public String getAddressLine2() {
+        return addressLine2;
+    }
+
+    public String getCity() {
+        return city;
+    }
+
+    public String getCountry() {
+        return country;
+    }
+
+    public int getZipCode() {
+        return zipCode;
+    }
+
+    public void setAddressLine1(String addressLine1) {
+        this.addressLine1 = addressLine1;
+    }
+
+    public void setAddressLine2(String addressLine2) {
+        this.addressLine2 = addressLine2;
+    }
+
+    public void setCity(String city) {
+        this.city = city;
+    }
+
+    public void setCountry(String country) {
+        this.country = country;
+    }
+
+    public void setZipCode(int zipCode) {
+        this.zipCode = zipCode;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        Address address = (Address) o;
+        return zipCode == address.zipCode &&
+                Objects.equals(addressLine1, address.addressLine1) &&
+                Objects.equals(addressLine2, address.addressLine2) &&
+                Objects.equals(city, address.city) &&
+                Objects.equals(country, address.country);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(addressLine1, addressLine2, city, country, zipCode);
+    }
+}

hibernate5/src/main/java/com/baeldung/hibernate/customtypes/AddressType.java

@@ -0,0 +1,169 @@
+package com.baeldung.hibernate.customtypes;
+
+import org.hibernate.HibernateException;
+import org.hibernate.engine.spi.SharedSessionContractImplementor;
+import org.hibernate.type.IntegerType;
+import org.hibernate.type.StringType;
+import org.hibernate.type.Type;
+import org.hibernate.usertype.CompositeUserType;
+
+import java.io.Serializable;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.sql.Types;
+import java.util.Objects;
+
+public class AddressType implements CompositeUserType {
+
+    @Override
+    public String[] getPropertyNames() {
+        return new String[]{"addressLine1", "addressLine2",
+                "city", "country", "zipcode"};
+    }
+
+    @Override
+    public Type[] getPropertyTypes() {
+        return new Type[]{StringType.INSTANCE, StringType.INSTANCE,
+                StringType.INSTANCE, StringType.INSTANCE, IntegerType.INSTANCE};
+    }
+
+    @Override
+    public Object getPropertyValue(Object component, int property) throws HibernateException {
+
+        Address empAdd = (Address) component;
+
+        switch (property) {
+            case 0:
+                return empAdd.getAddressLine1();
+            case 1:
+                return empAdd.getAddressLine2();
+            case 2:
+                return empAdd.getCity();
+            case 3:
+                return empAdd.getCountry();
+            case 4:
+                return Integer.valueOf(empAdd.getZipCode());
+        }
+
+        throw new IllegalArgumentException(property +
+                " is an invalid property index for class type " +
+                component.getClass().getName());
+    }
+
+    @Override
+    public void setPropertyValue(Object component, int property, Object value) throws HibernateException {
+
+        Address empAdd = (Address) component;
+
+        switch (property) {
+            case 0:
+                empAdd.setAddressLine1((String) value);
+            case 1:
+                empAdd.setAddressLine2((String) value);
+            case 2:
+                empAdd.setCity((String) value);
+            case 3:
+                empAdd.setCountry((String) value);
+            case 4:
+                empAdd.setZipCode((Integer) value);
+        }
+
+        throw new IllegalArgumentException(property +
+                " is an invalid property index for class type " +
+                component.getClass().getName());
+
+    }
+
+    @Override
+    public Class returnedClass() {
+        return Address.class;
+    }
+
+    @Override
+    public boolean equals(Object x, Object y) throws HibernateException {
+        if (x == y)
+            return true;
+
+        if (Objects.isNull(x) || Objects.isNull(y))
+            return false;
+
+        return x.equals(y);
+    }
+
+    @Override
+    public int hashCode(Object x) throws HibernateException {
+        return x.hashCode();
+    }
+
+    @Override
+    public Object nullSafeGet(ResultSet rs, String[] names, SharedSessionContractImplementor session, Object owner) throws HibernateException, SQLException {
+
+        Address empAdd = new Address();
+        empAdd.setAddressLine1(rs.getString(names[0]));
+
+        if (rs.wasNull())
+            return null;
+
+        empAdd.setAddressLine2(rs.getString(names[1]));
+        empAdd.setCity(rs.getString(names[2]));
+        empAdd.setCountry(rs.getString(names[3]));
+        empAdd.setZipCode(rs.getInt(names[4]));
+
+        return empAdd;
+    }
+
+    @Override
+    public void nullSafeSet(PreparedStatement st, Object value, int index, SharedSessionContractImplementor session) throws HibernateException, SQLException {
+
+        if (Objects.isNull(value))
+            st.setNull(index, Types.VARCHAR);
+        else {
+
+            Address empAdd = (Address) value;
+            st.setString(index, empAdd.getAddressLine1());
+            st.setString(index + 1, empAdd.getAddressLine2());
+            st.setString(index + 2, empAdd.getCity());
+            st.setString(index + 3, empAdd.getCountry());
+            st.setInt(index + 4, empAdd.getZipCode());
+        }
+    }
+
+    @Override
+    public Object deepCopy(Object value) throws HibernateException {
+
+        if (Objects.isNull(value))
+            return null;
+
+        Address oldEmpAdd = (Address) value;
+        Address newEmpAdd = new Address();
+
+        newEmpAdd.setAddressLine1(oldEmpAdd.getAddressLine1());
+        newEmpAdd.setAddressLine2(oldEmpAdd.getAddressLine2());
+        newEmpAdd.setCity(oldEmpAdd.getCity());
+        newEmpAdd.setCountry(oldEmpAdd.getCountry());
+        newEmpAdd.setZipCode(oldEmpAdd.getZipCode());
+
+        return newEmpAdd;
+    }
+
+    @Override
+    public boolean isMutable() {
+        return true;
+    }
+
+    @Override
+    public Serializable disassemble(Object value, SharedSessionContractImplementor session) throws HibernateException {
+        return (Serializable) deepCopy(value);
+    }
+
+    @Override
+    public Object assemble(Serializable cached, SharedSessionContractImplementor session, Object owner) throws HibernateException {
+        return deepCopy(cached);
+    }
+
+    @Override
+    public Object replace(Object original, Object target, SharedSessionContractImplementor session, Object owner) throws HibernateException {
+        return original;
+    }
+}

hibernate5/src/main/java/com/baeldung/hibernate/customtypes/LocalDateStringJavaDescriptor.java

@@ -0,0 +1,51 @@
+package com.baeldung.hibernate.customtypes;
+
+import org.hibernate.type.LocalDateType;
+import org.hibernate.type.descriptor.WrapperOptions;
+import org.hibernate.type.descriptor.java.AbstractTypeDescriptor;
+import org.hibernate.type.descriptor.java.ImmutableMutabilityPlan;
+import org.hibernate.type.descriptor.java.MutabilityPlan;
+
+import java.time.LocalDate;
+
+public class LocalDateStringJavaDescriptor extends AbstractTypeDescriptor<LocalDate> {
+
+    public static final LocalDateStringJavaDescriptor INSTANCE = new LocalDateStringJavaDescriptor();
+
+    public LocalDateStringJavaDescriptor() {
+        super(LocalDate.class, ImmutableMutabilityPlan.INSTANCE);
+    }
+
+    @Override
+    public String toString(LocalDate value) {
+        return LocalDateType.FORMATTER.format(value);
+    }
+
+    @Override
+    public LocalDate fromString(String string) {
+        return LocalDate.from(LocalDateType.FORMATTER.parse(string));
+    }
+
+    @Override
+    public <X> X unwrap(LocalDate value, Class<X> type, WrapperOptions options) {
+
+        if (value == null)
+            return null;
+
+        if (String.class.isAssignableFrom(type))
+            return (X) LocalDateType.FORMATTER.format(value);
+
+        throw unknownUnwrap(type);
+    }
+
+    @Override
+    public <X> LocalDate wrap(X value, WrapperOptions options) {
+        if (value == null)
+            return null;
+
+        if(String.class.isInstance(value))
+            return LocalDate.from(LocalDateType.FORMATTER.parse((CharSequence) value));
+
+        throw unknownWrap(value.getClass());
+    }
+}

hibernate5/src/main/java/com/baeldung/hibernate/customtypes/LocalDateStringType.java

@@ -0,0 +1,34 @@
+package com.baeldung.hibernate.customtypes;
+
+import org.hibernate.dialect.Dialect;
+import org.hibernate.type.AbstractSingleColumnStandardBasicType;
+import org.hibernate.type.DiscriminatorType;
+import org.hibernate.type.descriptor.java.LocalDateJavaDescriptor;
+import org.hibernate.type.descriptor.sql.VarcharTypeDescriptor;
+
+import java.time.LocalDate;
+
+public class LocalDateStringType extends AbstractSingleColumnStandardBasicType<LocalDate> implements DiscriminatorType<LocalDate> {
+
+    public static final LocalDateStringType INSTANCE = new LocalDateStringType();
+
+    public LocalDateStringType() {
+        super(VarcharTypeDescriptor.INSTANCE, LocalDateStringJavaDescriptor.INSTANCE);
+    }
+
+    @Override
+    public String getName() {
+        return "LocalDateString";
+    }
+
+    @Override
+    public LocalDate stringToObject(String xml) throws Exception {
+        return fromString(xml);
+    }
+
+    @Override
+    public String objectToSQLString(LocalDate value, Dialect dialect) throws Exception {
+        return '\'' + toString(value) + '\'';
+    }
+
+}

hibernate5/src/main/java/com/baeldung/hibernate/customtypes/OfficeEmployee.java

@@ -0,0 +1,88 @@
+package com.baeldung.hibernate.customtypes;
+
+import com.baeldung.hibernate.pojo.Phone;
+import org.hibernate.annotations.Columns;
+import org.hibernate.annotations.Parameter;
+import org.hibernate.annotations.Type;
+import org.hibernate.annotations.TypeDef;
+
+import javax.persistence.Column;
+import javax.persistence.Entity;
+import javax.persistence.GeneratedValue;
+import javax.persistence.Id;
+import javax.persistence.Table;
+import java.time.LocalDate;
+
+@TypeDef(name = "PhoneNumber",
+        typeClass = PhoneNumberType.class,
+        defaultForType = PhoneNumber.class)
+@Entity
+@Table(name = "OfficeEmployee")
+public class OfficeEmployee {
+
+    @Id
+    @GeneratedValue
+    private long id;
+
+    @Column
+    @Type(type = "LocalDateString")
+    private LocalDate dateOfJoining;
+
+    @Columns(columns = {@Column(name = "country_code"),
+            @Column(name = "city_code"),
+            @Column(name = "number")})
+    private PhoneNumber employeeNumber;
+
+    @Columns(columns = {@Column(name = "address_line_1"),
+            @Column(name = "address_line_2"),
+            @Column(name = "city"), @Column(name = "country"),
+            @Column(name = "zip_code")})
+    @Type(type = "com.baeldung.hibernate.customtypes.AddressType")
+    private Address empAddress;
+
+    @Type(type = "com.baeldung.hibernate.customtypes.SalaryType",
+            parameters = {@Parameter(name = "currency", value = "USD")})
+    @Columns(columns = {@Column(name = "amount"),
+            @Column(name = "currency")})
+    private Salary salary;
+
+    public Salary getSalary() {
+        return salary;
+    }
+
+    public void setSalary(Salary salary) {
+        this.salary = salary;
+    }
+
+    public long getId() {
+        return id;
+    }
+
+    public void setId(long id) {
+        this.id = id;
+    }
+
+    public LocalDate getDateOfJoining() {
+        return dateOfJoining;
+    }
+
+    public void setDateOfJoining(LocalDate dateOfJoining) {
+        this.dateOfJoining = dateOfJoining;
+    }
+
+    public PhoneNumber getEmployeeNumber() {
+        return employeeNumber;
+    }
+
+    public void setEmployeeNumber(PhoneNumber employeeNumber) {
+        this.employeeNumber = employeeNumber;
+    }
+
+    public Address getEmpAddress() {
+        return empAddress;
+    }
+
+    public void setEmpAddress(Address empAddress) {
+        this.empAddress = empAddress;
+    }
+}