Merge remote-tracking branch 'upstream/master' into feature/BAEL-6695-BooleanValidation

2023-10-07 22:35:50 +05:30
parent 7854c7336b 3a816d6b3d
commit 2958b275f7
75 changed files with 1527 additions and 95 deletions
@@ -13,3 +13,4 @@ You can build the project from the command line using: *mvn clean install*, or i
 - [Read Data From the Beginning Using Kafka Consumer API](https://www.baeldung.com/java-kafka-consumer-api-read)
 - [Get Partition Count for a Topic in Kafka](https://www.baeldung.com/java-kafka-partition-count-topic)
 - [bootstrap-server in Kafka Configuration](https://www.baeldung.com/java-kafka-bootstrap-server)
+- [Introduction to Apache Kafka](https://www.baeldung.com/apache-kafka)
@@ -0,0 +1,103 @@
+package com.baeldung.kafka.multipletopics;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import java.time.Duration;
+import java.util.Arrays;
+import java.util.Properties;
+import java.util.concurrent.ExecutionException;
+
+import org.apache.kafka.clients.consumer.ConsumerConfig;
+import org.apache.kafka.clients.consumer.ConsumerRecord;
+import org.apache.kafka.clients.consumer.KafkaConsumer;
+import org.apache.kafka.clients.producer.KafkaProducer;
+import org.apache.kafka.clients.producer.ProducerConfig;
+import org.apache.kafka.clients.producer.ProducerRecord;
+import org.apache.kafka.common.serialization.StringDeserializer;
+import org.apache.kafka.common.serialization.StringSerializer;
+import org.junit.jupiter.api.AfterAll;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.testcontainers.containers.KafkaContainer;
+import org.testcontainers.junit.jupiter.Container;
+import org.testcontainers.junit.jupiter.Testcontainers;
+import org.testcontainers.utility.DockerImageName;
+
+// This live test needs a Docker Daemon running so that a kafka container can be created
+
+@Testcontainers
+public class MultipleTopicsLiveTest {
+
+    private final Logger log = LoggerFactory.getLogger(MultipleTopicsLiveTest.class);
+
+    private static final String CARD_PAYMENTS_TOPIC = "card-payments";
+    private static final String BANK_TRANSFERS_TOPIC = "bank-transfers";
+    private static KafkaProducer<String, String> producer;
+    private static KafkaConsumer<String, String> consumer;
+
+    @Container
+    private static final KafkaContainer KAFKA_CONTAINER = new KafkaContainer(DockerImageName.parse("confluentinc/cp-kafka:latest"));
+
+    @BeforeAll
+    static void setup() {
+        KAFKA_CONTAINER.addExposedPort(9092);
+        producer = new KafkaProducer<>(getProducerProperties());
+        consumer = new KafkaConsumer<>(getConsumerProperties());
+    }
+
+    @AfterAll
+    static void destroy() {
+        KAFKA_CONTAINER.stop();
+    }
+
+    private static Properties getProducerProperties() {
+        Properties producerProperties = new Properties();
+        producerProperties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, KAFKA_CONTAINER.getBootstrapServers());
+        producerProperties.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
+        producerProperties.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
+        return producerProperties;
+    }
+
+    private static Properties getConsumerProperties() {
+        Properties consumerProperties = new Properties();
+        consumerProperties.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, KAFKA_CONTAINER.getBootstrapServers());
+        consumerProperties.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName());
+        consumerProperties.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName());
+        consumerProperties.put(ConsumerConfig.AUTO_OFFSET_RESET_CONFIG, "earliest");
+        consumerProperties.put(ConsumerConfig.GROUP_ID_CONFIG, "payments");
+        return consumerProperties;
+    }
+
+    @Test
+    void whenSendingMessagesOnTwoTopics_thenConsumerReceivesMessages() throws Exception {
+        publishMessages();
+
+        consumer.subscribe(Arrays.asList(CARD_PAYMENTS_TOPIC, BANK_TRANSFERS_TOPIC));
+
+        int eventsProcessed = 0;
+        for (ConsumerRecord<String, String> record : consumer.poll(Duration.ofSeconds(10))) {
+            log.info("Event on topic={}, payload={}", record.topic(), record.value());
+            eventsProcessed++;
+        }
+
+        assertThat(eventsProcessed).isEqualTo(2);
+    }
+
+    private void publishMessages() throws ExecutionException, InterruptedException {
+        ProducerRecord<String, String> cardPayment = new ProducerRecord<>(CARD_PAYMENTS_TOPIC, createCardPayment());
+        producer.send(cardPayment).get();
+
+        ProducerRecord<String, String> bankTransfer = new ProducerRecord<>(BANK_TRANSFERS_TOPIC, createBankTransfer());
+        producer.send(bankTransfer).get();
+    }
+
+    private String createCardPayment() {
+        return "{\"paymentReference\":\"A184028KM0013790\", \"type\":\"card\", \"amount\":\"275\", \"currency\":\"GBP\"}";
+    }
+
+    private String createBankTransfer() {
+        return "{\"paymentReference\":\"19ae2-18mk73-009\", \"type\":\"bank\", \"amount\":\"150\", \"currency\":\"EUR\"}";
+    }
+}
@@ -1,3 +1,5 @@
 ## Relevant Articles
 - [Sequenced Collections in Java 21](https://www.baeldung.com/java-21-sequenced-collections)
 - [String Templates in Java 21](https://www.baeldung.com/java-21-string-templates)
+- [Unnamed Classes and Instance Main Methods in Java 21](https://www.baeldung.com/java-21-unnamed-class-instance-main)
+- [Unnamed Patterns and Variables in Java 21](https://www.baeldung.com/java-unnamed-patterns-variables)
@@ -5,3 +5,4 @@ This module contains articles about Java Character Class
 ### Relevant Articles: 
 - [Character#isAlphabetic vs. Character#isLetter](https://www.baeldung.com/java-character-isletter-isalphabetic)
 - [Difference Between Java’s “char” and “String”](https://www.baeldung.com/java-char-vs-string)
+- [Increment Character in Java](https://www.baeldung.com/java-char-sequence)
@@ -5,4 +5,6 @@
 ### Relevant Articles:
 - [Introduction to Roaring Bitmap](https://www.baeldung.com/java-roaring-bitmap-intro)
 - [Creating Custom Iterator in Java](https://www.baeldung.com/java-creating-custom-iterator)
+- [Difference Between Arrays.sort() and Collections.sort()](https://www.baeldung.com/java-arrays-collections-sort-methods)
+- [Skipping the First Iteration in Java](https://www.baeldung.com/java-skip-first-iteration)
 - More articles: [[<-- prev]](/core-java-modules/core-java-collections-4)
@@ -3,4 +3,4 @@
 This module contains articles about the Java ArrayList collection

 ### Relevant Articles:
- [Create an ArrayList with Multiple Object Types](https://www.baeldung.com/arraylist-with-multiple-object-types)
+- [Create an ArrayList with Multiple Object Types](https://www.baeldung.com/java-arraylist-multiple-object-types)
@@ -3,3 +3,4 @@
 This module contains articles about conversions among Collection types in Java.

 ### Relevant Articles:
+- [Converting HashMap Values to an ArrayList in Java](https://www.baeldung.com/java-hashmap-arraylist)
@@ -0,0 +1 @@
+## Relevant Articles
@@ -0,0 +1,78 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+    <artifactId>core-java-collections-maps-7</artifactId>
+    <name>core-java-collections-maps-7</name>
+    <packaging>jar</packaging>
+
+    <parent>
+        <artifactId>core-java-modules</artifactId>
+        <groupId>com.baeldung.core-java-modules</groupId>
+        <version>0.0.1-SNAPSHOT</version>
+    </parent>
+
+    <properties>
+        <spring.version>5.2.5.RELEASE</spring.version>
+    </properties>
+    <dependencies>
+        <dependency>
+            <groupId>com.fasterxml.jackson.core</groupId>
+            <artifactId>jackson-databind</artifactId>
+            <version>2.12.4</version>
+        </dependency>
+        <dependency>
+            <groupId>org.openjdk.jmh</groupId>
+            <artifactId>jmh-core</artifactId>
+            <version>1.36</version>
+        </dependency>
+        <dependency>
+            <groupId>com.google.code.gson</groupId>
+            <artifactId>gson</artifactId>
+            <version>2.8.9</version>
+        </dependency>
+        <dependency>
+            <groupId>org.json</groupId>
+            <artifactId>json</artifactId>
+            <version>20230227</version>
+        </dependency>
+        <dependency>
+            <groupId>junit</groupId>
+            <artifactId>junit</artifactId>
+            <version>4.13.1</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.junit.jupiter</groupId>
+            <artifactId>junit-jupiter</artifactId>
+            <version>5.8.1</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.junit.jupiter</groupId>
+            <artifactId>junit-jupiter</artifactId>
+            <version>5.8.1</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>junit</groupId>
+            <artifactId>junit</artifactId>
+            <version>4.13.1</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.junit.jupiter</groupId>
+            <artifactId>junit-jupiter</artifactId>
+            <version>5.8.1</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>junit</groupId>
+            <artifactId>junit</artifactId>
+            <version>4.13.1</version>
+            <scope>test</scope>
+        </dependency>
+    </dependencies>
+
+</project>
@@ -0,0 +1,60 @@
+package com.baeldung.map;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class ConvertHashMapStringToHashMapObjectUsingtoString {
+    public String name;
+    public int age;
+
+    public ConvertHashMapStringToHashMapObjectUsingtoString(String name, int age) {
+        this.name = name;
+        this.age = age;
+    }
+
+    public static ConvertHashMapStringToHashMapObjectUsingtoString deserializeCustomObject(String valueString) {
+        if (valueString.startsWith("{") && valueString.endsWith("}")) {
+            valueString = valueString.substring(1, valueString.length() - 1);
+            String[] parts = valueString.split(",");
+            String name = null;
+            int age = -1;
+            for (String part : parts) {
+                String[] keyValue = part.split("=");
+                if (keyValue.length == 2) {
+                    String key = keyValue[0].trim();
+                    String val = keyValue[1].trim();
+                    if (key.equals("name")) {
+                        name = val;
+                    } else if (key.equals("age")) {
+                        age = Integer.parseInt(val);
+                    }
+                }
+            }
+            if (name != null && age >= 0) {
+                return new ConvertHashMapStringToHashMapObjectUsingtoString(name, age);
+            }
+        }
+        return new ConvertHashMapStringToHashMapObjectUsingtoString("", -1);
+    }
+
+    public static void main(String[] args) {
+        String hashMapString = "{key1={name=John, age=30}, key2={name=Alice, age=25}}";
+        String keyValuePairs = hashMapString.replaceAll("[{}\\s]", "");
+        String[] pairs = keyValuePairs.split(",");
+        Map<String, ConvertHashMapStringToHashMapObjectUsingtoString> actualHashMap = new HashMap<>();
+        for (String pair : pairs) {
+            String[] keyValue = pair.split("=");
+            if (keyValue.length == 2) {
+                String key = keyValue[0];
+                ConvertHashMapStringToHashMapObjectUsingtoString value = deserializeCustomObject(keyValue[1]);
+                actualHashMap.put(key, value);
+            }
+        }
+        System.out.println(actualHashMap);
+    }
+
+    @Override
+    public String toString() {
+        return "{name=" + name + ", age=" + age + "}";
+    }
+}
@@ -0,0 +1,31 @@
+package com.baeldung.map;
+
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+class ConvertHashMapStringToHashMapObjectUsingtoStringUnitTest {
+
+    @Test
+    void givenValidCustomObject_whenSerializing_thenSerializedStringIsCorrect() {
+        ConvertHashMapStringToHashMapObjectUsingtoString customObject = new ConvertHashMapStringToHashMapObjectUsingtoString("John", 30);
+        String expectedSerializedString = "{name=John, age=30}";
+        assertEquals(expectedSerializedString, customObject.toString());
+    }
+
+    @Test
+    void givenValidSerializedString_whenDeserializing_thenCustomObjectIsCorrect() {
+        String serializedString = "{name=Alice, age=25}";
+        ConvertHashMapStringToHashMapObjectUsingtoString customObject = ConvertHashMapStringToHashMapObjectUsingtoString.deserializeCustomObject(serializedString);
+        assertEquals("Alice", customObject.name);
+        assertEquals(25, customObject.age);
+    }
+
+    @Test
+    void givenInvalidSerializedString_whenDeserializing_thenDefaultCustomObjectIsCreated() {
+        String invalidSerializedString = "{invalidString}";
+        ConvertHashMapStringToHashMapObjectUsingtoString customObject = ConvertHashMapStringToHashMapObjectUsingtoString.deserializeCustomObject(invalidSerializedString);
+        assertEquals("", customObject.name);
+        assertEquals(-1, customObject.age);
+    }
+}
@@ -12,10 +12,10 @@ public class EpochTimeToLocalDateTimeConverterUnitTest {
    @Test
    public void testConvertEpochTimeToLocalDateTime() {
        long epochTimeMillis = 1624962431000L; // Example epoch time in milliseconds
-        LocalDateTime expectedDateTime = LocalDateTime.of(2021, 6, 29, 12, 13, 51);
+        LocalDateTime expectedDateTime = LocalDateTime.of(2021, 6, 29, 10, 27, 11);

        Instant instant = Instant.ofEpochMilli(epochTimeMillis);
-        ZoneId zoneId = ZoneId.systemDefault();
+        ZoneId zoneId = ZoneId.of("UTC");
        LocalDateTime actualDateTime = instant.atZone(zoneId).toLocalDateTime();

        assertEquals(expectedDateTime, actualDateTime);
@@ -3,6 +3,6 @@
 This module contains articles about core Java input and output (IO)

 ### Relevant Articles: 
-
+- [Get File Extension From MIME Type in Java](https://www.baeldung.com/java-mime-type-file-extension)
 - [[<-- Prev]](/core-java-modules/core-java-io-4)

@@ -14,5 +14,6 @@ This module contains articles about working with the operating system (OS) in Ja
 - [How to Run a Shell Command in Java](http://www.baeldung.com/run-shell-command-in-java)
 - [Taking Screenshots Using Java](https://www.baeldung.com/java-taking-screenshots)
 - [Java Sound API – Capturing Microphone](https://www.baeldung.com/java-sound-api-capture-mic)
+- [How to Detect the Username Using Java](https://www.baeldung.com/java-get-username)

 This module uses Java 9, so make sure to have the JDK 9 installed to run it.
@@ -9,4 +9,5 @@
 - [Regular Expression: \z vs \Z Anchors in Java](https://www.baeldung.com/java-regular-expression-z-vs-z-anchors)
 - [Extract Text Between Square Brackets](https://www.baeldung.com/java-get-content-between-square-brackets)
 - [Get the Indexes of Regex Pattern Matches in Java](https://www.baeldung.com/java-indexes-regex-pattern-matches)
+- [Check if a String is Strictly Alphanumeric With Java](https://www.baeldung.com/java-check-string-contains-only-letters-numbers)
 - More articles: [[<-- prev]](/core-java-modules/core-java-regex)
@@ -43,6 +43,11 @@
            <artifactId>vavr</artifactId>
            <version>${vavr.version}</version>
        </dependency>
+        <dependency>
+            <groupId>com.google.guava</groupId>
+            <artifactId>guava</artifactId>
+            <version>${guava.version}</version>
+        </dependency>
    </dependencies>

    <build>
@@ -72,6 +77,7 @@
        <maven.compiler.source>12</maven.compiler.source>
        <maven.compiler.target>12</maven.compiler.target>
        <vavr.version>0.10.2</vavr.version>
+        <guava.version>32.1.2-jre</guava.version>
    </properties>

 </project>
@@ -0,0 +1,90 @@
+package com.baeldung.streams.partitioning;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.function.BiConsumer;
+import java.util.function.BinaryOperator;
+import java.util.function.Function;
+import java.util.function.Supplier;
+import java.util.stream.Collector;
+import java.util.stream.Collectors;
+import java.util.stream.IntStream;
+import java.util.stream.Stream;
+
+import com.google.common.collect.Iterables;
+
+public class PartitionStream {
+
+    public static <T> Stream<List<T>> partitionList(List<T> source, int batchSize) {
+        if (batchSize <= 0) {
+            throw new IllegalArgumentException(String.format("Expected the batchSize to be greater than ZERO, actual value was: %s", batchSize));
+        }
+        if (source.isEmpty()) {
+            return Stream.empty();
+        }
+        int nrOfFullBatches = (source.size() - 1) / batchSize;
+        return IntStream.rangeClosed(0, nrOfFullBatches)
+          .mapToObj(batch -> {
+              int startIndex = batch * batchSize;
+              int endIndex = (batch == nrOfFullBatches) ? source.size() : (batch + 1) * batchSize;
+              return source.subList(startIndex, endIndex);
+          });
+    }
+
+    public static <T> Iterable<List<T>> partitionUsingGuava(Stream<T> source, int batchSize) {
+        return Iterables.partition(source::iterator, batchSize);
+    }
+
+    public static <T> List<List<T>> partitionStream(Stream<T> source, int batchSize) {
+        return source.collect(partitionBySize(batchSize, Collectors.toList()));
+    }
+
+    public static <T, A, R> Collector<T, ?, R> partitionBySize(int batchSize, Collector<List<T>, A, R> downstream) {
+        Supplier<Accumulator<T, A>> supplier = () -> new Accumulator<>(
+          batchSize,
+          downstream.supplier().get(),
+          downstream.accumulator()::accept
+        );
+
+        BiConsumer<Accumulator<T, A>, T> accumulator = (acc, value) -> acc.add(value);
+
+        BinaryOperator<Accumulator<T, A>> combiner = (acc1, acc2) -> acc1.combine(acc2, downstream.combiner());
+
+        Function<Accumulator<T, A>, R> finisher = acc -> {
+            if (!acc.values.isEmpty()) {
+                downstream.accumulator().accept(acc.downstreamAccumulator, acc.values);
+            }
+            return downstream.finisher().apply(acc.downstreamAccumulator);
+        };
+
+        return Collector.of(supplier, accumulator, combiner, finisher, Collector.Characteristics.UNORDERED);
+    }
+
+    static class Accumulator<T, A> {
+        private final List<T> values = new ArrayList<>();
+        private final int batchSize;
+        private A downstreamAccumulator;
+        private final BiConsumer<A, List<T>> batchFullListener;
+
+        Accumulator(int batchSize, A accumulator, BiConsumer<A, List<T>> onBatchFull) {
+            this.batchSize = batchSize;
+            this.downstreamAccumulator = accumulator;
+            this.batchFullListener = onBatchFull;
+        }
+
+        void add(T value) {
+            values.add(value);
+            if (values.size() == batchSize) {
+                batchFullListener.accept(downstreamAccumulator, new ArrayList<>(values));
+                values.clear();
+            }
+        }
+
+        Accumulator<T, A> combine(Accumulator<T, A> other, BinaryOperator<A> accumulatorCombiner) {
+            this.downstreamAccumulator = accumulatorCombiner.apply(downstreamAccumulator, other.downstreamAccumulator);
+            other.values.forEach(this::add);
+            return this;
+        }
+    }
+
+}
@@ -0,0 +1,82 @@
+package com.baeldung.partitioning;
+
+import static com.baeldung.streams.partitioning.PartitionStream.partitionList;
+import static com.baeldung.streams.partitioning.PartitionStream.partitionStream;
+import static com.baeldung.streams.partitioning.PartitionStream.partitionUsingGuava;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static org.assertj.core.api.Assertions.atIndex;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.stream.Stream;
+
+import org.junit.jupiter.api.Test;
+
+public class PartitionStreamsUnitTest {
+
+    @Test
+    void whenPartitionList_thenReturnThreeSubLists() {
+        List<Integer> source = List.of(1, 2, 3, 4, 5, 6, 7, 8);
+
+        Stream<List<Integer>> result = partitionList(source, 3);
+
+        assertThat(result)
+          .containsExactlyInAnyOrder(
+            List.of(1, 2, 3),
+            List.of(4, 5, 6),
+            List.of(7, 8)
+          );
+    }
+
+    @Test
+    void whenPartitionEmptyList_thenReturnEmptyStream() {
+        Stream<List<Integer>> result = partitionList(Collections.emptyList(), 3);
+
+        assertThat(result).isEmpty();
+    }
+
+    @Test
+    void whenPartitionListWithNegativeBatchSize_thenThrowException() {
+        assertThatThrownBy(() -> partitionList(List.of(1,2,3), -1))
+          .isInstanceOf(IllegalArgumentException.class)
+          .hasMessage("Expected the batchSize to be greater than ZERO, actual value was: -1");
+    }
+
+    @Test
+    void whenPartitionParallelStream_thenReturnThreeSubLists() {
+        Stream<Integer> source = Stream.of(1, 2, 3, 4, 5, 6, 7, 8).parallel();
+
+        List<List<Integer>> result = partitionStream(source, 3);
+
+        assertThat(result)
+          .hasSize(3)
+          .satisfies(batch -> assertThat(batch).hasSize(3), atIndex(0))
+          .satisfies(batch -> assertThat(batch).hasSize(3), atIndex(1))
+          .satisfies(batch -> assertThat(batch).hasSize(2), atIndex(2));
+    }
+
+    @Test
+    void whenPartitionEmptyParallelStream_thenReturnEmptyList() {
+        Stream<Integer> source = Stream.<Integer>empty().parallel();
+
+        List<List<Integer>> result = partitionStream(source, 3);
+
+        assertThat(result).isEmpty();
+    }
+
+    @Test
+    void whenPartitionParallelStreamWithGuava_thenReturnThreeSubLists() {
+        Stream<Integer> source = Stream.of(1, 2, 3, 4, 5, 6, 7, 8).parallel();
+
+        Iterable<List<Integer>> result = partitionUsingGuava(source, 3);
+
+        assertThat(result)
+          .map(ArrayList::new)
+          .hasSize(3)
+          .satisfies(batch -> assertThat(batch).asList().hasSize(3), atIndex(0))
+          .satisfies(batch -> assertThat(batch).asList().hasSize(3), atIndex(1))
+          .satisfies(batch -> assertThat(batch).asList().hasSize(2), atIndex(2));
+    }
+}
@@ -28,12 +28,18 @@
            <artifactId>commons-vfs2</artifactId>
            <version>${commons-vfs2.version}</version>
        </dependency>
+        <dependency>
+            <groupId>org.apache.commons</groupId>
+            <artifactId>commons-text</artifactId>
+            <version>${apache-commons-text.version}</version>
+        </dependency>
    </dependencies>

    <properties>
        <commons-compress.version>1.23.0</commons-compress.version>
        <ant.version>1.10.13</ant.version>
        <commons-vfs2.version>2.9.0</commons-vfs2.version>
+        <apache-commons-text.version>1.10.0</apache-commons-text.version>
    </properties>

 </project>
@@ -0,0 +1,29 @@
+package com.baeldung.commons.convertunicode;
+
+import org.apache.commons.text.StringEscapeUtils;
+
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+public class UnicodeConverterUtil {
+
+    public static String decodeWithApacheCommons(String input) {
+        return StringEscapeUtils.unescapeJava(input);
+    }
+
+    public static String decodeWithPlainJava(String input) {
+        Pattern pattern = Pattern.compile("\\\\u[0-9a-fA-F]{4}");
+        Matcher matcher = pattern.matcher(input);
+
+        StringBuilder decodedString = new StringBuilder();
+
+        while (matcher.find()) {
+            String unicodeSequence = matcher.group();
+            char unicodeChar = (char) Integer.parseInt(unicodeSequence.substring(2), 16);
+            matcher.appendReplacement(decodedString, Character.toString(unicodeChar));
+        }
+
+        matcher.appendTail(decodedString);
+        return decodedString.toString();
+    }
+}
@@ -0,0 +1,39 @@
+package com.baeldung.commons.convertunicode;
+
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+public class UnicodeConverterUnitTest {
+
+    @Test
+    public void whenInputHaveUnicodeSequences_ThenDecode() {
+        String encodedString = "\\u0048\\u0065\\u006C\\u006C\\u006F World";
+        String expectedDecodedString = "Hello World";
+        assertEquals(expectedDecodedString, UnicodeConverterUtil.decodeWithApacheCommons(encodedString));
+        assertEquals(expectedDecodedString, UnicodeConverterUtil.decodeWithPlainJava(encodedString));
+    }
+
+    @Test
+    public void whenInputHaveNoUnicodeSequences_ThenDoNothing() {
+        String inputString = "Hello World";
+        assertEquals(inputString, UnicodeConverterUtil.decodeWithApacheCommons(inputString));
+        assertEquals(inputString, UnicodeConverterUtil.decodeWithPlainJava(inputString));
+    }
+
+    @Test
+    public void whenInputHaveUnicodeSequencesInMiddle_ThenDecode() {
+        String encodedString = "This is a test \\u0069\\u006E the middle.";
+        String expectedDecodedString = "This is a test in the middle.";
+        assertEquals(expectedDecodedString, UnicodeConverterUtil.decodeWithApacheCommons(encodedString));
+        assertEquals(expectedDecodedString, UnicodeConverterUtil.decodeWithPlainJava(encodedString));
+    }
+
+    @Test
+    public void whenInputHaveMultipleUnicodeSequences_ThenDecode() {
+        String encodedString = "Unicode: \\u0048\\u0065\\u006C\\u006C\\u006F \\u0057\\u006F\\u0072\\u006C\\u0064";
+        String expectedDecodedString = "Unicode: Hello World";
+        assertEquals(expectedDecodedString, UnicodeConverterUtil.decodeWithApacheCommons(encodedString));
+        assertEquals(expectedDecodedString, UnicodeConverterUtil.decodeWithPlainJava(encodedString));
+    }
+}
@@ -5,6 +5,18 @@
    <modelVersion>4.0.0</modelVersion>
    <artifactId>libraries-io</artifactId>
    <name>libraries-io</name>
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-compiler-plugin</artifactId>
+                <configuration>
+                    <source>17</source>
+                    <target>17</target>
+                </configuration>
+            </plugin>
+        </plugins>
+    </build>

    <parent>
        <groupId>com.baeldung</groupId>
@@ -34,6 +46,11 @@
            <artifactId>zip4j</artifactId>
            <version>${zip4j.version}</version>
        </dependency>
+        <dependency>
+            <groupId>com.opencsv</groupId>
+            <artifactId>opencsv</artifactId>
+            <version>${opencsv.version}</version>
+        </dependency>
    </dependencies>

    <properties>
@@ -42,6 +59,10 @@
        <sshj.version>0.27.0</sshj.version>
        <vfs.version>2.4</vfs.version>
        <zip4j.version>2.9.0</zip4j.version>
+        <opencsv.version>5.7.1</opencsv.version>
+        <maven.compiler.source>17</maven.compiler.source>
+        <maven.compiler.target>17</maven.compiler.target>
+        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>

 </project>
@@ -0,0 +1,4 @@
+package com.baeldung.java.io.pojotocsv;
+
+public record Application(String id, String name, Integer age, String created_at) {
+}
@@ -0,0 +1,8 @@
+package com.baeldung.java.io.pojotocsv;
+
+import com.opencsv.bean.CsvBindByName;
+import com.opencsv.bean.CsvBindByPosition;
+
+public record ApplicationWithAnnotation(@CsvBindByName(column = "id", required = true) @CsvBindByPosition(position = 1) String id, @CsvBindByName(column = "name", required = true) @CsvBindByPosition(position = 0) String name,
+                                        @CsvBindByName(column = "age", required = true) @CsvBindByPosition(position = 2) Integer age, @CsvBindByName(column = "position", required = true) @CsvBindByPosition(position = 3) String created_at) {
+}
@@ -0,0 +1,55 @@
+package com.baeldung.java.io.pojotocsv;
+
+import java.io.FileWriter;
+import java.io.IOException;
+import java.util.List;
+
+import com.opencsv.CSVWriter;
+import com.opencsv.bean.StatefulBeanToCsvBuilder;
+import com.opencsv.exceptions.CsvDataTypeMismatchException;
+import com.opencsv.exceptions.CsvRequiredFieldEmptyException;
+
+public class BeanToCsv {
+
+    public void beanToCSVWithDefault(List<Application> applications) throws Exception {
+        try (FileWriter writer = new FileWriter("src/main/resources/application.csv")) {
+            var builder = new StatefulBeanToCsvBuilder<Application>(writer).withQuotechar(CSVWriter.NO_QUOTE_CHARACTER)
+                .withSeparator(',')
+                .build();
+            builder.write(applications);
+        }
+    }
+
+    public void beanToCSVWithCustomHeaderStrategy(List<Application> applications) throws IOException, CsvRequiredFieldEmptyException, CsvDataTypeMismatchException {
+        try (FileWriter writer = new FileWriter("src/main/resources/application2.csv")) {
+            var mappingStrategy = new CustomHeaderStrategy<Application>();
+            mappingStrategy.setType(Application.class);
+
+            var builder = new StatefulBeanToCsvBuilder<Application>(writer).withQuotechar(CSVWriter.NO_QUOTE_CHARACTER)
+                .withMappingStrategy(mappingStrategy)
+                .build();
+            builder.write(applications);
+        }
+    }
+
+    public void beanToCSVWithCustomPositionStrategy(List<ApplicationWithAnnotation> applications) throws Exception {
+        try (FileWriter writer = new FileWriter("src/main/resources/application3.csv")) {
+            var builder = new StatefulBeanToCsvBuilder<ApplicationWithAnnotation>(writer).withQuotechar(CSVWriter.NO_QUOTE_CHARACTER)
+                .build();
+            builder.write(applications);
+        }
+    }
+
+    public void beanToCSVWithCustomHeaderAndPositionStrategy(List<ApplicationWithAnnotation> applications) throws IOException, CsvRequiredFieldEmptyException, CsvDataTypeMismatchException {
+        try (FileWriter writer = new FileWriter("src/main/resources/application4.csv")) {
+            var mappingStrategy = new CustomColumnPositionStrategy<ApplicationWithAnnotation>();
+            mappingStrategy.setType(ApplicationWithAnnotation.class);
+
+            var builder = new StatefulBeanToCsvBuilder<ApplicationWithAnnotation>(writer).withQuotechar(CSVWriter.NO_QUOTE_CHARACTER)
+                .withMappingStrategy(mappingStrategy)
+                .build();
+            builder.write(applications);
+        }
+    }
+
+}
@@ -0,0 +1,12 @@
+package com.baeldung.java.io.pojotocsv;
+
+import com.opencsv.bean.ColumnPositionMappingStrategy;
+import com.opencsv.exceptions.CsvRequiredFieldEmptyException;
+
+public class CustomColumnPositionStrategy<T> extends ColumnPositionMappingStrategy<T> {
+    @Override
+    public String[] generateHeader(T bean) throws CsvRequiredFieldEmptyException {
+        super.generateHeader(bean);
+        return super.getColumnMapping();
+    }
+}
@@ -0,0 +1,16 @@
+package com.baeldung.java.io.pojotocsv;
+
+import java.util.Arrays;
+
+import com.opencsv.bean.HeaderColumnNameMappingStrategy;
+import com.opencsv.exceptions.CsvRequiredFieldEmptyException;
+
+public class CustomHeaderStrategy<T> extends HeaderColumnNameMappingStrategy<T> {
+    @Override
+    public String[] generateHeader(T bean) throws CsvRequiredFieldEmptyException {
+        String[] header = super.generateHeader(bean);
+        return Arrays.stream(header)
+            .map(String::toLowerCase)
+            .toArray(String[]::new);
+    }
+}
@@ -0,0 +1,4 @@
+AGE,CREATED_AT,ID,NAME
+34,2023-08-11,123,Sam
+44,2023-02-11,456,Tam
+54,2023-03-11,890,Jam
@@ -0,0 +1,4 @@
+age,created_at,id,name
+34,2023-08-11,123,Sam
+44,2023-02-11,456,Tam
+54,2023-03-11,890,Jam
@@ -0,0 +1,3 @@
+Sam,123,34,2023-08-11
+Tam,456,44,2023-02-11
+Jam,789,54,2023-03-11
--- a/Show More
+++ b/Show More