Merge branch 'eugenp:master' into PR-7145

aws-modules/aws-miscellaneous/README.md

@@ -5,6 +5,5 @@ This module contains articles about various Amazon Web Services (AWS) such as EC
 ### Relevant articles
 
 - [Managing EC2 Instances in Java](https://www.baeldung.com/ec2-java)
-- [Integration Testing with a Local DynamoDB Instance](https://www.baeldung.com/dynamodb-local-integration-tests)
 - [Managing Amazon SQS Queues in Java](https://www.baeldung.com/aws-queues-java)
 - [Guide to AWS Aurora RDS with Java](https://www.baeldung.com/aws-aurora-rds-java)

core-java-modules/core-java-8/README.md

@@ -11,5 +11,5 @@ This module contains articles about Java 8 core features
 - [Finding Min/Max in an Array with Java](https://www.baeldung.com/java-array-min-max)
 - [Internationalization and Localization in Java 8](https://www.baeldung.com/java-8-localization)
 - [Generalized Target-Type Inference in Java](https://www.baeldung.com/java-generalized-target-type-inference)
-- [Monads in Java](https://www.baeldung.com/java-monads)
+- [Monads in Java – Optional](https://www.baeldung.com/java-monads)
 - [[More -->]](/core-java-modules/core-java-8-2)

core-java-modules/core-java-arrays-operations-basic-2/README.md

@@ -3,3 +3,4 @@
 This module contains articles about Java array fundamentals. They assume no previous background knowledge on working with arrays.
 
 ### Relevant Articles: 
+- [Arrays mismatch() Method in Java](https://www.baeldung.com/java-arrays-mismatch)

core-java-modules/core-java-collections-5/README.md

@@ -7,4 +7,5 @@
 - [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)
+- [Remove Elements From a Queue Using Loop](https://www.baeldung.com/java-remove-elements-queue)
 - More articles: [[<-- prev]](/core-java-modules/core-java-collections-4)

core-java-modules/core-java-collections-maps-7/README.md

@@ -1,2 +1,3 @@
 ## Relevant Articles
 - [Difference Between putIfAbsent() and computeIfAbsent() in Java’s Map](https://www.baeldung.com/java-map-putifabsent-computeifabsent)
+- [How to Write Hashmap to CSV File](https://www.baeldung.com/java-write-hashmap-csv)

core-java-modules/core-java-concurrency-advanced-5/README.md

@@ -0,0 +1,3 @@
+
+### Relevant Articles:
+- [Why wait() Requires Synchronization?](https://www.baeldung.com/java-wait-necessary-synchronization)

core-java-modules/core-java-concurrency-basic-3/README.md

@@ -10,4 +10,5 @@ This module contains articles about basic Java concurrency.
 - [Returning a Value After Finishing Thread’s Job in Java](https://www.baeldung.com/java-return-value-after-thread-finish)
 - [CompletableFuture and ThreadPool in Java](https://www.baeldung.com/java-completablefuture-threadpool)
 - [CompletableFuture allOf().join() vs. CompletableFuture.join()](https://www.baeldung.com/java-completablefuture-allof-join)
+- [Retry Logic with CompletableFuture](https://www.baeldung.com/java-completablefuture-retry-logic)
 - [[<-- Prev]](../core-java-concurrency-basic-2)

core-java-modules/core-java-concurrency-basic-3/src/main/java/com/baeldung/concurrent/completablefuturelist/Application.java

@@ -0,0 +1,100 @@
+package com.baeldung.concurrent.completablefuturelist;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.Executors;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.stream.Collectors;
+
+public class Application {
+
+    ScheduledExecutorService asyncOperationEmulation;
+
+    Application initialize() {
+        asyncOperationEmulation = Executors.newScheduledThreadPool(10);
+        return this;
+    }
+
+    CompletableFuture<String> asyncOperation(String operationId) {
+        CompletableFuture<String> cf = new CompletableFuture<>();
+        asyncOperationEmulation.submit(() -> {
+            // The following lines simulate an exception happening on the 567th operation
+            //  if (operationId.endsWith("567")) {
+            //      cf.completeExceptionally(new Exception("Error on operation " + operationId));
+            //      return;
+            //  }
+            try {
+                Thread.sleep(100);
+                cf.complete(operationId);
+            } catch (InterruptedException e) {
+                System.err.println("Thread interrupted error");
+                cf.completeExceptionally(e);
+            }
+        });
+        return cf;
+    }
+
+    void startNaive() {
+        List<CompletableFuture<String>> futures = new ArrayList<>();
+        for (int i = 1; i <= 1000; i++) {
+            String operationId = "Naive-Operation-" + i;
+            futures.add(asyncOperation(operationId));
+        }
+
+        CompletableFuture<List<String>> aggregate = CompletableFuture.completedFuture(new ArrayList<>());
+        for (CompletableFuture<String> future : futures) {
+            aggregate = aggregate.thenCompose(list -> {
+                try {
+                    list.add(future.get());
+                    return CompletableFuture.completedFuture(list);
+                } catch (Exception e) {
+                    final CompletableFuture<List<String>> excFuture = new CompletableFuture<>();
+                    excFuture.completeExceptionally(e);
+                    return excFuture;
+                }
+            });
+        }
+
+        try {
+            final List<String> results = aggregate.join();
+            System.out.println("Printing first 10 results");
+            for (int i = 0; i < 10; i++) {
+                System.out.println("Finished " + results.get(i));
+            }
+        } finally {
+            close();
+        }
+    }
+
+    void start() {
+        List<CompletableFuture<String>> futures = new ArrayList<>();
+        for (int i = 1; i <= 1000; i++) {
+            String operationId = "Operation-" + i;
+            futures.add(asyncOperation(operationId));
+        }
+        CompletableFuture<?>[] futuresArray = futures.toArray(new CompletableFuture<?>[0]);
+        CompletableFuture<List<String>> listFuture = CompletableFuture.allOf(futuresArray).thenApply(v -> futures.stream().map(CompletableFuture::join).collect(Collectors.toList()));
+        try {
+            final List<String> results = listFuture.join();
+            System.out.println("Printing first 10 results");
+            for (int i = 0; i < 10; i++) {
+                System.out.println("Finished " + results.get(i));
+            }
+        } finally {
+            close();
+        }
+    }
+
+    void close() {
+        asyncOperationEmulation.shutdownNow();
+    }
+
+    public static void main(String[] args) {
+        new Application().initialize()
+        // Switch between .startNaive() and .start() to test both implementations
+        //  .startNaive();
+          .start();
+    }
+
+}

core-java-modules/core-java-concurrency-simple/README.md

@@ -12,6 +12,7 @@ This module contains articles about Java Concurrency that are also part of an Eb
 - [Guide to the Volatile Keyword in Java](https://www.baeldung.com/java-volatile)
 - [A Guide to the Java ExecutorService](https://www.baeldung.com/java-executor-service-tutorial)
 - [Guide To CompletableFuture](https://www.baeldung.com/java-completablefuture)
+- [How To Manage Timeout for CompletableFuture](https://www.baeldung.com/java-completablefuture-timeout)
 
 ### NOTE:
 

core-java-modules/core-java-io-5/pom.xml

@@ -35,6 +35,21 @@
             <artifactId>simplemagic</artifactId>
             <version>${simplemagic.version}</version>
         </dependency>
+        <dependency>
+            <groupId>commons-io</groupId>
+            <artifactId>commons-io</artifactId>
+            <version>${commons-io.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.openjdk.jmh</groupId>
+            <artifactId>jmh-core</artifactId>
+            <version>${jmh.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.openjdk.jmh</groupId>
+            <artifactId>jmh-generator-annprocess</artifactId>
+            <version>${jmh.version}</version>
+        </dependency>
     </dependencies>
 
     <build>
@@ -62,5 +77,6 @@
         <jmime-magic.version>0.1.5</jmime-magic.version>
         <jodd-util.version>6.2.1</jodd-util.version>
         <simplemagic.version>1.17</simplemagic.version>
+        <jmh.version>1.37</jmh.version>
     </properties>
 </project>

core-java-modules/core-java-io-5/src/main/java/com/baeldung/zip/ZipBenchmark.java

@@ -0,0 +1,112 @@
+package com.baeldung.zip;
+
+import java.io.*;
+import java.util.concurrent.TimeUnit;
+import java.util.*;
+import java.util.zip.*;
+
+import org.openjdk.jmh.annotations.*;
+import org.openjdk.jmh.infra.Blackhole;
+import org.openjdk.jmh.runner.Runner;
+import org.openjdk.jmh.runner.options.Options;
+import org.openjdk.jmh.runner.options.OptionsBuilder;
+
+@State(Scope.Benchmark)
+@BenchmarkMode(Mode.AverageTime)
+@Warmup(iterations = 1, time = 2, timeUnit = TimeUnit.SECONDS)
+@Measurement(iterations = 3, time = 1, timeUnit = TimeUnit.SECONDS)
+@OutputTimeUnit(TimeUnit.MILLISECONDS)
+@Fork(value = 1)
+public class ZipBenchmark {
+
+    public static final int NUM_OF_FILES = 10;
+    public static final int DATA_SIZE = 204800;
+
+    @State(Scope.Thread)
+    public static class SourceState {
+
+        public File compressedFile;
+
+        @Setup(Level.Trial)
+        public void setup() throws IOException {
+            ZipSampleFileStore sampleFileStore = new ZipSampleFileStore(NUM_OF_FILES, DATA_SIZE);
+            compressedFile = sampleFileStore.getFile();
+        }
+
+        @TearDown(Level.Trial)
+        public void cleanup() {
+            if (compressedFile.exists()) {
+                compressedFile.delete();
+            }
+        }
+    }
+
+    @Benchmark
+    public static void readAllEntriesByZipFile(SourceState sourceState, Blackhole blackhole) throws IOException {
+
+        try (ZipFile zipFile = new ZipFile(sourceState.compressedFile)) {
+            Enumeration<? extends ZipEntry> zipEntries = zipFile.entries();
+            while (zipEntries.hasMoreElements())  {
+                ZipEntry zipEntry = zipEntries.nextElement();
+                try (InputStream inputStream = new BufferedInputStream(zipFile.getInputStream(zipEntry))) {
+                    blackhole.consume(ZipSampleFileStore.getString(inputStream));
+                }
+            }
+        }
+    }
+
+    @Benchmark
+    public static void readAllEntriesByZipInputStream(SourceState sourceState, Blackhole blackhole) throws IOException {
+
+        try (
+            BufferedInputStream bis = new BufferedInputStream(new FileInputStream(sourceState.compressedFile));
+            ZipInputStream zipInputStream = new ZipInputStream(bis)
+        ) {
+            ZipEntry entry;
+            while ((entry = zipInputStream.getNextEntry()) != null) {
+                blackhole.consume(ZipSampleFileStore.getString(zipInputStream));
+            }
+        }
+    }
+
+    @Benchmark
+    public static void readLastEntryByZipFile(SourceState sourceState, Blackhole blackhole) throws IOException {
+
+        try (ZipFile zipFile = new ZipFile(sourceState.compressedFile)) {
+           ZipEntry zipEntry = zipFile.getEntry(getLastEntryName());
+            try (InputStream inputStream = new BufferedInputStream(zipFile.getInputStream(zipEntry))) {
+                blackhole.consume(ZipSampleFileStore.getString(inputStream));
+            }
+        }
+    }
+
+    @Benchmark
+    public static void readLastEntryByZipInputStream(SourceState sourceState, Blackhole blackhole) throws IOException {
+
+        try (
+            BufferedInputStream bis = new BufferedInputStream(new FileInputStream(sourceState.compressedFile));
+            ZipInputStream zipInputStream = new ZipInputStream(bis)
+        ) {
+            ZipEntry entry;
+            while ((entry = zipInputStream.getNextEntry()) != null) {
+                if (Objects.equals(entry.getName(), getLastEntryName())){
+                    blackhole.consume(ZipSampleFileStore.getString(zipInputStream));
+                }
+            }
+        }
+    }
+
+    private static String getLastEntryName() {
+        return String.format(ZipSampleFileStore.ENTRY_NAME_PATTERN, NUM_OF_FILES);
+    }
+
+    public static void main(String[] args) throws Exception {
+        Options options = new OptionsBuilder()
+          .include(ZipBenchmark.class.getSimpleName()).threads(1)
+          .shouldFailOnError(true)
+          .shouldDoGC(true)
+          .jvmArgs("-server").build();
+        new Runner(options).run();
+    }
+
+}

core-java-modules/core-java-io-5/src/main/java/com/baeldung/zip/ZipSampleFileStore.java

@@ -0,0 +1,70 @@
+package com.baeldung.zip;
+
+import java.io.*;
+import java.nio.charset.Charset;
+import java.nio.charset.StandardCharsets;
+import java.util.*;
+import java.util.zip.ZipEntry;
+import java.util.zip.ZipOutputStream;
+
+import org.apache.commons.io.IOUtils;
+
+public class ZipSampleFileStore {
+
+    public static final String ENTRY_NAME_PATTERN = "str-data-%s.txt";
+    private static final Charset DEFAULT_ENCODING = StandardCharsets.UTF_8;
+
+    private final File file;
+    private final List<String> dataList;
+
+    public ZipSampleFileStore(int numOfFiles, int fileSize) throws IOException {
+
+        dataList = new ArrayList<>(numOfFiles);
+        file = File.createTempFile("zip-sample", "");
+
+        try (ZipOutputStream zos = new ZipOutputStream(new FileOutputStream(file))) {
+
+            for (int idx=0; idx<=numOfFiles; idx++) {
+
+                byte[] data = createRandomStringInByte(fileSize);
+                dataList.add(new String(data, DEFAULT_ENCODING));
+
+                ZipEntry entry = new ZipEntry(String.format(ENTRY_NAME_PATTERN, idx));
+                zos.putNextEntry(entry);
+                zos.write(data);
+                zos.closeEntry();
+            }
+        }
+    }
+
+    public static byte[] createRandomStringInByte(int size) {
+        Random random = new Random();
+        byte[] data = new byte[size];
+        for (int n = 0; n < data.length; n++) {
+            char randomChar;
+            int choice = random.nextInt(2); // 0 for uppercase, 1 for lowercase
+            if (choice == 0) {
+                randomChar = (char) ('A' + random.nextInt(26)); // 'A' to 'Z'
+            } else {
+                randomChar = (char) ('a' + random.nextInt(26)); // 'a' to 'z'
+            }
+            data[n] = (byte) randomChar;
+        }
+        return data;
+    }
+
+    public File getFile() {
+        return file;
+    }
+
+    public List<String> getDataList() {
+        return dataList;
+    }
+
+    public static String getString(InputStream inputStream) throws IOException {
+        ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
+        IOUtils.copy(inputStream, byteArrayOutputStream);
+        return byteArrayOutputStream.toString(DEFAULT_ENCODING);
+    }
+
+}

core-java-modules/core-java-io-5/src/test/java/com/baeldung/zip/ZipUnitTest.java

@@ -0,0 +1,83 @@
+package com.baeldung.zip;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import java.io.*;
+import java.util.*;
+import java.util.zip.*;
+
+import org.junit.*;
+
+public class ZipUnitTest {
+
+    private static File compressedFile;
+    private static List<String> dataList = new ArrayList<>();
+
+    @BeforeClass
+    public static void prepareData() throws IOException {
+        ZipSampleFileStore sampleFileStore = new ZipSampleFileStore(ZipBenchmark.NUM_OF_FILES, ZipBenchmark.DATA_SIZE);
+        compressedFile = sampleFileStore.getFile();
+        dataList = sampleFileStore.getDataList();
+    }
+
+    @Test
+    public void whenCreateZipFile_thenCompressedSizeShouldBeLessThanOriginal() throws IOException {
+        byte[] data = ZipSampleFileStore.createRandomStringInByte(10240);
+        File file = File.createTempFile("zip-temp", "");
+
+        try (
+            BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(file));
+            ZipOutputStream zos = new ZipOutputStream(bos)
+        ) {
+            ZipEntry zipEntry = new ZipEntry("zip-entry.txt");
+            zos.putNextEntry(zipEntry);
+            zos.write(data);
+            zos.closeEntry();
+
+            assertThat(file.length()).isLessThan(data.length);
+        }
+        finally {
+            file.delete();
+        }
+    }
+
+    @Test
+    public void whenReadAllEntriesViaZipFile_thenDataIsEqualtoTheSource() throws IOException {
+
+        try (ZipFile zipFile = new ZipFile(compressedFile)) {
+            Enumeration<? extends ZipEntry> entries = zipFile.entries();
+            List<? extends ZipEntry> entryList = Collections.list(entries);
+
+            for (int idx=0; idx<entryList.size(); idx++) {
+                ZipEntry zipEntry = entryList.get(idx);
+                try (InputStream inputStream = zipFile.getInputStream(zipEntry)) {
+                    String actual = ZipSampleFileStore.getString(inputStream);
+                    assertThat(actual).as("Data for ZIP entry: " + zipEntry.getName()).isEqualTo(dataList.get(idx));
+                }
+            }
+        }
+    }
+
+    @Test
+    public void whenReadAllEntriesViaZipInputStream_thenDataIsEqualtoTheSource() throws IOException {
+        int idx = 0;
+        try (
+            BufferedInputStream bis = new BufferedInputStream(new FileInputStream(compressedFile));
+            ZipInputStream zipInputStream = new ZipInputStream(bis)
+        ) {
+            ZipEntry zipEntry;
+            while ((zipEntry = zipInputStream.getNextEntry()) != null) {
+                String actual = ZipSampleFileStore.getString(zipInputStream);
+                assertThat(actual).as("Data for ZIP entry: " + zipEntry.getName()).isEqualTo(dataList.get(idx++));
+            }
+        }
+    }
+
+    @AfterClass
+    public static void cleanup() {
+        if (compressedFile.exists()) {
+            compressedFile.delete();
+        }
+    }
+
+}

core-java-modules/core-java-io-apis-2/alabama.txt

@@ -0,0 +1,2 @@
+I'm going to Alabama
+Alabama is a state in the US

core-java-modules/core-java-io-apis-2/dream.txt

@@ -0,0 +1 @@
+Dreams from My Father by Barack Obama

core-java-modules/core-java-io-apis-2/potter.txt

@@ -0,0 +1 @@
+Harry Potter and the Chamber of Secrets

core-java-modules/core-java-io-apis-2/src/test/java/com/baeldung/printwritervsfilewriter/PrintWriterVsFilePrinterUnitTest.java

@@ -0,0 +1,64 @@
+package com.baeldung.printwritervsfilewriter;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.FileReader;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.io.PrintWriter;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.List;
+
+import org.junit.jupiter.api.Test;
+
+public class PrintWriterVsFilePrinterUnitTest {
+
+    @Test
+    public void whenWritingToTextFileUsingFileWriter_thenTextMatches() throws IOException {
+        String result = "Harry Potter and the Chamber of Secrets";
+
+        File file = new File("potter.txt");
+        try (FileWriter fw = new FileWriter(file);) {
+            fw.write("Harry Potter and the Chamber of Secrets");
+        }
+
+        try (BufferedReader reader = new BufferedReader(new FileReader(file));) {
+            String actualData = reader.readLine();
+            assertEquals(result, actualData);
+        }
+    }
+
+    @Test
+    public void whenWritingToTextFileUsingPrintWriterPrintf_thenTextMatches() throws IOException {
+        String result = "Dreams from My Father by Barack Obama";
+        File file = new File("dream.txt");
+        try (PrintWriter pw = new PrintWriter(file);) {
+            String author = "Barack Obama";
+            pw.printf("Dreams from My Father by %s", author);
+            assertTrue(!pw.checkError());
+        }
+
+        try (BufferedReader reader = new BufferedReader(new FileReader(file));) {
+            String actualData = reader.readLine();
+            assertEquals(result, actualData);
+        }
+    }
+
+    @Test
+    public void whenWritingToTextFileUsingPrintWriterPrintln_thenTextMatches() throws IOException {
+        String result = "I'm going to Alabama\nAlabama is a state in the US\n";
+        try (PrintWriter pw = new PrintWriter("alabama.txt");) {
+            pw.println("I'm going to Alabama");
+            pw.println("Alabama is a state in the US");
+        }
+        Path path = Paths.get("alabama.txt");
+        String actualData = new String(Files.readAllBytes(path));
+        assertEquals(result, actualData);
+    }
+
+}

core-java-modules/core-java-streams-5/README.md

@@ -4,3 +4,4 @@
 - [Aggregate Runtime Exceptions in Java Streams](https://www.baeldung.com/java-streams-aggregate-exceptions)
 - [Streams vs. Loops in Java](https://www.baeldung.com/java-streams-vs-loops)
 - [Partition a Stream in Java](https://www.baeldung.com/java-partition-stream)
+- [Taking Every N-th Element from Finite and Infinite Streams in Java](https://www.baeldung.com/java-nth-element-finite-infinite-streams)

core-java-modules/core-java-string-algorithms-3/README.md

@@ -13,3 +13,4 @@ This module contains articles about string-related algorithms.
 - [Find the Most Frequent Characters in a String](https://www.baeldung.com/java-string-find-most-frequent-characters)
 - [Checking If a String Is a Repeated Substring](https://www.baeldung.com/java-repeated-substring)
 - [Check if Letter Is Emoji With Java](https://www.baeldung.com/java-check-letter-emoji)
+- [Wrapping a String After a Number of Characters Word-Wise](https://www.baeldung.com/java-wrap-string-number-characters-word-wise)

core-java-modules/core-java-string-conversions-3/README.md

@@ -3,3 +3,5 @@
 - [Convert String to Int Using Encapsulation](https://www.baeldung.com/java-encapsulation-convert-string-to-int)
 - [HashMap with Multiple Values for the Same Key](https://www.baeldung.com/java-hashmap-multiple-values-per-key)
 - [Split Java String Into Key-Value Pairs](https://www.baeldung.com/java-split-string-map)
+- [How to Center Text Output in Java](https://www.baeldung.com/java-center-text-output)
+- [How to Convert an Object to String](https://www.baeldung.com/java-object-string-representation)

core-java-modules/core-java-string-operations-6/README.md

@@ -11,4 +11,4 @@
 - [Check if a String Has All Unique Characters in Java](https://www.baeldung.com/java-check-string-all-unique-chars)
 - [Performance Comparison Between Different Java String Concatenation Methods](https://www.baeldung.com/java-string-concatenation-methods)
 - [Replacing Single Quote with \’ in Java String](https://www.baeldung.com/java-replacing-single-quote-string)
-
+- [Check if a String Contains a Number Value in Java](https://www.baeldung.com/java-string-number-presence)

core-java-modules/core-java-string-operations-7/README.md

@@ -1,2 +1,4 @@
 
 ### Relevant Articles:
+- [How to Center Text Output in Java](https://www.baeldung.com/java-center-text-output)
+- [Capitalize the First Letter of Each Word in a String](https://www.baeldung.com/java-string-initial-capital-letter-every-word)

core-java-modules/core-java-strings/src/test/java/com/baeldung/passstringbyreference/Dummy.java

@@ -0,0 +1,14 @@
+package com.baeldung.passstringbyreference;
+
+public class Dummy {
+
+    String dummyString;
+
+    public String getDummyString() {
+        return dummyString;
+    }
+
+    public void setDummyString(String dummyString) {
+        this.dummyString = dummyString;
+    }
+}

core-java-modules/core-java-strings/src/test/java/com/baeldung/passstringbyreference/PassStringUnitTest.java

@@ -0,0 +1,85 @@
+package com.baeldung.passstringbyreference;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNull;
+
+import org.junit.jupiter.api.Test;
+
+class PassStringUnitTest {
+
+    @Test
+    void givenAString_whenPassedToVoidMethod_thenStringIsNotModified() {
+        String s = "hello";
+        concatStringWithNoReturn(s);
+        assertEquals("hello", s);
+    }
+
+    void concatStringWithNoReturn(String input) {
+        input += " world";
+        assertEquals("hello world", input);
+    }
+
+    @Test
+    void givenAString_whenPassedToMethodAndReturnNewString_thenStringIsModified() {
+        String s = "hello";
+        assertEquals("hello world", concatStringWithReturn(s));
+    }
+
+    String concatStringWithReturn(String input) {
+        return input + " world";
+    }
+
+    @Test
+    void givenAString_whenPassStringBuilderToVoidMethod_thenConcatNewStringOk() {
+        StringBuilder builder = new StringBuilder("hello");
+        concatWithStringBuilder(builder);
+
+        assertEquals("hello world", builder.toString());
+    }
+
+    void concatWithStringBuilder(StringBuilder input) {
+        input.append(" world");
+    }
+
+    @Test
+    void givenAString_whenPassStringBufferToVoidMethod_thenConcatNewStringOk() {
+        StringBuffer builder = new StringBuffer("hello");
+        concatWithStringBuffer(builder);
+
+        assertEquals("hello world", builder.toString());
+    }
+
+    void concatWithStringBuffer(StringBuffer input) {
+        input.append(" world");
+    }
+
+    @Test
+    void givenObjectWithStringField_whenSetDifferentValue_thenObjectIsModified() {
+        Dummy dummy = new Dummy();
+        assertNull(dummy.getDummyString());
+        modifyStringValueInInputObject(dummy, "hello world");
+        assertEquals("hello world", dummy.getDummyString());
+    }
+
+    void modifyStringValueInInputObject(Dummy dummy, String dummyString) {
+        dummy.setDummyString(dummyString);
+    }
+
+    @Test
+    void givenObjectWithStringField_whenSetDifferentValueWithStringBuilder_thenSetStringInNewObject() {
+        assertEquals("hello world", getDummy("hello", "world").getDummyString());
+    }
+
+    Dummy getDummy(String hello, String world) {
+        StringBuilder builder = new StringBuilder();
+
+        builder.append(hello)
+          .append(" ")
+          .append(world);
+
+        Dummy dummy = new Dummy();
+        dummy.setDummyString(builder.toString());
+
+        return dummy;
+    }
+}

libraries-io/README.md

@@ -3,4 +3,4 @@
 
 - [Transferring a File Through SFTP in Java](https://www.baeldung.com/java-file-sftp)
 - [How to Create Password-Protected Zip Files and Unzip Them in Java](https://www.baeldung.com/java-password-protected-zip-unzip)
-
+- [How to Create CSV File from POJO with Custom Column Headers and Positions](https://www.baeldung.com/java-create-csv-pojo-customize-columns)

persistence-modules/hibernate-ogm/src/test/java/com/baeldung/hibernate/ogm/EditorUnitTest.java

@@ -22,6 +22,7 @@ public class EditorUnitTest {
         loadAndVerifyTestData(entityManagerFactory, editor);
     }
     */
+
     @Test
     public void givenNeo4j_WhenEntitiesCreated_thenCanBeRetrieved() throws Exception {
         EntityManagerFactory entityManagerFactory = Persistence.createEntityManagerFactory("ogm-neo4j");

persistence-modules/pom.xml

@@ -106,6 +106,7 @@
         <module>spring-jpa</module>
         <module>spring-jpa-2</module>
         <module>spring-jdbc</module>
+	<module>spring-jdbc-2</module>
         <module>spring-jooq</module>
         <module>spring-mybatis</module>
         <module>spring-persistence-simple</module>

persistence-modules/spring-jdbc-2/pom.xml

@@ -0,0 +1,93 @@
+<?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>org.example</groupId>
+    <artifactId>spring-jdbc-2</artifactId>
+    <version>1.0-SNAPSHOT</version>
+    <name>spring-jdbc-2</name>
+    <description>Demo project for Spring Jdbc</description>
+
+    <parent>
+        <groupId>com.baeldung</groupId>
+        <artifactId>parent-boot-3</artifactId>
+        <version>0.0.1-SNAPSHOT</version>
+        <relativePath>../../parent-boot-3</relativePath>
+    </parent>
+
+    <dependencies>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-jdbc</artifactId>
+        </dependency>
+
+        <dependency>
+            <groupId>com.h2database</groupId>
+            <artifactId>h2</artifactId>
+            <scope>runtime</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-test</artifactId>
+
+        </dependency>
+    </dependencies>
+
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.springframework.boot</groupId>
+                <artifactId>spring-boot-maven-plugin</artifactId>
+            </plugin>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-compiler-plugin</artifactId>
+            </plugin>
+        </plugins>
+    </build>
+    <repositories>
+        <repository>
+            <id>spring-milestones</id>
+            <name>Spring Milestones</name>
+            <url>https://repo.spring.io/milestone</url>
+            <snapshots>
+                <enabled>false</enabled>
+            </snapshots>
+        </repository>
+        <repository>
+            <id>spring-snapshots</id>
+            <name>Spring Snapshots</name>
+            <url>https://repo.spring.io/snapshot</url>
+            <releases>
+                <enabled>false</enabled>
+            </releases>
+        </repository>
+    </repositories>
+    <pluginRepositories>
+        <pluginRepository>
+            <id>spring-milestones</id>
+            <name>Spring Milestones</name>
+            <url>https://repo.spring.io/milestone</url>
+            <snapshots>
+                <enabled>false</enabled>
+            </snapshots>
+        </pluginRepository>
+        <pluginRepository>
+            <id>spring-snapshots</id>
+            <name>Spring Snapshots</name>
+            <url>https://repo.spring.io/snapshot</url>
+            <releases>
+                <enabled>false</enabled>
+            </releases>
+        </pluginRepository>
+    </pluginRepositories>
+
+    <properties>
+        <spring-boot.version>3.2.0-SNAPSHOT</spring-boot.version>
+        <junit-jupiter.version>5.10.0</junit-jupiter.version>
+        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+    </properties>
+
+</project>

persistence-modules/spring-jdbc-2/src/main/java/com/baeldung/jdbcclient/JdbcClientDemoApplication.java

@@ -0,0 +1,14 @@
+package com.baeldung.jdbcclient;
+
+import org.springframework.boot.SpringApplication;
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+import org.springframework.context.annotation.ComponentScan;
+
+@SpringBootApplication
+@ComponentScan(basePackages = "com.baledung.jdbcclient")
+public class JdbcClientDemoApplication {
+
+    public static void main(String[] args) {
+        SpringApplication.run(JdbcClientDemoApplication.class, args);
+    }
+}

persistence-modules/spring-jdbc-2/src/main/java/com/baeldung/jdbcclient/dao/StudentDao.java

@@ -0,0 +1,95 @@
+package com.baeldung.jdbcclient.dao;
+
+import com.baeldung.jdbcclient.model.Student;
+import com.baeldung.jdbcclient.model.StudentResultExtractor;
+import com.baeldung.jdbcclient.model.StudentRowMapper;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.jdbc.core.RowCountCallbackHandler;
+import org.springframework.jdbc.core.simple.JdbcClient;
+import org.springframework.stereotype.Repository;
+
+import java.sql.Types;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+
+@Repository
+public class StudentDao {
+
+    private static final Logger logger = LoggerFactory.getLogger(StudentDao.class);
+    @Autowired
+    private JdbcClient jdbcClient;
+
+    public Integer insertWithSetParamWithNamedParamAndSqlType(Student student) {
+        String sql = "INSERT INTO student (student_name, age, grade, gender, state)"
+          + "VALUES (:name, :age, :grade, :gender, :state)";
+        Integer noOfrowsAffected = this.jdbcClient.sql(sql)
+          .param("name", student.getStudentName(), Types.VARCHAR)
+          .param("age", student.getAge(), Types.INTEGER)
+          .param("grade", student.getGrade(), Types.INTEGER)
+          .param("gender", student.getStudentGender(), Types.VARCHAR)
+          .param("state", student.getState(), Types.VARCHAR)
+          .update();
+        logger.info("No. of rows affected: " + noOfrowsAffected);
+        return noOfrowsAffected;
+    }
+
+    public List<Student> getStudentsOfGradeStateAndGenderWithPositionalParams(int grade, String state, String gender) {
+        String sql = "select student_id, student_name, age, grade, gender, state from student"
+          + " where grade = ? and state = ? and gender = ?";
+        return jdbcClient.sql(sql)
+          .param(grade)
+          .param(state)
+          .param(gender)
+          .query(new StudentRowMapper()).list();
+    }
+
+    public List<Student> getStudentsOfGradeStateAndGenderWithParamIndex(int grade, String state, String gender) {
+        String sql = "select student_id, student_name, age, grade, gender, state from student"
+          + " where grade = ? and state = ? and gender = ?";
+        return jdbcClient.sql(sql)
+          .param(1,grade)
+          .param(2, state)
+          .param(3, gender)
+          .query(new StudentResultExtractor());
+    }
+
+    public Student getStudentsOfGradeStateAndGenderWithParamsInVarargs(int grade, String state, String gender) {
+        String sql = "select student_id, student_name, age, grade, gender, state from student"
+          + " where grade = ? and state = ? and gender = ? limit 1";
+        return jdbcClient.sql(sql)
+          .params(grade, state, gender)
+          .query(new StudentRowMapper()).single();
+    }
+
+    public Optional<Student> getStudentsOfGradeStateAndGenderWithParamsInList(List params) {
+        String sql = "select student_id, student_name, age, grade, gender, state from student"
+          + " where grade = ? and state = ? and gender = ? limit 1";
+        return jdbcClient.sql(sql)
+          .params(params)
+          .query(new StudentRowMapper()).optional();
+    }
+
+
+    public int getCountOfStudentsOfGradeStateAndGenderWithNamedParam(int grade, String state, String gender) {
+        String sql = "select student_id, student_name, age, grade, gender, state from student"
+          + " where grade = :grade and state = :state and gender = :gender";
+        RowCountCallbackHandler countCallbackHandler = new RowCountCallbackHandler();
+        jdbcClient.sql(sql)
+          .param("grade", grade)
+          .param("state", state)
+          .param("gender", gender)
+          .query(countCallbackHandler);
+        return countCallbackHandler.getRowCount();
+    }
+
+    public List<Student> getStudentsOfGradeStateAndGenderWithParamMap(Map<String, ?> paramMap) {
+        String sql = "select student_id, student_name, age, grade, gender, state from student"
+          + " where grade = :grade and state = :state and gender = :gender";
+        return jdbcClient.sql(sql)
+          .params(paramMap)
+          .query(new StudentRowMapper()).list();
+    }
+}