Merge branch 'master' of https://github.com/eugenp/tutorials into BAEL-7487-resolve-multiple-completable-futures

.gitignore

@@ -64,13 +64,13 @@ core-java-io/hard_link.txt
 core-java-io/target_link.txt
 core-java/src/main/java/com/baeldung/manifest/MANIFEST.MF
 ethereum/logs/
-jmeter/src/main/resources/*-JMeter.csv
-jmeter/src/main/resources/*-Basic*.csv
-jmeter/src/main/resources/*-JMeter*.csv
-jmeter/src/main/resources/*ReportsDashboard*.csv
-jmeter/src/main/resources/dashboard/*ReportsDashboard*.csv
-jmeter/src/main/resources/*FileExtractionExample.csv
-jmeter/src/main/resources/*_Summary-Report.csv
+testing-modules/jmeter/src/main/resources/*-JMeter.csv
+testing-modules/jmeter/src/main/resources/*-Basic*.csv
+testing-modules/jmeter/src/main/resources/*-JMeter*.csv
+testing-modules/jmeter/src/main/resources/*ReportsDashboard*.csv
+testing-modules/jmeter/src/main/resources/dashboard/*ReportsDashboard*.csv
+testing-modules/jmeter/src/main/resources/*FileExtractionExample.csv
+testing-modules/jmeter/src/main/resources/*_Summary-Report.csv
 
 ninja/devDb.mv.db
 
@@ -128,3 +128,6 @@ persistence-modules/neo4j/data/**
 /deep-shallow-copy/.mvn/wrapper
 /deep-shallow-copy/mvnw
 /deep-shallow-copy/mvnw.cmd
+
+#spring-5-webflux-2
+**/testdb.mv.db

algorithms-modules/algorithms-miscellaneous-2/pom.xml

@@ -14,16 +14,6 @@
     </parent>
 
     <dependencies>
-        <dependency>
-            <groupId>org.apache.commons</groupId>
-            <artifactId>commons-math3</artifactId>
-            <version>${commons-math3.version}</version>
-        </dependency>
-        <dependency>
-            <groupId>commons-codec</groupId>
-            <artifactId>commons-codec</artifactId>
-            <version>${commons-codec.version}</version>
-        </dependency>
         <dependency>
             <groupId>org.projectlombok</groupId>
             <artifactId>lombok</artifactId>

algorithms-modules/algorithms-miscellaneous-2/src/test/java/com/baeldung/algorithms/DijkstraAlgorithmLongRunningUnitTest.java

@@ -1,7 +1,5 @@
 package com.baeldung.algorithms;
 
-
-
 import com.baeldung.algorithms.ga.dijkstra.Dijkstra;
 import com.baeldung.algorithms.ga.dijkstra.Graph;
 import com.baeldung.algorithms.ga.dijkstra.Node;

algorithms-modules/algorithms-miscellaneous-7/README.md

@@ -5,4 +5,5 @@
 - [Getting Pixel Array From Image in Java](https://www.baeldung.com/java-getting-pixel-array-from-image)
 - [Calculate Distance Between Two Coordinates in Java](https://www.baeldung.com/java-find-distance-between-points)
 - [Rotate Arrays in Java](https://www.baeldung.com/java-rotate-arrays)
+- [Find Missing Number From a Given Array in Java](https://www.baeldung.com/java-array-find-missing-number)
 - More articles: [[<-- prev]](/algorithms-miscellaneous-6)

algorithms-modules/algorithms-miscellaneous-7/src/test/java/com/baeldung/algorithms/weightedaverage/WeightedAverageUnitTest.java

@@ -0,0 +1,153 @@
+package com.baeldung.algorithms.weightedaverage;
+
+import org.junit.jupiter.api.Test;
+
+import java.util.*;
+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.IntStream;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+public class WeightedAverageUnitTest {
+
+    private List<Values> values = Arrays.asList(
+            new Values(1, 10),
+            new Values(3, 20),
+            new Values(5, 30),
+            new Values(7, 50),
+            new Values(9, 40)
+    );
+
+    private Double expected = 6.2;
+
+    @Test
+    void twoPass() {
+        double top = values.stream()
+                .mapToDouble(v -> v.value * v.weight)
+                .sum();
+        double bottom = values.stream()
+                .mapToDouble(v -> v.weight)
+                .sum();
+
+        double result = top / bottom;
+        assertEquals(expected, result);
+    }
+
+    @Test
+    void onePass() {
+        double top = 0;
+        double bottom = 0;
+
+        for (Values v : values) {
+            top += (v.value * v.weight);
+            bottom += v.weight;
+        }
+
+        double result = top / bottom;
+        assertEquals(expected, result);
+    }
+
+    @Test
+    void expanding() {
+        double result = values.stream()
+                .flatMap(v -> Collections.nCopies(v.weight, v.value).stream())
+                .mapToInt(v -> v)
+                .average()
+                .getAsDouble();
+        assertEquals(expected, result);
+    }
+
+    @Test
+    void reduce() {
+        class WeightedAverage {
+            final double top;
+            final double bottom;
+
+            public WeightedAverage(double top, double bottom) {
+                this.top = top;
+                this.bottom = bottom;
+            }
+
+            double average() {
+                return top / bottom;
+            }
+        }
+
+        double result = values.stream()
+                .reduce(new WeightedAverage(0, 0),
+                        (acc, next) -> new WeightedAverage(
+                                acc.top + (next.value * next.weight),
+                                acc.bottom + next.weight),
+                        (left, right) -> new WeightedAverage(
+                                left.top + right.top,
+                                left.bottom + right.bottom))
+                .average();
+        assertEquals(expected, result);
+    }
+
+    @Test
+    void customCollector() {
+        class WeightedAverage implements Collector<Values, WeightedAverage.RunningTotals, Double> {
+            class RunningTotals {
+                double top;
+                double bottom;
+
+                public RunningTotals() {
+                    this.top = 0;
+                    this.bottom = 0;
+                }
+            }
+
+            @Override
+            public Supplier<RunningTotals> supplier() {
+                return RunningTotals::new;
+            }
+
+            @Override
+            public BiConsumer<RunningTotals, Values> accumulator() {
+                return (current, next) -> {
+                    current.top += (next.value * next.weight);
+                    current.bottom += next.weight;
+                };
+            }
+
+            @Override
+            public BinaryOperator<RunningTotals> combiner() {
+                return (left, right) -> {
+                    left.top += right.top;
+                    left.bottom += right.bottom;
+
+                    return left;
+                };
+            }
+
+            @Override
+            public Function<RunningTotals, Double> finisher() {
+                return rt -> rt.top / rt.bottom;
+            }
+
+            @Override
+            public Set<Characteristics> characteristics() {
+                return Collections.singleton(Characteristics.UNORDERED);
+            }
+        }
+
+        double result = values.stream()
+                .collect(new WeightedAverage());
+        assertEquals(expected, result);
+    }
+
+    private static class Values {
+        int value;
+        int weight;
+
+        public Values(int value, int weight) {
+            this.value = value;
+            this.weight = weight;
+        }
+    }
+}

apache-cxf-modules/cxf-aegis/pom.xml

@@ -20,8 +20,4 @@
         </dependency>
     </dependencies>
 
-    <properties>
-        <cxf.version>4.0.0</cxf.version>
-    </properties>
-
 </project>

apache-cxf-modules/cxf-introduction/pom.xml

@@ -48,7 +48,6 @@
     </build>
 
     <properties>
-        <cxf.version>4.0.0</cxf.version>
         <jakarta-xml.version>4.0.0</jakarta-xml.version>
         <jakarta.jws.version>3.0.0</jakarta.jws.version>
     </properties>

apache-cxf-modules/cxf-jaxrs-implementation/pom.xml

@@ -16,12 +16,12 @@
         <dependency>
             <groupId>org.apache.cxf</groupId>
             <artifactId>cxf-rt-frontend-jaxrs</artifactId>
-            <version>4.0.0</version>
+            <version>${cxf.version}</version>
         </dependency>
         <dependency>
             <groupId>org.apache.cxf</groupId>
             <artifactId>cxf-rt-transports-http-jetty</artifactId>
-            <version>4.0.0</version>
+            <version>${cxf.version}</version>
         </dependency>
         <dependency>
             <groupId>jakarta.xml.ws</groupId>

apache-cxf-modules/cxf-spring/pom.xml

@@ -115,6 +115,7 @@
     </profiles>
 
     <properties>
+        <cxf.version>3.1.8</cxf.version>
         <spring.version>5.3.25</spring.version>
         <cargo-maven2-plugin.version>1.6.1</cargo-maven2-plugin.version>
         <jstl.version>1.2</jstl.version>

apache-cxf-modules/pom.xml

@@ -35,7 +35,7 @@
     </build>
 
     <properties>
-        <cxf.version>3.1.8</cxf.version>
+        <cxf.version>4.0.0</cxf.version>
     </properties>
 
 </project>

apache-cxf-modules/sse-jaxrs/sse-jaxrs-client/pom.xml

@@ -16,12 +16,12 @@
         <dependency>
             <groupId>org.apache.cxf</groupId>
             <artifactId>cxf-rt-rs-client</artifactId>
-            <version>${cxf-version}</version>
+            <version>${cxf.version}</version>
         </dependency>
         <dependency>
             <groupId>org.apache.cxf</groupId>
             <artifactId>cxf-rt-rs-sse</artifactId>
-            <version>${cxf-version}</version>
+            <version>${cxf.version}</version>
         </dependency>
         <dependency>
             <groupId>jakarta.ws.rs</groupId>
@@ -60,7 +60,6 @@
     </build>
 
     <properties>
-        <cxf-version>4.0.0</cxf-version>
         <jakarta-ws.version>3.1.0</jakarta-ws.version>
     </properties>
 

apache-kafka-2/README.md

@@ -15,3 +15,4 @@ You can build the project from the command line using: *mvn clean install*, or i
 - [bootstrap-server in Kafka Configuration](https://www.baeldung.com/java-kafka-bootstrap-server)
 - [Introduction to Apache Kafka](https://www.baeldung.com/apache-kafka)
 - [Ensuring Message Ordering in Kafka: Strategies and Configurations](https://www.baeldung.com/kafka-message-ordering)
+- [Read Multiple Messages with Apache Kafka](https://www.baeldung.com/kafka-read-multiple-messages)

apache-poi-3/README.md

@@ -1,3 +1,4 @@
 ## Relevant Articles
 - [How To Convert Excel Data Into List Of Java Objects](https://www.baeldung.com/java-convert-excel-data-into-list)
 - [Expand Columns with Apache POI](https://www.baeldung.com/java-apache-poi-expand-columns)
+- [Apply Bold Text Style for an Entire Row Using Apache POI](https://www.baeldung.com/appache-poi-apply-bold-text-style-entire-row)

apache-poi-3/pom.xml

@@ -76,7 +76,7 @@
     </dependencies>
 
     <properties>
-        <poi.version>5.2.3</poi.version>
+        <poi.version>5.2.5</poi.version>
         <poiji.version>4.1.1</poiji.version>
         <fastexcel.version>0.15.7</fastexcel.version>
         <jxl.version>2.6.12</jxl.version>

apache-poi-3/src/main/java/com/baeldung/poi/rowstyle/PoiUtils.java

@@ -0,0 +1,53 @@
+package com.baeldung.poi.rowstyle;
+
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.nio.file.Path;
+
+import org.apache.poi.ss.usermodel.Cell;
+import org.apache.poi.ss.usermodel.CellStyle;
+import org.apache.poi.ss.usermodel.Font;
+import org.apache.poi.ss.usermodel.Row;
+import org.apache.poi.ss.usermodel.Sheet;
+import org.apache.poi.ss.usermodel.Workbook;
+
+public class PoiUtils {
+
+    private PoiUtils() {
+    }
+
+    private static void newCell(Row row, String value) {
+        short cellNum = row.getLastCellNum();
+        if (cellNum == -1)
+            cellNum = 0;
+
+        Cell cell = row.createCell(cellNum);
+        cell.setCellValue(value);
+    }
+
+    public static Row newRow(Sheet sheet, String... rowValues) {
+        Row row = sheet.createRow(sheet.getLastRowNum() + 1);
+
+        for (String value : rowValues) {
+            newCell(row, value);
+        }
+
+        return row;
+    }
+
+    public static CellStyle boldFontStyle(Workbook workbook) {
+        Font boldFont = workbook.createFont();
+        boldFont.setBold(true);
+
+        CellStyle boldStyle = workbook.createCellStyle();
+        boldStyle.setFont(boldFont);
+
+        return boldStyle;
+    }
+
+    public static void write(Workbook workbook, Path path) throws IOException {
+        try (FileOutputStream fileOut = new FileOutputStream(path.toFile())) {
+            workbook.write(fileOut);
+        }
+    }
+}

apache-poi-3/src/test/java/com/baeldung/poi/rowstyle/PoiBoldStyleIntegrationTest.java

@@ -0,0 +1,150 @@
+package com.baeldung.poi.rowstyle;
+
+import static org.junit.jupiter.api.Assertions.assertNotEquals;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+
+import org.apache.poi.hssf.usermodel.HSSFCellStyle;
+import org.apache.poi.hssf.usermodel.HSSFWorkbook;
+import org.apache.poi.openxml4j.exceptions.InvalidFormatException;
+import org.apache.poi.ss.usermodel.CellStyle;
+import org.apache.poi.ss.usermodel.Row;
+import org.apache.poi.ss.usermodel.Sheet;
+import org.apache.poi.ss.usermodel.Workbook;
+import org.apache.poi.xssf.streaming.SXSSFWorkbook;
+import org.apache.poi.xssf.usermodel.XSSFCellStyle;
+import org.apache.poi.xssf.usermodel.XSSFWorkbook;
+import org.junit.jupiter.api.Test;
+
+class PoiBoldStyleIntegrationTest {
+
+    private void writeSampleSheet(Path destination, Workbook workbook) throws IOException {
+        Sheet sheet = workbook.createSheet();
+        CellStyle boldStyle = PoiUtils.boldFontStyle(workbook);
+
+        Row header = PoiUtils.newRow(sheet, "Name", "Value", "Details");
+        header.setRowStyle(boldStyle);
+
+        PoiUtils.newRow(sheet, "Albert", "A", "First");
+        PoiUtils.newRow(sheet, "Jane", "B", "Second");
+        PoiUtils.newRow(sheet, "Zack", "C", "Third");
+
+        PoiUtils.write(workbook, destination);
+    }
+
+    private void assertRowStyleAppliedAndDefaultCellStylesDontMatch(Path sheetFile) throws IOException, InvalidFormatException {
+        try (Workbook workbook = new XSSFWorkbook(sheetFile.toFile())) {
+            Sheet sheet = workbook.getSheetAt(0);
+            Row row0 = sheet.getRow(0);
+
+            XSSFCellStyle rowStyle = (XSSFCellStyle) row0.getRowStyle();
+            assertTrue(rowStyle.getFont()
+                .getBold());
+
+            row0.forEach(cell -> {
+                XSSFCellStyle style = (XSSFCellStyle) cell.getCellStyle();
+                assertNotEquals(rowStyle, style);
+            });
+
+            Row row1 = sheet.getRow(1);
+            XSSFCellStyle row1Style = (XSSFCellStyle) row1.getRowStyle();
+            assertNull(row1Style);
+
+            Files.delete(sheetFile);
+        }
+    }
+
+    @Test
+    void givenXssfWorkbook_whenSetRowStyle1stRow_thenOnly1stRowStyled() throws IOException, InvalidFormatException {
+        Path sheetFile = Files.createTempFile("xssf-row-style", ".xlsx");
+
+        try (Workbook workbook = new XSSFWorkbook()) {
+            writeSampleSheet(sheetFile, workbook);
+        }
+
+        assertRowStyleAppliedAndDefaultCellStylesDontMatch(sheetFile);
+    }
+
+    @Test
+    void givenSxssfWorkbook_whenSetRowStyle_thenOnly1stRowStyled() throws IOException, InvalidFormatException {
+        Path sheetFile = Files.createTempFile("sxssf-row-style", ".xlsx");
+
+        try (Workbook workbook = new SXSSFWorkbook()) {
+            writeSampleSheet(sheetFile, workbook);
+        }
+
+        assertRowStyleAppliedAndDefaultCellStylesDontMatch(sheetFile);
+    }
+
+    @Test
+    void givenHssfWorkbook_whenSetRowStyle_thenOnly1stRowStyled() throws IOException {
+        Path sheetFile = Files.createTempFile("hssf-row-style", ".xls");
+
+        try (Workbook workbook = new HSSFWorkbook()) {
+            writeSampleSheet(sheetFile, workbook);
+        }
+
+        try (Workbook workbook = new HSSFWorkbook(Files.newInputStream(sheetFile))) {
+            Sheet sheet = workbook.getSheetAt(0);
+            Row row0 = sheet.getRow(0);
+
+            HSSFCellStyle rowStyle = (HSSFCellStyle) row0.getRowStyle();
+            assertTrue(rowStyle.getFont(workbook)
+                .getBold());
+
+            row0.forEach(cell -> {
+                HSSFCellStyle style = (HSSFCellStyle) cell.getCellStyle();
+                assertNotEquals(rowStyle, style);
+            });
+
+            Row row1 = sheet.getRow(1);
+            HSSFCellStyle row1Style = (HSSFCellStyle) row1.getRowStyle();
+            assertNull(row1Style);
+
+            Files.delete(sheetFile);
+        }
+    }
+
+    @Test
+    void givenXssfWorkbook_whenSetCellStyleForEachRow_thenAllCellsContainStyle() throws IOException, InvalidFormatException {
+        Path sheetFile = Files.createTempFile("xssf-cell-style", ".xlsx");
+
+        try (Workbook workbook = new XSSFWorkbook()) {
+            Sheet sheet = workbook.createSheet();
+            CellStyle boldStyle = PoiUtils.boldFontStyle(workbook);
+
+            Row header = PoiUtils.newRow(sheet, "Name", "Value", "Details");
+            header.forEach(cell -> cell.setCellStyle(boldStyle));
+
+            PoiUtils.newRow(sheet, "Albert", "A", "First");
+            PoiUtils.newRow(sheet, "Jane", "B", "Second");
+            PoiUtils.newRow(sheet, "Zack", "C", "Third");
+
+            PoiUtils.write(workbook, sheetFile);
+        }
+
+        try (Workbook workbook = new XSSFWorkbook(sheetFile.toFile())) {
+            Sheet sheet = workbook.getSheetAt(0);
+            Row row0 = sheet.getRow(0);
+
+            XSSFCellStyle rowStyle = (XSSFCellStyle) row0.getRowStyle();
+            assertNull(rowStyle);
+
+            row0.forEach(cell -> {
+                XSSFCellStyle style = (XSSFCellStyle) cell.getCellStyle();
+                assertTrue(style.getFont()
+                    .getBold());
+            });
+
+            Row row1 = sheet.getRow(1);
+            rowStyle = (XSSFCellStyle) row1.getRowStyle();
+            assertNull(rowStyle);
+
+            Files.delete(sheetFile);
+        }
+    }
+}

aws-modules/aws-lambda-modules/lambda-function/pom.xml

@@ -97,7 +97,7 @@
         <json-simple.version>1.1.1</json-simple.version>
         <aws-lambda-java-events.version>3.11.0</aws-lambda-java-events.version>
         <aws-lambda-java-core.version>1.2.1</aws-lambda-java-core.version>
-        <gson.version>2.8.2</gson.version>
+        <gson.version>2.10.1</gson.version>
     </properties>
 
 </project>

core-java-modules/core-java-11-3/pom.xml

@@ -46,7 +46,7 @@
         <maven.compiler.source.version>11</maven.compiler.source.version>
         <maven.compiler.target.version>11</maven.compiler.target.version>
         <jackson.version>2.16.0</jackson.version>
-        <gson.version>2.10</gson.version>
+        <gson.version>2.10.1</gson.version>
     </properties>
 
 </project>

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

@@ -3,3 +3,4 @@
 - [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)
+- [JFR View Command in Java 21](https://www.baeldung.com/java-flight-recorder-view)

core-java-modules/core-java-21/src/main/java/com/baeldung/jfrview/JFRExample.java

@@ -0,0 +1,21 @@
+package com.baeldung.jfrview;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class JFRExample {
+    public static void main(String[] args) {
+        JFRExample se = new JFRExample();
+        se.insertToList(new ArrayList<>());
+    }
+
+    private void insertToList(List<Object> list) {
+        try {
+            while (true) {
+                list.add(new Object());
+            }
+        } catch (OutOfMemoryError e) {
+            System.out.println("Out of Memory. Exiting");
+        }
+    }
+}

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

@@ -9,4 +9,8 @@
 - [Round the Date in Java](https://www.baeldung.com/java-round-the-date)
 - [Representing Furthest Possible Date in Java](https://www.baeldung.com/java-date-represent-max)
 - [Retrieving Unix Time in Java](https://www.baeldung.com/java-retrieve-unix-time)
+- [Calculate Months Between Two Dates in Java](https://www.baeldung.com/java-months-difference-two-dates)
+- [Format LocalDate to ISO 8601 With T and Z](https://www.baeldung.com/java-format-localdate-iso-8601-t-z)
+- [Check if Two Date Ranges Overlap](https://www.baeldung.com/java-check-two-date-ranges-overlap)
+- [Difference between ZoneOffset.UTC and ZoneId.of(“UTC”)](https://www.baeldung.com/java-zoneoffset-utc-zoneid-of)
 - [[<-- Prev]](/core-java-modules/core-java-datetime-java8-1)

core-java-modules/core-java-8-datetime-2/src/main/java/com/baeldung/daterangeoverlap/DateRangeOverlapChecker.java

@@ -0,0 +1,46 @@
+package com.baeldung.daterangeoverlap;
+
+import java.time.LocalDate;
+import java.util.Calendar;
+
+import org.joda.time.DateTime;
+import org.joda.time.Interval;
+
+public class DateRangeOverlapChecker {
+
+    public static boolean isOverlapUsingCalendarAndDuration(Calendar start1, Calendar end1, Calendar start2, Calendar end2) {
+        long overlap = Math.min(end1.getTimeInMillis(), end2.getTimeInMillis()) - Math.max(start1.getTimeInMillis(), start2.getTimeInMillis());
+        return overlap >= 0;
+    }
+
+    public static boolean isOverlapUsingLocalDateAndDuration(LocalDate start1, LocalDate end1, LocalDate start2, LocalDate end2) {
+        long overlap = Math.min(end1.toEpochDay(), end2.toEpochDay()) - Math.max(start1.toEpochDay(), start2.toEpochDay());
+        return overlap >= 0;
+    }
+
+    public static boolean isOverlapUsingJodaTime(DateTime start1, DateTime end1, DateTime start2, DateTime end2) {
+        Interval interval1 = new Interval(start1, end1);
+        Interval interval2 = new Interval(start2, end2);
+        return interval1.overlaps(interval2);
+    }
+
+    public static boolean isOverlapUsingCalendarAndCondition(Calendar start1, Calendar end1, Calendar start2, Calendar end2) {
+        return !(end1.before(start2) || start1.after(end2));
+    }
+
+    public static boolean isOverlapUsingLocalDateAndCondition(LocalDate start1, LocalDate end1, LocalDate start2, LocalDate end2) {
+        return !(end1.isBefore(start2) || start1.isAfter(end2));
+    }
+
+    public static boolean isOverlapUsingCalendarAndFindMin(Calendar start1, Calendar end1, Calendar start2, Calendar end2) {
+        long overlap1 = Math.min(end1.getTimeInMillis() - start1.getTimeInMillis(), end1.getTimeInMillis() - start2.getTimeInMillis());
+        long overlap2 = Math.min(end2.getTimeInMillis() - start2.getTimeInMillis(), end2.getTimeInMillis() - start1.getTimeInMillis());
+        return Math.min(overlap1, overlap2) / (24 * 60 * 60 * 1000) >= 0;
+    }
+
+    public static boolean isOverlapUsingLocalDateAndFindMin(LocalDate start1, LocalDate end1, LocalDate start2, LocalDate end2) {
+        long overlap1 = Math.min(end1.toEpochDay() - start1.toEpochDay(), end1.toEpochDay() - start2.toEpochDay());
+        long overlap2 = Math.min(end2.toEpochDay() - start2.toEpochDay(), end2.toEpochDay() - start1.toEpochDay());
+        return Math.min(overlap1, overlap2) >= 0;
+    }
+}

core-java-modules/core-java-8-datetime-2/src/test/java/com/baeldung/daterangeoverlap/DateRangeOverlapCheckerUnitTest.java

@@ -0,0 +1,158 @@
+package com.baeldung.daterangeoverlap;
+
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+import java.time.LocalDate;
+import java.util.Calendar;
+
+import org.joda.time.DateTime;
+import org.junit.Test;
+
+public class DateRangeOverlapCheckerUnitTest {
+
+    @Test
+    public void givenPartialOverlappingRanges_thenReturnsTrue() {
+        Calendar start1 = Calendar.getInstance();
+        start1.set(2024, 11, 15);
+        Calendar end1 = Calendar.getInstance();
+        end1.set(2024, 11, 20);
+
+        Calendar start2 = Calendar.getInstance();
+        start2.set(2024, 11, 18);
+        Calendar end2 = Calendar.getInstance();
+        end2.set(2024, 11, 22);
+
+        LocalDate startLD1 = LocalDate.of(2024, 12, 15);
+        LocalDate endLD1 = LocalDate.of(2024, 12, 20);
+
+        LocalDate startLD2 = LocalDate.of(2024, 12, 18);
+        LocalDate endLD2 = LocalDate.of(2024, 12, 22);
+
+        DateTime startJT1 = new DateTime(2024, 12, 15, 0, 0);
+        DateTime endJT1 = new DateTime(2024, 12, 20, 0, 0);
+
+        DateTime startJT2 = new DateTime(2024, 12, 18, 0, 0);
+        DateTime endJT2 = new DateTime(2024, 12, 22, 0, 0);
+
+        assertTrue(DateRangeOverlapChecker.isOverlapUsingCalendarAndDuration(start1, end1, start2, end2));
+        assertTrue(DateRangeOverlapChecker.isOverlapUsingLocalDateAndDuration(startLD1, endLD1, startLD2, endLD2));
+
+        assertTrue(DateRangeOverlapChecker.isOverlapUsingCalendarAndCondition(start1, end1, start2, end2));
+        assertTrue(DateRangeOverlapChecker.isOverlapUsingLocalDateAndCondition(startLD1, endLD1, startLD2, endLD2));
+
+        assertTrue(DateRangeOverlapChecker.isOverlapUsingCalendarAndFindMin(start1, end1, start2, end2));
+        assertTrue(DateRangeOverlapChecker.isOverlapUsingLocalDateAndFindMin(startLD1, endLD1, startLD2, endLD2));
+
+        assertTrue(DateRangeOverlapChecker.isOverlapUsingJodaTime(startJT1, endJT1, startJT2, endJT2));
+    }
+
+    @Test
+    public void givenFullOverlappingRanges_thenReturnsTrue() {
+        Calendar start1 = Calendar.getInstance();
+        start1.set(2024, 11, 15);
+        Calendar end1 = Calendar.getInstance();
+        end1.set(2024, 11, 20);
+
+        Calendar start2 = Calendar.getInstance();
+        start2.set(2024, 11, 16);
+        Calendar end2 = Calendar.getInstance();
+        end2.set(2024, 11, 18);
+
+        LocalDate startLD1 = LocalDate.of(2024, 12, 15);
+        LocalDate endLD1 = LocalDate.of(2024, 12, 20);
+
+        LocalDate startLD2 = LocalDate.of(2024, 12, 16);
+        LocalDate endLD2 = LocalDate.of(2024, 12, 18);
+
+        DateTime startJT1 = new DateTime(2024, 12, 15, 0, 0);
+        DateTime endJT1 = new DateTime(2024, 12, 20, 0, 0);
+
+        DateTime startJT2 = new DateTime(2024, 12, 16, 0, 0);
+        DateTime endJT2 = new DateTime(2024, 12, 18, 0, 0);
+
+        assertTrue(DateRangeOverlapChecker.isOverlapUsingCalendarAndDuration(start1, end1, start2, end2));
+        assertTrue(DateRangeOverlapChecker.isOverlapUsingLocalDateAndDuration(startLD1, endLD1, startLD2, endLD2));
+
+        assertTrue(DateRangeOverlapChecker.isOverlapUsingCalendarAndCondition(start1, end1, start2, end2));
+        assertTrue(DateRangeOverlapChecker.isOverlapUsingLocalDateAndCondition(startLD1, endLD1, startLD2, endLD2));
+
+        assertTrue(DateRangeOverlapChecker.isOverlapUsingCalendarAndFindMin(start1, end1, start2, end2));
+        assertTrue(DateRangeOverlapChecker.isOverlapUsingLocalDateAndFindMin(startLD1, endLD1, startLD2, endLD2));
+
+        assertTrue(DateRangeOverlapChecker.isOverlapUsingJodaTime(startJT1, endJT1, startJT2, endJT2));
+    }
+
+    @Test
+    public void givenConsecutiveRanges_thenReturnsFalse() {
+        Calendar start1 = Calendar.getInstance();
+        start1.set(2024, 11, 15);
+        Calendar end1 = Calendar.getInstance();
+        end1.set(2024, 11, 20);
+
+        Calendar start2 = Calendar.getInstance();
+        start2.set(2024, 11, 21);
+        Calendar end2 = Calendar.getInstance();
+        end2.set(2024, 11, 24);
+
+        LocalDate startLD1 = LocalDate.of(2024, 12, 15);
+        LocalDate endLD1 = LocalDate.of(2024, 12, 20);
+
+        LocalDate startLD2 = LocalDate.of(2024, 12, 21);
+        LocalDate endLD2 = LocalDate.of(2024, 12, 24);
+
+        DateTime startJT1 = new DateTime(2024, 12, 15, 0, 0);
+        DateTime endJT1 = new DateTime(2024, 12, 20, 0, 0);
+
+        DateTime startJT2 = new DateTime(2024, 12, 21, 0, 0);
+        DateTime endJT2 = new DateTime(2024, 12, 24, 0, 0);
+
+        assertFalse(DateRangeOverlapChecker.isOverlapUsingCalendarAndDuration(start1, end1, start2, end2));
+        assertFalse(DateRangeOverlapChecker.isOverlapUsingLocalDateAndDuration(startLD1, endLD1, startLD2, endLD2));
+
+        assertFalse(DateRangeOverlapChecker.isOverlapUsingCalendarAndCondition(start1, end1, start2, end2));
+        assertFalse(DateRangeOverlapChecker.isOverlapUsingLocalDateAndCondition(startLD1, endLD1, startLD2, endLD2));
+
+        assertFalse(DateRangeOverlapChecker.isOverlapUsingCalendarAndFindMin(start1, end1, start2, end2));
+        assertFalse(DateRangeOverlapChecker.isOverlapUsingLocalDateAndFindMin(startLD1, endLD1, startLD2, endLD2));
+
+        assertFalse(DateRangeOverlapChecker.isOverlapUsingJodaTime(startJT1, endJT1, startJT2, endJT2));
+    }
+
+    @Test
+    public void givenZeroRangeRanges_thenReturnsTrue() {
+        Calendar start1 = Calendar.getInstance();
+        start1.set(2024, 11, 15);
+        Calendar end1 = Calendar.getInstance();
+        end1.set(2024, 11, 20);
+
+        Calendar start2 = Calendar.getInstance();
+        start2.set(2024, 11, 20);
+        Calendar end2 = Calendar.getInstance();
+        end2.set(2024, 11, 20);
+
+        LocalDate startLD1 = LocalDate.of(2024, 12, 15);
+        LocalDate endLD1 = LocalDate.of(2024, 12, 20);
+
+        LocalDate startLD2 = LocalDate.of(2024, 12, 20);
+        LocalDate endLD2 = LocalDate.of(2024, 12, 20);
+
+        DateTime startJT1 = new DateTime(2024, 12, 15, 0, 0);
+        DateTime endJT1 = new DateTime(2024, 12, 20, 0, 0);
+
+        DateTime startJT2 = new DateTime(2024, 12, 20, 0, 0);
+        DateTime endJT2 = new DateTime(2024, 12, 20, 0, 0);
+
+        assertTrue(DateRangeOverlapChecker.isOverlapUsingCalendarAndDuration(start1, end1, start2, end2));
+        assertTrue(DateRangeOverlapChecker.isOverlapUsingLocalDateAndDuration(startLD1, endLD1, startLD2, endLD2));
+
+        assertTrue(DateRangeOverlapChecker.isOverlapUsingCalendarAndCondition(start1, end1, start2, end2));
+        assertTrue(DateRangeOverlapChecker.isOverlapUsingLocalDateAndCondition(startLD1, endLD1, startLD2, endLD2));
+
+        assertTrue(DateRangeOverlapChecker.isOverlapUsingCalendarAndFindMin(start1, end1, start2, end2));
+        assertTrue(DateRangeOverlapChecker.isOverlapUsingLocalDateAndFindMin(startLD1, endLD1, startLD2, endLD2));
+
+        //the overlaps method considers two intervals as overlapping only if they have a non-zero duration.
+        assertFalse(DateRangeOverlapChecker.isOverlapUsingJodaTime(startJT1, endJT1, startJT2, endJT2));
+    }
+}

core-java-modules/core-java-8-datetime-2/src/test/java/com/baeldung/zoneoffsetandzoneidof/ZoneOffSetAndZoneIdOfUnitTest.java

@@ -0,0 +1,25 @@
+package com.baeldung.zoneoffsetandzoneidof;
+
+import org.junit.jupiter.api.Test;
+
+import java.time.OffsetDateTime;
+import java.time.ZoneId;
+import java.time.ZoneOffset;
+import java.time.ZonedDateTime;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+public class ZoneOffSetAndZoneIdOfUnitTest {
+
+    @Test
+    public void givenOffsetDateTimeWithUTCZoneOffset_thenOffsetShouldBeUTC() {
+        OffsetDateTime dateTimeWithOffset = OffsetDateTime.now(ZoneOffset.UTC);
+        assertEquals(dateTimeWithOffset.getOffset(), ZoneOffset.UTC);
+    }
+
+    @Test
+    public void givenZonedDateTimeWithUTCZoneId_thenZoneShouldBeUTC() {
+        ZonedDateTime zonedDateTime = ZonedDateTime.now(ZoneId.of("UTC"));
+        assertEquals(zonedDateTime.getZone(), ZoneId.of("UTC"));
+    }
+}

core-java-modules/core-java-arrays-convert/README.md

@@ -12,3 +12,4 @@ This module contains articles about arrays conversion in Java
 - [Convert an ArrayList of String to a String Array in Java](https://www.baeldung.com/java-convert-string-arraylist-array)
 - [Convert Char Array to Int Array in Java](https://www.baeldung.com/java-convert-char-int-array)
 - [How to Convert Byte Array to Char Array](https://www.baeldung.com/java-convert-byte-array-char)
+- [Convert byte[] to Byte[] and Vice Versa in Java](https://www.baeldung.com/java-byte-array-wrapper-primitive-type-convert)

core-java-modules/core-java-arrays-convert/src/test/java/com/baeldung/array/conversions/ByteArrayToPrimitiveByteArrayUnitTest.java

@@ -0,0 +1,36 @@
+package com.baeldung.array.conversions;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import org.apache.commons.lang3.ArrayUtils;
+import org.junit.jupiter.api.Test;
+
+public class ByteArrayToPrimitiveByteArrayUnitTest {
+    private static final byte[] EXPECTED_ARRAY_VALUES = {65, 66, 67, 68};
+    private static final Byte[] BYTE_ARRAY = {65, 66, 67, 68};
+
+    @Test
+    public void givenByteArray_whenConvertingUsingByteValue_thenGiveExpectedResult() {
+        byte[] newByteArray = new byte[BYTE_ARRAY.length];
+        for (int i = 0; i < BYTE_ARRAY.length; i++) {
+            newByteArray[i] = BYTE_ARRAY[i].byteValue();
+        }
+        assertThat(newByteArray).containsExactly(EXPECTED_ARRAY_VALUES);
+    }
+
+    @Test
+    public void givenByteArray_whenConvertingUsingUnboxing_thenGiveExpectedResult() {
+        byte[] newByteArray = new byte[BYTE_ARRAY.length];
+        for (int i = 0; i < BYTE_ARRAY.length; i++) {
+            newByteArray[i] = BYTE_ARRAY[i];
+        }
+        assertThat(newByteArray).containsExactly(EXPECTED_ARRAY_VALUES);
+    }
+
+    @Test
+    public void givenByteArray_whenConvertingArrayUtils_thenGiveExpectedResult() {
+        byte[] newByteArray = ArrayUtils.toPrimitive(BYTE_ARRAY);
+
+        assertThat(newByteArray).containsExactly(EXPECTED_ARRAY_VALUES);
+    }
+}

core-java-modules/core-java-arrays-convert/src/test/java/com/baeldung/array/conversions/PrimitiveByteArrayToByteArrayUnitTest.java

@@ -0,0 +1,47 @@
+package com.baeldung.array.conversions;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import java.util.Arrays;
+
+import org.apache.commons.lang3.ArrayUtils;
+import org.junit.jupiter.api.Test;
+
+public class PrimitiveByteArrayToByteArrayUnitTest {
+    private static final byte[] PRIMITIVE_BYTE_ARRAY = {65, 66, 67, 68};
+    private static final Byte[] EXPECTED_ARRAY_VALUES = {65, 66, 67, 68};
+
+    @Test
+    public void givenPrimitiveByteArray_whenConvertingUsingByteValueOf_thenGiveExpectedResult() {
+        Byte[] newByteArray = new Byte[PRIMITIVE_BYTE_ARRAY.length];
+        for (int i = 0; i < PRIMITIVE_BYTE_ARRAY.length; i++) {
+            newByteArray[i] = Byte.valueOf(PRIMITIVE_BYTE_ARRAY[i]);
+        }
+        assertThat(newByteArray).containsExactly(EXPECTED_ARRAY_VALUES);
+    }
+
+    @Test
+    public void givenPrimitiveByteArray_whenConvertingUsingAutoboxing_thenGiveExpectedResult() {
+        Byte[] newByteArray = new Byte[PRIMITIVE_BYTE_ARRAY.length];
+        for (int i = 0; i < PRIMITIVE_BYTE_ARRAY.length; i++) {
+            newByteArray[i] = PRIMITIVE_BYTE_ARRAY[i];
+        }
+        assertThat(newByteArray).containsExactly(EXPECTED_ARRAY_VALUES);
+    }
+
+    @Test
+    public void givenPrimitiveByteArray_whenConvertingUsingAutoboxingAndArraysSetAll_thenGiveExpectedResult() {
+        Byte[] newByteArray = new Byte[PRIMITIVE_BYTE_ARRAY.length];
+        Arrays.setAll(newByteArray, n -> PRIMITIVE_BYTE_ARRAY[n]);
+
+        assertThat(newByteArray)
+            .containsExactly(EXPECTED_ARRAY_VALUES);
+    }
+
+    @Test
+    public void givenPrimitiveByteArray_whenConvertingUsingArrayUtils_thenGiveExpectedResult() {
+        Byte[] newByteArray = ArrayUtils.toObject(PRIMITIVE_BYTE_ARRAY);
+
+        assertThat(newByteArray).containsExactly(EXPECTED_ARRAY_VALUES);
+    }
+}

core-java-modules/core-java-arrays-guides/README.md

@@ -10,3 +10,4 @@ This module contains complete guides about arrays in Java
 - [Creating a Generic Array in Java](https://www.baeldung.com/java-generic-array)
 - [Maximum Size of Java Arrays](https://www.baeldung.com/java-arrays-max-size)
 - [Merge Two Arrays and Remove Duplicates in Java](https://www.baeldung.com/java-merge-two-arrays-delete-duplicates)
+- [Print a Java 2D Array](https://www.baeldung.com/java-2d-array-print)

core-java-modules/core-java-arrays-guides/pom.xml

@@ -7,10 +7,6 @@
     <name>core-java-arrays-guides</name>
     <packaging>jar</packaging>
 
-    <properties>
-        <system-stubs.jupiter.version>2.1.5</system-stubs.jupiter.version>
-    </properties>
-
     <parent>
         <artifactId>core-java-modules</artifactId>
         <groupId>com.baeldung.core-java-modules</groupId>
@@ -34,7 +30,10 @@
             <version>${system-stubs.jupiter.version}</version>
             <scope>test</scope>
         </dependency>
-
     </dependencies>
 
+    <properties>
+        <system-stubs.jupiter.version>2.1.5</system-stubs.jupiter.version>
+    </properties>
+
 </project>

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

@@ -6,3 +6,4 @@ This module contains articles about Java Character Class
 - [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)
+- [Creating Unicode Character From Its Code Point Hex String](https://www.baeldung.com/java-unicode-character-from-code-point-hex-string)

core-java-modules/core-java-char/src/test/java/com/baeldung/unicodechar/UnicodeCharFromCodePointHexStringUnitTest.java

@@ -0,0 +1,70 @@
+package com.baeldung.unicodechar;
+
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+public class UnicodeCharFromCodePointHexStringUnitTest {
+    private static final String U_CHECK = "✅"; // U+2705
+    private static final String U_STRONG = "强"; // U+5F3A
+
+
+    @Test
+    void whenEscapeUAndNumberInString_thenGetExpectedUnicodeStr() {
+        String check = "\u2705";
+        assertEquals(U_CHECK, check);
+
+        String strong = "\u5F3A";
+        assertEquals(U_STRONG, strong);
+
+        // "A" U+0041
+        assertEquals("A", "\u0041");
+    }
+
+
+    @Test
+    void whenConcatUAndNumberAsString_thenDoNotGetExpectedUnicodeStr() {
+        String check = "\\u" + "2705";
+        assertEquals("\\u2705", check);
+
+        String strong = "\\u" + "5F3A";
+        assertEquals("\\u5F3A", strong);
+    }
+
+
+    @Test
+    void whenCastHexCodePointToCharAndConvertCharToString_thenGetExpectedUnicodeStr() {
+
+        int codePoint = Integer.parseInt("2705", 16); //Decimal int: 9989
+        char[] checkChar = Character.toChars(codePoint);
+        String check = String.valueOf(checkChar);
+        assertEquals(U_CHECK, check);
+
+        // For Java 11 and later versions
+        // assertEquals(U_CHECK, Character.toString(codePoint));
+
+        codePoint = Integer.parseInt("5F3A", 16); //Decimal int: 24378
+        char[] strongChar = Character.toChars(codePoint);
+        String strong = String.valueOf(strongChar);
+        assertEquals(U_STRONG, strong);
+
+        // For Java 11 and later versions
+        // assertEquals(U_STRONG, Character.toString(codePoint));
+    }
+
+    String stringFromCodePointHex(String codePointHex) {
+        int codePoint = Integer.parseInt(codePointHex, 16);
+
+        // For Java 11 and later versions: return Character.toString(codePoint)
+
+        char[] chars = Character.toChars(codePoint);
+        return String.valueOf(chars);
+    }
+
+    @Test
+    void whenUsingstringFromCodePointHex_thenGetExpectedUnicodeStr() {
+        assertEquals("A", stringFromCodePointHex("0041"));
+        assertEquals(U_CHECK, stringFromCodePointHex("2705"));
+        assertEquals(U_STRONG, stringFromCodePointHex("5F3A"));
+    }
+}

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

@@ -11,4 +11,7 @@
 - [Intro to Vector Class in Java](https://www.baeldung.com/java-vector-guide)
 - [HashSet toArray() Method in Java](https://www.baeldung.com/java-hashset-toarray)
 - [Time Complexity of Java Collections Sort in Java](https://www.baeldung.com/java-time-complexity-collections-sort)
+- [Check if List Contains at Least One Enum](https://www.baeldung.com/java-list-check-enum-presence)
+- [Comparison of for Loops and Iterators](https://www.baeldung.com/java-for-loops-vs-iterators)
+- [PriorityQueue iterator() Method in Java](https://www.baeldung.com/java-priorityqueue-iterator)
 - More articles: [[<-- prev]](/core-java-modules/core-java-collections-4)

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

@@ -5,18 +5,6 @@
     <modelVersion>4.0.0</modelVersion>
     <artifactId>core-java-collections-5</artifactId>
     <name>core-java-collections-5</name>
-    <build>
-        <plugins>
-            <plugin>
-                <groupId>org.apache.maven.plugins</groupId>
-                <artifactId>maven-compiler-plugin</artifactId>
-                <configuration>
-                    <source>9</source>
-                    <target>9</target>
-                </configuration>
-            </plugin>
-        </plugins>
-    </build>
     <packaging>jar</packaging>
 
     <parent>
@@ -61,6 +49,19 @@
         </dependency>
     </dependencies>
 
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-compiler-plugin</artifactId>
+                <configuration>
+                    <source>9</source>
+                    <target>9</target>
+                </configuration>
+            </plugin>
+        </plugins>
+    </build>
+
     <properties>
         <junit.version>5.9.2</junit.version>
         <roaringbitmap.version>0.9.38</roaringbitmap.version>

core-java-modules/core-java-collections-list-5/pom.xml

@@ -55,7 +55,6 @@
             <version>${org.json.version}</version>
             <scope>test</scope>
         </dependency>
-
     </dependencies>
 
     <properties>

core-java-modules/core-java-collections-list-6/README.md

@@ -1,2 +1,6 @@
 ## Relevant Articles
 - [Check if a List Contains a String Element While Ignoring Case](https://www.baeldung.com/java-list-search-case-insensitive)
+- [Removing the Last Node in a Linked List](https://www.baeldung.com/java-linked-list-remove-last-element)
+- [Call a Method on Each Element of a List in Java](https://www.baeldung.com/java-call-method-each-list-item)
+- [Sorting One List Based on Another List in Java](https://www.baeldung.com/java-sorting-one-list-using-another)
+- [Reset ListIterator to First Element of the List in Java](https://www.baeldung.com/java-reset-listiterator)

core-java-modules/core-java-collections-list-6/src/test/java/com/baeldung/resetlistiterator/ResetListIteratorUnitTest.java

@@ -0,0 +1,46 @@
+package com.baeldung.resetlistiterator;
+
+import org.junit.jupiter.api.Test;
+
+import java.util.List;
+import java.util.ListIterator;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+
+public class ResetListIteratorUnitTest {
+
+    private static final List<String> MY_LIST = List.of("A", "B", "C", "D", "E", "F", "G");
+
+    @Test
+    void whenRecreateAnListIterator_thenGetTheExpectedResult() {
+        ListIterator<String> lit = MY_LIST.listIterator();
+        lit.next();
+        lit.next();
+        lit.next();
+        lit.next();
+
+        lit = MY_LIST.listIterator();
+
+        assertFalse(lit.hasPrevious());
+        assertEquals("A", lit.next());
+    }
+
+    @Test
+    void whenBackwardIterationToTheFirst_thenGetTheExpectedResult() {
+        ListIterator<String> lit = MY_LIST.listIterator();
+        lit.next();
+        lit.next();
+        lit.next();
+        lit.next();
+
+
+        while (lit.hasPrevious()) {
+            lit.previous();
+        }
+
+        assertFalse(lit.hasPrevious());
+        assertEquals("A", lit.next());
+    }
+
+}

core-java-modules/core-java-collections-maps-6/pom.xml

@@ -27,7 +27,7 @@
         <dependency>
             <groupId>com.google.code.gson</groupId>
             <artifactId>gson</artifactId>
-            <version>2.8.9</version>
+            <version>2.10.1</version>
         </dependency>
         <dependency>
             <groupId>org.json</groupId>

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

@@ -5,6 +5,6 @@
 - [How to Get First or Last Entry From a LinkedHashMap in Java](https://www.baeldung.com/java-linkedhashmap-first-last-key-value-pair)
 - [How to Write and Read a File with a Java HashMap](https://www.baeldung.com/java-hashmap-write-read-file)
 - [Limiting the Max Size of a HashMap in Java](https://www.baeldung.com/java-hashmap-size-bound)
-- [How to Sort LinkedHashMap By Values in Java](https://www.baeldung.com/java-sort-linkedhashmap-using-values)
+- [How to Sort LinkedHashMap by Values in Java](https://www.baeldung.com/java-sort-linkedhashmap-using-values)
 - [How to Increment a Map Value in Java](https://www.baeldung.com/java-increment-map-value)
 - More articles: [[<-- prev]](/core-java-modules/core-java-collections-maps-6)

core-java-modules/core-java-collections-set/pom.xml

@@ -41,7 +41,7 @@
     </build>
 
     <properties>
-        <gson.version>2.8.5</gson.version>
+        <gson.version>2.10.1</gson.version>
     </properties>
 
 </project>

core-java-modules/core-java-concurrency-advanced-5/src/main/java/com/baeldung/countdownlatchvssemaphore/CountDownLatchDemo.java

@@ -0,0 +1,33 @@
+package com.baeldung.countdownlatchvssemaphore;
+
+import java.util.concurrent.CountDownLatch;
+
+public class CountDownLatchDemo {
+
+    public static void main(String[] args) throws InterruptedException {
+        // Create a CountDownLatch with an initial count equal to the number of tasks to be completed
+        int numberOfTasks = 3;
+        CountDownLatch latch = new CountDownLatch(numberOfTasks);
+
+        // Simulate completion of tasks by worker threads
+        for (int i = 1; i <= numberOfTasks; i++) {
+            new Thread(() -> {
+                System.out.println("Task completed by Thread " + Thread.currentThread()
+                    .getId());
+
+                // Decrement the latch count to signal completion of a task
+                latch.countDown();
+            }).start();
+        }
+
+        // Main thread waits until all tasks are completed
+        latch.await();
+        System.out.println("All tasks completed. Main thread proceeds.");
+
+        // Attempting to reset will have no effect
+        latch.countDown();
+        // Latch is already at zero, await() returns immediately
+        latch.await(); // This line won't block
+        System.out.println("Latch is already at zero and cannot be reset.");
+    }
+}

core-java-modules/core-java-concurrency-advanced-5/src/main/java/com/baeldung/countdownlatchvssemaphore/SemaphoreDemo.java

@@ -0,0 +1,42 @@
+package com.baeldung.countdownlatchvssemaphore;
+
+import java.util.concurrent.Semaphore;
+
+public class SemaphoreDemo {
+
+    public static void main(String[] args) {
+        // Create a Semaphore with a fixed number of permits
+        int NUM_PERMITS = 3;
+        Semaphore semaphore = new Semaphore(NUM_PERMITS);
+
+        // Simulate resource access by worker threads
+        for (int i = 1; i <= 5; i++) {
+            new Thread(() -> {
+                try {
+                    // Acquire a permit to access the resource
+                    semaphore.acquire();
+                    System.out.println("Thread " + Thread.currentThread().getId() + " accessing resource.");
+
+                    // Simulate resource usage
+                    Thread.sleep(2000);
+                } catch (InterruptedException e) {
+                    e.printStackTrace();
+                } finally {
+                    // Release the permit after resource access is complete
+                    semaphore.release();
+                }
+            }).start();
+        }
+
+        // Simulate resetting the Semaphore by releasing additional permits after a delay
+        try {
+            Thread.sleep(5000);
+
+            // Resetting the semaphore permits to the initial count
+            semaphore.release(NUM_PERMITS);
+            System.out.println("Semaphore permits reset to initial count.");
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+}

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

@@ -12,4 +12,5 @@ This module contains articles about basic Java concurrency
 - [How to Get the Number of Threads in a Java Process](https://www.baeldung.com/java-get-number-of-threads)
 - [Set the Name of a Thread in Java](https://www.baeldung.com/java-set-thread-name)
 - [Thread vs. Single Thread Executor Service](https://www.baeldung.com/java-single-thread-executor-service)
+- [Difference Between a Future and a Promise in Java](https://www.baeldung.com/java-future-vs-promise-comparison)
 - [[<-- Prev]](../core-java-concurrency-basic)[[Next -->]](../core-java-concurrency-basic-3)

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

@@ -13,4 +13,5 @@ This module contains articles about basic Java concurrency.
 - [Retry Logic with CompletableFuture](https://www.baeldung.com/java-completablefuture-retry-logic)
 - [Convert From List of CompletableFuture to CompletableFuture List](https://www.baeldung.com/java-completablefuture-list-convert)
 - [Synchronize a Static Variable Among Different Threads](https://www.baeldung.com/java-synchronize-static-variable-different-threads)
+- [Difference Between execute() and submit() in Executor Service](https://www.baeldung.com/java-execute-vs-submit-executor-service)
 - [[<-- Prev]](../core-java-concurrency-basic-2)

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

@@ -8,3 +8,4 @@
 - [System.console() vs. System.out](https://www.baeldung.com/java-system-console-vs-system-out)
 - [How to Log to the Console in Color](https://www.baeldung.com/java-log-console-in-color)
 - [Create Table Using ASCII in a Console in Java](https://www.baeldung.com/java-console-ascii-make-table)
+- [Printing Message on Console without Using main() Method in Java](https://www.baeldung.com/java-no-main-print-message-console)

core-java-modules/core-java-date-operations-4/README.md

@@ -0,0 +1,6 @@
+## Core Date Operations (Part 4)
+This module contains articles about date operations in Java.
+
+### Relevant Articles:
+- [Calculate Number of Weekdays Between Two Dates in Java](https://www.baeldung.com/java-count-weekdays-between-two-dates)
+- [Convert Long to Date in Java](https://www.baeldung.com/java-long-date-conversion)

core-java-modules/core-java-date-operations-4/pom.xml

@@ -0,0 +1,46 @@
+<?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-date-operations-4</artifactId>
+    <name>core-java-date-operations-4</name>
+
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-compiler-plugin</artifactId>
+                <configuration>
+                    <source>11</source>
+                    <target>11</target>
+                </configuration>
+            </plugin>
+        </plugins>
+    </build>
+    <packaging>jar</packaging>
+
+    <parent>
+        <groupId>com.baeldung.core-java-modules</groupId>
+        <artifactId>core-java-modules</artifactId>
+        <version>0.0.1-SNAPSHOT</version>
+    </parent>
+
+    <dependencies>
+        <dependency>
+            <groupId>joda-time</groupId>
+            <artifactId>joda-time</artifactId>
+            <version>${joda-time.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.apache.commons</groupId>
+            <artifactId>commons-lang3</artifactId>
+            <version>${commons-lang3.version}</version>
+        </dependency>
+    </dependencies>
+
+    <properties>
+        <joda-time.version>2.12.6</joda-time.version>
+    </properties>
+
+</project>

core-java-modules/core-java-date-operations-4/src/main/java/com/baeldung/calculateweekdays/CalculateWeekdays.java

@@ -0,0 +1,46 @@
+package com.baeldung.calculateweekdays;
+
+import java.time.DayOfWeek;
+import java.time.LocalDate;
+import java.time.temporal.ChronoUnit;
+import java.time.temporal.TemporalAdjusters;
+import java.util.Arrays;
+
+public class CalculateWeekdays {
+
+    public long getWorkingDaysWithStream(LocalDate start, LocalDate end){
+        return start.datesUntil(end)
+          .map(LocalDate::getDayOfWeek)
+          .filter(day -> !Arrays.asList(DayOfWeek.SATURDAY, DayOfWeek.SUNDAY).contains(day))
+          .count();
+    }
+
+    public long getWorkingDaysWithoutStream(LocalDate start, LocalDate end) {
+        boolean startOnWeekend = false;
+
+        // If starting at the weekend, move to following Monday
+        if(start.getDayOfWeek().getValue() > 5){
+            start = start.with(TemporalAdjusters.next(DayOfWeek.MONDAY));
+            startOnWeekend = true;
+        }
+        boolean endOnWeekend = false;
+        // If ending at the weekend, move to previous Friday
+        if(end.getDayOfWeek().getValue() > 5){
+            end = end.with(TemporalAdjusters.previous(DayOfWeek.FRIDAY));
+            endOnWeekend = true;
+        }
+        // Cover case where starting on Saturday and ending following Sunday
+        if(start.isAfter(end)){
+            return 0;
+        }
+        // Get total weeks
+        long weeks = ChronoUnit.WEEKS.between(start, end);
+
+        long addValue = startOnWeekend || endOnWeekend ? 1 : 0;
+
+        // Add on days that did not make up a full week
+        return ( weeks * 5 ) + ( end.getDayOfWeek().getValue() - start.getDayOfWeek().getValue() ) + addValue;
+    }
+
+
+}

core-java-modules/core-java-date-operations-4/src/test/java/com/baeldung/calculateweekdays/CalculateWeekdaysUnitTest.java

@@ -0,0 +1,83 @@
+package com.baeldung.calculateweekdays;
+
+import static junit.framework.TestCase.assertEquals;
+
+import java.time.LocalDate;
+
+import org.junit.jupiter.api.Test;
+
+public class CalculateWeekdaysUnitTest {
+
+    // Start Saturday end following Sunday (answer is 0)
+    LocalDate startTomorrow = LocalDate.of(2023, 12, 2);
+    LocalDate endTomorrow = LocalDate.of(2023, 12, 3);
+
+    // Three week gap with midweek start and finish (answer is 17)
+    LocalDate startThreeWeeks = LocalDate.of(2023, 11, 28);
+    LocalDate endThreeWeeks = LocalDate.of(2023, 12, 21);
+
+    // Three week gap with midweek start and weekend finish (answer is 17)
+    LocalDate startThreeWeeks2 = LocalDate.of(2023, 11, 6);
+    LocalDate endThreeWeeks2 = LocalDate.of(2023, 12, 30);
+
+    // Week gap start and end on weekend (answer is 40)
+    LocalDate startThreeWeeksWeekend = LocalDate.of(2023, 12, 2);
+    LocalDate endThreeWeeksWeekend = LocalDate.of(2023, 12, 9);
+
+    @Test
+    void givenTwoDaysOnSameWeekend_whenUsingStreams_thenCalculateWeekdays(){
+        CalculateWeekdays c = new CalculateWeekdays();
+        long result = c.getWorkingDaysWithStream(startTomorrow, endTomorrow);
+        assertEquals(0, result);
+    }
+
+    @Test
+    void givenTwoDaysOnSameWeekend_whenUsingMaths_thenCalculateWeekdays(){
+        CalculateWeekdays c = new CalculateWeekdays();
+        long result = c.getWorkingDaysWithoutStream(startTomorrow, endTomorrow);
+        assertEquals(0, result);
+    }
+
+    @Test
+    void givenAThreeWeekGapMidweekDates_whenUsingStreams_thenCalculateWeekdays(){
+        CalculateWeekdays c = new CalculateWeekdays();
+        long result = c.getWorkingDaysWithStream(startThreeWeeks, endThreeWeeks);
+        assertEquals(17, result);
+    }
+
+    @Test
+    void givenAThreeWeekGapMidweekDates_whenUsingMaths_thenCalculateWeekdays(){
+        CalculateWeekdays c = new CalculateWeekdays();
+        long result = c.getWorkingDaysWithoutStream(startThreeWeeks, endThreeWeeks);
+        assertEquals(17, result);
+    }
+
+    @Test
+    void givenThreeWeekGapMidweekAndWeekendDates_whenUsingStreams_thenCalculateWeekdays(){
+        CalculateWeekdays c = new CalculateWeekdays();
+        long result = c.getWorkingDaysWithStream(startThreeWeeksWeekend, endThreeWeeksWeekend);
+        assertEquals(5, result);
+    }
+
+    @Test
+    void givenThreeWeekGapMidweekAndWeekendDates_whenUsingMaths_thenCalculateWeekdays(){
+        CalculateWeekdays c = new CalculateWeekdays();
+        long result = c.getWorkingDaysWithoutStream(startThreeWeeksWeekend, endThreeWeeksWeekend);
+        assertEquals(5, result);
+    }
+
+    @Test
+    void givenThreeWeekGapWeekendDates_whenUsingStreams_thenCalculateWeekdays(){
+        CalculateWeekdays c = new CalculateWeekdays();
+        long result = c.getWorkingDaysWithStream(startThreeWeeks2, endThreeWeeks2);
+        assertEquals(40, result);
+    }
+
+    @Test
+    void givenThreeWeekGapWeekendDates_whenUsingMaths_thenCalculateWeekdays(){
+        CalculateWeekdays c = new CalculateWeekdays();
+        long result = c.getWorkingDaysWithoutStream(startThreeWeeks2, endThreeWeeks2);
+        assertEquals(40, result);
+    }
+
+}

core-java-modules/core-java-date-operations-4/src/test/java/com/baeldung/longtodate/LongToDateUnitTest.java

@@ -0,0 +1,74 @@
+package com.baeldung.longtodate;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import java.text.ParseException;
+import java.text.SimpleDateFormat;
+import java.time.LocalDate;
+import java.util.Calendar;
+import java.util.Date;
+import java.util.TimeZone;
+
+import org.joda.time.DateTimeZone;
+import org.joda.time.Instant;
+import org.junit.jupiter.api.Test;
+
+class LongToDateUnitTest {
+
+    @Test
+    void givenLongValue_whenUsingInstantClass_thenConvert() {
+        Instant expectedDate = Instant.parse("2020-09-08T12:16:40Z");
+        long seconds = 1599567400L;
+
+        Instant date = Instant.ofEpochSecond(seconds);
+
+        assertEquals(expectedDate, date);
+    }
+
+    @Test
+    void givenLongValue_whenUsingLocalDateClass_thenConvert() {
+        LocalDate expectedDate = LocalDate.of(2023, 10, 17);
+        long epochDay = 19647L;
+
+        LocalDate date = LocalDate.ofEpochDay(epochDay);
+
+        assertEquals(expectedDate, date);
+    }
+
+    @Test
+    void givenLongValue_whenUsingDateClass_thenConvert() throws ParseException {
+        SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
+        dateFormat.setTimeZone(TimeZone.getTimeZone("UTC"));
+        Date expectedDate = dateFormat.parse("2023-07-15 22:00:00");
+        long milliseconds = 1689458400000L;
+
+        Date date = new Date(milliseconds);
+
+        assertEquals(expectedDate, date);
+    }
+
+    @Test
+    void givenLongValue_whenUsingCalendarClass_thenConvert() throws ParseException {
+        SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
+        dateFormat.setTimeZone(TimeZone.getTimeZone("UTC"));
+        Date expectedDate = dateFormat.parse("2023-07-15 22:00:00");
+        long milliseconds = 1689458400000L;
+
+        Calendar calendar = Calendar.getInstance();
+        calendar.setTimeZone(TimeZone.getTimeZone("UTC"));
+        calendar.setTimeInMillis(milliseconds);
+
+        assertEquals(expectedDate, calendar.getTime());
+    }
+
+    @Test
+    void givenLongValue_whenUsingJodaTimeLocalDateClass_thenConvert() {
+        org.joda.time.LocalDate expectedDate = new org.joda.time.LocalDate(2023, 7, 15);
+        long milliseconds = 1689458400000L;
+
+        org.joda.time.LocalDate date = new org.joda.time.LocalDate(milliseconds, DateTimeZone.UTC);
+
+        assertEquals(expectedDate, date);
+    }
+
+}

core-java-modules/core-java-datetime-conversion-2/README.md

@@ -0,0 +1,6 @@
+## Java Date/time conversion Cookbooks and Examples
+
+This module contains articles about converting between Java date and time objects.
+
+### Relevant Articles: 
+- [Convert Gregorian to Hijri Date in Java](https://www.baeldung.com/java-date-gregorian-hijri-conversion)

core-java-modules/core-java-datetime-conversion-2/pom.xml

@@ -0,0 +1,57 @@
+<?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-datetime-conversion-2</artifactId>
+    <version>${project.parent.version}</version>
+    <name>core-java-datetime-conversion-2</name>
+    <packaging>jar</packaging>
+
+    <parent>
+        <groupId>com.baeldung.core-java-modules</groupId>
+        <artifactId>core-java-modules</artifactId>
+        <version>0.0.1-SNAPSHOT</version>
+    </parent>
+
+    <dependencies>
+        <dependency>
+            <groupId>joda-time</groupId>
+            <artifactId>joda-time</artifactId>
+            <version>${joda-time.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.apache.commons</groupId>
+            <artifactId>commons-lang3</artifactId>
+            <version>${commons-lang3.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>com.github.msarhan</groupId>
+            <artifactId>ummalqura-calendar</artifactId>
+            <version>${ummalqura-calendar.version}</version>
+        </dependency>
+
+    </dependencies>
+
+    <build>
+        <finalName>core-java-datetime-conversion-2</finalName>
+        <resources>
+            <resource>
+                <directory>src/main/resources</directory>
+                <filtering>true</filtering>
+            </resource>
+        </resources>
+        <plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-compiler-plugin</artifactId>
+            </plugin>
+        </plugins>
+    </build>
+
+    <properties>
+        <joda-time.version>2.12.5</joda-time.version>
+        <ummalqura-calendar.version>2.0.2</ummalqura-calendar.version>
+    </properties>
+
+</project>

core-java-modules/core-java-datetime-conversion-2/src/main/java/com/baeldung/gregoriantohijri/GregorianToHijriDateConverter.java

@@ -0,0 +1,34 @@
+package com.baeldung.gregoriantohijri;
+
+import java.text.ParseException;
+import java.time.LocalDate;
+import java.time.chrono.ChronoLocalDate;
+import java.time.chrono.HijrahChronology;
+import java.time.chrono.HijrahDate;
+import java.util.GregorianCalendar;
+
+import org.joda.time.chrono.IslamicChronology;
+
+import com.github.msarhan.ummalqura.calendar.UmmalquraCalendar;
+
+public class GregorianToHijriDateConverter {
+    public static HijrahDate usingHijrahChronology(LocalDate gregorianDate) {
+        HijrahChronology hijrahChronology = HijrahChronology.INSTANCE;
+        ChronoLocalDate hijriChronoLocalDate = hijrahChronology.date(gregorianDate);
+        return HijrahDate.from(hijriChronoLocalDate);
+    }
+
+    public static HijrahDate usingFromMethod(LocalDate gregorianDate) {
+        return HijrahDate.from(gregorianDate);
+    }
+
+    public static org.joda.time.DateTime usingJodaDate(org.joda.time.DateTime gregorianDate) {
+        return gregorianDate.withChronology(IslamicChronology.getInstance());
+    }
+
+    public static UmmalquraCalendar usingUmmalquraCalendar(GregorianCalendar gregorianCalendar) throws ParseException {
+        UmmalquraCalendar hijriCalendar = new UmmalquraCalendar();
+        hijriCalendar.setTime(gregorianCalendar.getTime());
+        return hijriCalendar;
+    }
+}

core-java-modules/core-java-datetime-conversion-2/src/main/java/com/baeldung/stringdatetoxmlgregoriancalendar/StringDateToXMLGregorianCalendarConverter.java

@@ -0,0 +1,42 @@
+package com.baeldung.stringdatetoxmlgregoriancalendar;
+
+import java.text.ParseException;
+import java.text.SimpleDateFormat;
+import java.time.LocalDate;
+import java.util.Date;
+import java.util.GregorianCalendar;
+
+import javax.xml.datatype.DatatypeConfigurationException;
+import javax.xml.datatype.DatatypeFactory;
+import javax.xml.datatype.XMLGregorianCalendar;
+
+import org.joda.time.DateTime;
+import org.joda.time.format.DateTimeFormat;
+
+public class StringDateToXMLGregorianCalendarConverter {
+    public static XMLGregorianCalendar usingDatatypeFactoryForDate(String dateAsString) throws DatatypeConfigurationException {
+        return DatatypeFactory.newInstance().newXMLGregorianCalendar(dateAsString);
+    }
+
+    public static XMLGregorianCalendar usingLocalDate(String dateAsString) throws DatatypeConfigurationException {
+        LocalDate localDate = LocalDate.parse(dateAsString);
+        return DatatypeFactory.newInstance().newXMLGregorianCalendar(localDate.toString());
+    }
+
+    public static XMLGregorianCalendar usingSimpleDateFormat(String dateTimeAsString) throws DatatypeConfigurationException, ParseException {
+        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss");
+        Date date = simpleDateFormat.parse(dateTimeAsString);
+        return DatatypeFactory.newInstance().newXMLGregorianCalendar(simpleDateFormat.format(date));
+    }
+
+    public static XMLGregorianCalendar usingGregorianCalendar(String dateTimeAsString) throws DatatypeConfigurationException, ParseException {
+        GregorianCalendar calendar = new GregorianCalendar();
+        calendar.setTime(new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss").parse(dateTimeAsString));
+        return DatatypeFactory.newInstance().newXMLGregorianCalendar(calendar);
+    }
+
+    public static XMLGregorianCalendar usingJodaTime(String dateTimeAsString) throws DatatypeConfigurationException {
+        DateTime dateTime = DateTime.parse(dateTimeAsString, DateTimeFormat.forPattern("yyyy-MM-dd'T'HH:mm:ss"));
+        return DatatypeFactory.newInstance().newXMLGregorianCalendar(dateTime.toGregorianCalendar());
+    }
+}

core-java-modules/core-java-datetime-conversion-2/src/test/java/com/baeldung/gregoriantohijri/GregorianToHijriDateConverterUnitTest.java

@@ -0,0 +1,53 @@
+package com.baeldung.gregoriantohijri;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import java.text.ParseException;
+import java.time.LocalDate;
+import java.time.chrono.HijrahDate;
+import java.time.temporal.ChronoField;
+import java.util.Calendar;
+import java.util.GregorianCalendar;
+
+import org.joda.time.DateTime;
+import org.junit.jupiter.api.Test;
+
+import com.github.msarhan.ummalqura.calendar.UmmalquraCalendar;
+
+public class GregorianToHijriDateConverterUnitTest {
+        @Test
+        void givenGregorianDate_whenUsingHijrahChronologyClass_thenConvertHijriDate() {
+            LocalDate gregorianDate = LocalDate.of(2013, 3, 31);
+            HijrahDate hijriDate = GregorianToHijriDateConverter.usingHijrahChronology(gregorianDate);
+            assertEquals(1434, hijriDate.get(ChronoField.YEAR));
+            assertEquals(5, hijriDate.get(ChronoField.MONTH_OF_YEAR));
+            assertEquals(19, hijriDate.get(ChronoField.DAY_OF_MONTH));
+        }
+
+    @Test
+    void givenGregorianDate_whenUsingFromMethod_thenConvertHijriDate() {
+        LocalDate gregorianDate = LocalDate.of(2013, 3, 31);
+        HijrahDate hijriDate = GregorianToHijriDateConverter.usingFromMethod(gregorianDate);
+        assertEquals(1434, hijriDate.get(ChronoField.YEAR));
+        assertEquals(5, hijriDate.get(ChronoField.MONTH_OF_YEAR));
+        assertEquals(19, hijriDate.get(ChronoField.DAY_OF_MONTH));
+    }
+
+    @Test
+    void givenGregorianDate_whenUsingJodaDate_thenConvertHijriDate() {
+        DateTime gregorianDate = new DateTime(2013, 3, 31, 0, 0, 0);
+        DateTime hijriDate = GregorianToHijriDateConverter.usingJodaDate(gregorianDate);
+        assertEquals(1434, hijriDate.getYear());
+        assertEquals(5, hijriDate.getMonthOfYear());
+        assertEquals(19, hijriDate.getDayOfMonth());
+    }
+
+    @Test
+    void givenGregorianDate_whenUsingUmmalquraCalendar_thenConvertHijriDate() throws ParseException {
+        GregorianCalendar gregorianCalendar = new GregorianCalendar(2013, Calendar.MARCH, 31);
+        UmmalquraCalendar ummalquraCalendar = GregorianToHijriDateConverter.usingUmmalquraCalendar(gregorianCalendar);
+        assertEquals(1434, ummalquraCalendar.get(Calendar.YEAR));
+        assertEquals(5, ummalquraCalendar.get(Calendar.MONTH) + 1);
+        assertEquals(19, ummalquraCalendar.get(Calendar.DAY_OF_MONTH));
+    }
+}

core-java-modules/core-java-datetime-conversion-2/src/test/java/com/baeldung/stringdatetoxmlgregoriancalendar/StringDateToXMLGregorianCalendarConverterUnitTest.java

@@ -0,0 +1,63 @@
+package com.baeldung.stringdatetoxmlgregoriancalendar;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import java.text.ParseException;
+import javax.xml.datatype.DatatypeConfigurationException;
+import javax.xml.datatype.XMLGregorianCalendar;
+
+import org.junit.jupiter.api.Test;
+
+public class StringDateToXMLGregorianCalendarConverterUnitTest {
+    private static final String dateAsString = "2014-04-24";
+    private static final String dateTimeAsString = "2014-04-24T15:45:30";
+
+    @Test
+    void givenStringDate_whenUsingDatatypeFactory_thenConvertToXMLGregorianCalendar() throws DatatypeConfigurationException {
+        XMLGregorianCalendar xmlGregorianCalendar = StringDateToXMLGregorianCalendarConverter.usingDatatypeFactoryForDate(dateAsString);
+        assertEquals(24,xmlGregorianCalendar.getDay());
+        assertEquals(4,xmlGregorianCalendar.getMonth());
+        assertEquals(2014,xmlGregorianCalendar.getYear());
+    }
+
+    @Test
+    void givenStringDateTime_whenUsingApacheCommonsLang3_thenConvertToXMLGregorianCalendar() throws DatatypeConfigurationException {
+        XMLGregorianCalendar xmlGregorianCalendar = StringDateToXMLGregorianCalendarConverter.usingLocalDate(dateAsString);
+        assertEquals(24,xmlGregorianCalendar.getDay());
+        assertEquals(4,xmlGregorianCalendar.getMonth());
+        assertEquals(2014,xmlGregorianCalendar.getYear());
+    }
+
+    @Test
+    void givenStringDateTime_whenUsingSimpleDateFormat_thenConvertToXMLGregorianCalendar() throws DatatypeConfigurationException, ParseException {
+        XMLGregorianCalendar xmlGregorianCalendar = StringDateToXMLGregorianCalendarConverter.usingSimpleDateFormat(dateTimeAsString);
+        assertEquals(24,xmlGregorianCalendar.getDay());
+        assertEquals(4,xmlGregorianCalendar.getMonth());
+        assertEquals(2014,xmlGregorianCalendar.getYear());
+        assertEquals(15,xmlGregorianCalendar.getHour());
+        assertEquals(45,xmlGregorianCalendar.getMinute());
+        assertEquals(30,xmlGregorianCalendar.getSecond());
+    }
+
+    @Test
+    void givenStringDateTime_whenUsingGregorianCalendar_thenConvertToXMLGregorianCalendar() throws DatatypeConfigurationException, ParseException {
+        XMLGregorianCalendar xmlGregorianCalendar = StringDateToXMLGregorianCalendarConverter.usingGregorianCalendar(dateTimeAsString);
+        assertEquals(24,xmlGregorianCalendar.getDay());
+        assertEquals(4,xmlGregorianCalendar.getMonth());
+        assertEquals(2014,xmlGregorianCalendar.getYear());
+        assertEquals(15,xmlGregorianCalendar.getHour());
+        assertEquals(45,xmlGregorianCalendar.getMinute());
+        assertEquals(30,xmlGregorianCalendar.getSecond());
+    }
+
+    @Test
+     void givenStringDateTime_whenUsingJodaTime_thenConvertToXMLGregorianCalendar() throws DatatypeConfigurationException {
+        XMLGregorianCalendar xmlGregorianCalendar = StringDateToXMLGregorianCalendarConverter.usingJodaTime(dateTimeAsString);
+        assertEquals(24,xmlGregorianCalendar.getDay());
+        assertEquals(4,xmlGregorianCalendar.getMonth());
+        assertEquals(2014,xmlGregorianCalendar.getYear());
+        assertEquals(15,xmlGregorianCalendar.getHour());
+        assertEquals(45,xmlGregorianCalendar.getMinute());
+        assertEquals(30,xmlGregorianCalendar.getSecond());
+    }
+}

core-java-modules/core-java-datetime-conversion/README.md

@@ -12,3 +12,4 @@ This module contains articles about converting between Java date and time object
 - [Convert Epoch Time to LocalDate and LocalDateTime](https://www.baeldung.com/java-convert-epoch-localdate)
 - [Convert Timestamp String to Long in Java](https://www.baeldung.com/java-convert-timestamp-string-long)
 - [Convert Long Timestamp to LocalDateTime in Java](https://www.baeldung.com/java-convert-long-timestamp-localdatetime)
+- [Convert Joda-Time DateTime to Date and Vice Versa](https://www.baeldung.com/java-convert-joda-time-datetime-to-date)

core-java-modules/core-java-datetime-string-2/README.md

@@ -5,3 +5,4 @@ This module contains articles about parsing and formatting Java date and time ob
 ### Relevant Articles: 
 - [Convert String to Instant](https://www.baeldung.com/java-string-to-instant)
 - [Sort Date Strings in Java](https://www.baeldung.com/java-sort-date-strings)
+- [Using Current Time as Filename in Java](https://www.baeldung.com/java-current-time-filename)

core-java-modules/core-java-datetime-string-2/pom.xml

@@ -13,6 +13,14 @@
         <version>0.0.1-SNAPSHOT</version>
     </parent>
 
+    <dependencies>
+        <dependency>
+            <groupId>joda-time</groupId>
+            <artifactId>joda-time</artifactId>
+            <version>${joda-time.version}</version>
+        </dependency>
+    </dependencies>
+
     <build>
         <plugins>
             <plugin>
@@ -22,4 +30,8 @@
         </plugins>
     </build>
 
+    <properties>
+        <joda-time.version>2.12.5</joda-time.version>
+    </properties>
+
 </project>

core-java-modules/core-java-datetime-string-2/src/test/java/com/baeldung/timestamp/CurrentTimeAsFileNameUnitTest.java

@@ -0,0 +1,114 @@
+package com.baeldung.timestamp;
+
+import static org.junit.Assert.assertTrue;
+
+import java.text.MessageFormat;
+import java.text.SimpleDateFormat;
+import java.time.Instant;
+import java.time.LocalDateTime;
+import java.time.OffsetDateTime;
+import java.time.ZoneId;
+import java.time.ZoneOffset;
+import java.time.ZonedDateTime;
+import java.time.format.DateTimeFormatter;
+import java.time.temporal.ChronoUnit;
+import java.util.Calendar;
+import java.util.Date;
+import java.util.regex.Pattern;
+
+import org.joda.time.DateTime;
+import org.joda.time.format.DateTimeFormat;
+import org.junit.Test;
+
+public class CurrentTimeAsFileNameUnitTest {
+
+    static final String TIMESTAMP_FORMAT = "yyyyMMddHHmmss";
+    static final DateTimeFormatter DATETIME_FORMATTER = DateTimeFormatter.ofPattern(TIMESTAMP_FORMAT);
+    static final SimpleDateFormat SIMPLEDATE_FORMAT = new SimpleDateFormat(TIMESTAMP_FORMAT);
+
+    @Test
+    public void whenUsingCalendar_thenCurrentTimeAsFileName() {
+        String currentTime = SIMPLEDATE_FORMAT.format(Calendar.getInstance().getTime());
+        String fileName = getFileName(currentTime);
+
+        assertTrue(verifyFileName(fileName));
+    }
+
+    @Test
+    public void whenUsingDate_thenCurrentTimeAsFileName() {
+        String currentTime = SIMPLEDATE_FORMAT.format(new Date());
+        String fileName = getFileName(currentTime);
+
+        assertTrue(verifyFileName(fileName));
+    }
+
+    @Test
+    public void whenUsingInstant_thenCurrentTimeAsFileName() {
+        String currentTime = Instant
+            .now()
+            .truncatedTo(ChronoUnit.SECONDS)
+            .toString()
+            .replaceAll("[:TZ-]", "");
+        String fileName = getFileName(currentTime);
+
+        assertTrue(verifyFileName(fileName));
+    }
+
+    @Test
+    public void whenUsingLocalDateTime_thenCurrentTimeAsFileName() {
+        String currentTime = LocalDateTime.now().format(DATETIME_FORMATTER);
+        String fileName = getFileName(currentTime);
+
+        assertTrue(verifyFileName(fileName));
+    }
+
+    @Test
+    public void whenUsingZonedDateTime_thenCurrentTimeAsFileName() {
+        String currentTime = ZonedDateTime
+            .now(ZoneId.of("Europe/Paris"))
+            .format(DATETIME_FORMATTER);
+        String fileName = getFileName(currentTime);
+
+        assertTrue(verifyFileName(fileName));
+    }
+
+    @Test
+    public void whenUsingOffsetDateTime_thenCurrentTimeAsFileName() {
+        String currentTime = OffsetDateTime
+            .of(LocalDateTime.now(), ZoneOffset.of("+01:00"))
+            .format(DATETIME_FORMATTER);
+        String fileName = getFileName(currentTime);
+
+        assertTrue(verifyFileName(fileName));
+    }
+
+    @Test
+    public void whenUsingJodaDateTime_thenCurrentTimeAsFileName() {
+        String currentTime = DateTime.now().toString(TIMESTAMP_FORMAT);
+        String fileName = getFileName(currentTime);
+
+        assertTrue(verifyFileName(fileName));
+    }
+
+    @Test
+    public void whenUsingJodaInstant_thenCurrentTimeAsFileName() {
+        String currentTime = DateTimeFormat
+            .forPattern(TIMESTAMP_FORMAT)
+            .print(org.joda.time.Instant.now()
+                .toDateTime());
+        String fileName = getFileName(currentTime);
+
+        assertTrue(verifyFileName(fileName));
+    }
+
+    String getFileName(String currentTime) {
+        return MessageFormat.format("{0}.txt", currentTime);
+    }
+
+    boolean verifyFileName(String fileName) {
+        return Pattern
+            .compile("[0-9]{14}+\\.txt", Pattern.CASE_INSENSITIVE)
+            .matcher(fileName)
+            .matches();
+    }
+}

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

@@ -6,3 +6,4 @@
 - [Java 8 Predicate Chain](https://www.baeldung.com/java-predicate-chain)
 - [Use Cases for Static Methods in Java](https://www.baeldung.com/java-static-methods-use-cases)
 - [TriFunction Interface in Java](https://www.baeldung.com/java-trifunction)
+- [Lazy Field Initialization with Lambdas](https://www.baeldung.com/java-lambda-lazy-field-initialization)

core-java-modules/core-java-io-4/README.md

@@ -9,7 +9,7 @@ This module contains articles about core Java input and output (IO)
 - [SequenceInputStream Class in Java](https://www.baeldung.com/java-sequenceinputstream)
 - [Read a File Into a Map in Java](https://www.baeldung.com/java-read-file-into-map)
 - [Read User Input Until a Condition Is Met](https://www.baeldung.com/java-read-input-until-condition)
-- [Java Scanner.skip method with examples](https://www.baeldung.com/java-scanner-skip)
+- [Java Scanner.skip Method with Examples](https://www.baeldung.com/java-scanner-skip)
 - [Generate the MD5 Checksum for a File in Java](https://www.baeldung.com/java-md5-checksum-file)
 - [Getting the Filename From a String Containing an Absolute File Path](https://www.baeldung.com/java-filename-full-path)
 - [Mocking Java InputStream Object](https://www.baeldung.com/java-mocking-inputstream)

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

@@ -6,5 +6,7 @@ This module contains articles about core Java input and output (IO)
 - [Get File Extension From MIME Type in Java](https://www.baeldung.com/java-mime-type-file-extension)
 - [How to Remove Line Breaks From a File in Java](https://www.baeldung.com/java-file-remove-line-breaks)
 - [Difference Between ZipFile and ZipInputStream in Java](https://www.baeldung.com/java-zipfile-vs-zipinputstream)
+- [How to Write Strings to OutputStream in Java](https://www.baeldung.com/java-write-string-outputstream)
+- [Read a File and Split It Into Multiple Files in Java](https://www.baeldung.com/java-read-file-split-into-several)
 - [[<-- Prev]](/core-java-modules/core-java-io-4)
 

core-java-modules/core-java-io-5/file.txt

@@ -0,0 +1 @@
+Hello, world!

core-java-modules/core-java-io-5/src/main/java/com/baeldung/readwritethread/ReadWriteBlockingQueue.java

@@ -0,0 +1,85 @@
+package com.baeldung.readwritethread;
+
+import java.io.BufferedReader;
+import java.io.BufferedWriter;
+import java.io.FileReader;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.util.concurrent.BlockingQueue;
+import java.util.concurrent.LinkedBlockingQueue;
+
+public class ReadWriteBlockingQueue {
+
+    public static void main(String[] args) throws InterruptedException {
+
+        BlockingQueue<String> queue = new LinkedBlockingQueue<>();
+        String readFileName = "src/main/resources/read_file.txt";
+        String writeFileName = "src/main/resources/write_file.txt";
+
+        Thread producerThread = new Thread(new FileProducer(queue, readFileName));
+        Thread consumerThread1 = new Thread(new FileConsumer(queue, writeFileName));
+
+        producerThread.start();
+        Thread.sleep(100); // Give producer a head start
+        consumerThread1.start();
+        try {
+            producerThread.join();
+            consumerThread1.join();
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+
+    }
+}
+
+class FileProducer implements Runnable {
+
+    private final BlockingQueue<String> queue;
+    private final String inputFileName;
+
+    public FileProducer(BlockingQueue<String> queue, String inputFileName) {
+        this.queue = queue;
+        this.inputFileName = inputFileName;
+    }
+
+    @Override
+    public void run() {
+        try (BufferedReader reader = new BufferedReader(new FileReader(inputFileName))) {
+            String line;
+            while ((line = reader.readLine()) != null) {
+                queue.offer(line);
+                System.out.println("Producer added line: " + line);
+                System.out.println("Queue size: " + queue.size());
+            }
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+    }
+}
+
+class FileConsumer implements Runnable {
+
+    private final BlockingQueue<String> queue;
+    private final String outputFileName;
+
+    public FileConsumer(BlockingQueue queue, String outputFileName) {
+        this.queue = queue;
+        this.outputFileName = outputFileName;
+    }
+
+    @Override
+    public void run() {
+        try (BufferedWriter writer = new BufferedWriter(new FileWriter(outputFileName))) {
+            String line;
+            while ((line = queue.poll()) != null) {
+                writer.write(line);
+                writer.newLine();
+                System.out.println(Thread.currentThread()
+                    .getId() + " - Consumer processed line: " + line);
+                System.out.println("Queue size: " + queue.size());
+            }
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+    }
+}

core-java-modules/core-java-io-5/src/main/java/com/baeldung/readwritethread/ReadWriteThread.java

@@ -0,0 +1,55 @@
+package com.baeldung.readwritethread;
+
+import java.io.BufferedReader;
+import java.io.FileReader;
+import java.io.FileWriter;
+import java.io.IOException;
+
+public class ReadWriteThread {
+
+    public static void readFile(String filePath) {
+        Thread thread = new Thread(new Runnable() {
+            @Override
+            public void run() {
+                try (BufferedReader bufferedReader = new BufferedReader(new FileReader(filePath))) {
+                    String line;
+                    while ((line = bufferedReader.readLine()) != null) {
+                        System.out.println(line);
+                    }
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            }
+        });
+        thread.start();
+    }
+
+    public static void writeFile(String filePath, String content) {
+        Thread thread = new Thread(new Runnable() {
+            @Override
+            public void run() {
+                try (FileWriter fileWriter = new FileWriter(filePath)) {
+                    fileWriter.write("Hello, world!");
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            }
+        });
+        thread.start();
+    }
+
+    public static void main(String[] args) {
+        String file = "src/main/resources/text.txt";
+
+        writeFile(file, "Hello, world!");
+
+        readFile(file);
+
+        // Sleep for a while to allow the threads to complete
+        try {
+            Thread.sleep(1000);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+}

core-java-modules/core-java-io-5/src/main/resources/read_file.txt

@@ -0,0 +1,5 @@
+Hello,
+Baeldung!
+Nice to meet you!
+My name is
+Wynn.

core-java-modules/core-java-io-5/src/main/resources/text.txt

@@ -0,0 +1 @@
+Hello, world!

core-java-modules/core-java-io-5/src/main/resources/write_file.txt

@@ -0,0 +1,5 @@
+Hello,
+Baeldung!
+Nice to meet you!
+My name is
+Wynn.

core-java-modules/core-java-io-apis-2/README.md

@@ -9,3 +9,5 @@ This module contains articles about core Java input/output(IO) APIs.
 - [Converting Relative to Absolute Paths in Java](https://www.baeldung.com/java-from-relative-to-absolute-paths)
 - [Detect EOF in Java](https://www.baeldung.com/java-file-detect-end-of-file)
 - [PrintWriter vs. FileWriter in Java](https://www.baeldung.com/java-printwriter-filewriter-difference)
+- [Read Input Character-by-Character in Java](https://www.baeldung.com/java-read-input-character)
+- [Difference Between flush() and close() in Java FileWriter](https://www.baeldung.com/java-filewriter-flush-vs-close)

core-java-modules/core-java-io-apis-2/pom.xml

@@ -82,6 +82,7 @@
             <scope>test</scope>
         </dependency>
     </dependencies>
+
     <build>
         <finalName>core-java-io-apis-2</finalName>
         <resources>
@@ -91,6 +92,7 @@
             </resource>
         </resources>
     </build>
+
     <properties>
         <junit-jupiter-version>5.9.3</junit-jupiter-version>
     </properties>

core-java-modules/core-java-io-apis/README.md

@@ -11,5 +11,5 @@ This module contains articles about core Java input/output(IO) APIs.
 - [Quick Use of FilenameFilter](https://www.baeldung.com/java-filename-filter)
 - [Guide to BufferedReader](https://www.baeldung.com/java-buffered-reader)
 - [Difference Between FileReader and BufferedReader in Java](https://www.baeldung.com/java-filereader-vs-bufferedreader)
-- [Java: Read Multiple Inputs on Same Line](https://www.baeldung.com/java-read-multiple-inputs-same-line)
+- [Read Multiple Inputs on the Same Line in Java](https://www.baeldung.com/java-read-multiple-inputs-same-line)
 - [Write Console Output to Text File in Java](https://www.baeldung.com/java-write-console-output-file)

core-java-modules/core-java-lang-6/Dockerfile

@@ -0,0 +1,7 @@
+FROM maven:3.9-amazoncorretto-17
+WORKDIR /app
+COPY /src/test/java/com/baeldung/setenvironment/SettingDockerEnvironmentVariableUnitTest.java \
+ ./src/test/java/com/baeldung/setenvironment/
+COPY /docker-pom.xml ./
+ENV CUSTOM_DOCKER_ENV_VARIABLE=TRUE
+ENTRYPOINT mvn -f docker-pom.xml test

core-java-modules/core-java-lang-6/README.md

@@ -10,4 +10,8 @@ This module contains articles about core features in the Java language
 - [Stop Executing Further Code in Java](https://www.baeldung.com/java-stop-running-code)
 - [Using the Apache Commons Lang 3 for Comparing Objects in Java](https://www.baeldung.com/java-apache-commons-lang-3-compare-objects)
 - [Return First Non-null Value in Java](https://www.baeldung.com/java-first-non-null)
+- [Compress and Uncompress Byte Array Using Deflater/Inflater](https://www.baeldung.com/java-compress-uncompress-byte-array)
 - [Static Final Variables in Java](https://www.baeldung.com/java-static-final-variables)
+- [What Is the Error: “Non-static method cannot be referenced from a static context”?](https://www.baeldung.com/java-non-static-method-cannot-be-referenced-from-a-static-context)
+- [Recursively Sum the Integers in an Array](https://www.baeldung.com/java-recursive-sum-integer-array)
+- [Set an Environment Variable at Runtime in Java](https://www.baeldung.com/java-set-environment-variable-runtime)

core-java-modules/core-java-lang-6/docker-pom.xml

@@ -0,0 +1,42 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+    xmlns="http://maven.apache.org/POM/4.0.0"
+    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+
+    <groupId>com.baeldung.core-java-modules</groupId>
+    <artifactId>core-java-lang-6</artifactId>
+    <version>0.0.1-SNAPSHOT</version>
+
+    <dependencies>
+        <dependency>
+            <groupId>org.testcontainers</groupId>
+            <artifactId>testcontainers</artifactId>
+            <version>${testcontainers.junit.version}</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.testcontainers</groupId>
+            <artifactId>junit-jupiter</artifactId>
+            <version>${testcontainers.junit.version}</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.junit.jupiter</groupId>
+            <artifactId>junit-jupiter-api</artifactId>
+            <version>5.10.1</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.junit.jupiter</groupId>
+            <artifactId>junit-jupiter-engine</artifactId>
+            <version>5.10.1</version>
+            <scope>test</scope>
+        </dependency>
+    </dependencies>
+
+    <properties>
+        <testcontainers.junit.version>1.19.3</testcontainers.junit.version>
+    </properties>
+
+</project>

core-java-modules/core-java-lang-6/pom.xml

@@ -3,14 +3,14 @@
     xmlns="http://maven.apache.org/POM/4.0.0"
     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-lang-6</artifactId>
+
     <parent>
         <groupId>com.baeldung.core-java-modules</groupId>
         <artifactId>core-java-modules</artifactId>
         <version>0.0.1-SNAPSHOT</version>
     </parent>
 
-    <artifactId>core-java-lang-6</artifactId>
-
     <dependencies>
         <!-- https://mvnrepository.com/artifact/org.mapstruct/mapstruct -->
         <dependency>
@@ -33,6 +33,25 @@
             <artifactId>jmh-generator-annprocess</artifactId>
             <version>${jmh.version}</version>
         </dependency>
+        <dependency>
+            <groupId>org.junit-pioneer</groupId>
+            <artifactId>junit-pioneer</artifactId>
+            <version>${junit.pioneer.version}</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.testcontainers</groupId>
+            <artifactId>testcontainers</artifactId>
+            <version>${testcontaienr.version}</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.testcontainers</groupId>
+            <artifactId>junit-jupiter</artifactId>
+            <version>${testcontaienr.version}</version>
+            <scope>test</scope>
+        </dependency>
+
     </dependencies>
     <build>
         <plugins>
@@ -53,6 +72,8 @@
                             <version>${jmh.version}</version>
                         </path>
                     </annotationProcessorPaths>
+                    <source>14</source>
+                    <target>14</target>
                 </configuration>
             </plugin>
         </plugins>
@@ -61,6 +82,8 @@
     <properties>
         <mapstruct.version>1.6.0.Beta1</mapstruct.version>
         <jmh.version>1.37</jmh.version>
+        <junit.pioneer.version>2.2.0</junit.pioneer.version>
+        <testcontaienr.version>1.19.3</testcontaienr.version>
     </properties>
 
 </project>

core-java-modules/core-java-lang-6/src/test/java/com/baeldung/setenvironment/SettingChildProcessEnvironmentVariableUnitTest.java

@@ -0,0 +1,44 @@
+package com.baeldung.setenvironment;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import java.io.IOException;
+import java.util.Map;
+import org.junit.jupiter.api.Tag;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.condition.EnabledIfEnvironmentVariable;
+
+class SettingChildProcessEnvironmentVariableUnitTest {
+
+    public static final String ENVIRONMENT_VARIABLE_NAME = "test";
+    public static final String ENVIRONMENT_VARIABLE_VALUE = "Hello World";
+    public static final String CHILD_PROCESS_CONDITION = "CHILD_PROCESS_TEST";
+    public static final String CHILD_PROCESS_VALUE = "true";
+    public static final String CHILD_PROCESS_TAG = "child_process";
+    public static final String TAG = String.format("-Dgroups=%s", CHILD_PROCESS_TAG);
+    private final String testClass = String.format("-Dtest=%s", getClass().getName());
+    private final String[] arguments = {"mvn", "test", TAG, testClass};
+
+    @Test
+    void givenChildProcessTestRunner_whenRunTheTest_thenAllSucceed()
+      throws IOException, InterruptedException {
+        ProcessBuilder processBuilder = new ProcessBuilder();
+        processBuilder.inheritIO();
+
+        Map<String, String> environment = processBuilder.environment();
+        environment.put(CHILD_PROCESS_CONDITION, CHILD_PROCESS_VALUE);
+        environment.put(ENVIRONMENT_VARIABLE_NAME, ENVIRONMENT_VARIABLE_VALUE);
+        Process process = processBuilder.command(arguments).start();
+
+        int errorCode = process.waitFor();
+        assertThat(errorCode).isZero();
+    }
+
+    @Test
+    @EnabledIfEnvironmentVariable(named = CHILD_PROCESS_CONDITION, matches = CHILD_PROCESS_VALUE)
+    @Tag(CHILD_PROCESS_TAG)
+    void givenChildProcess_whenGetEnvironmentVariable_thenReturnsCorrectValue() {
+        String actual = System.getenv(ENVIRONMENT_VARIABLE_NAME);
+        assertThat(actual).isEqualTo(ENVIRONMENT_VARIABLE_VALUE);
+    }
+}

core-java-modules/core-java-lang-6/src/test/java/com/baeldung/setenvironment/SettingDockerEnvironmentVariableUnitTest.java

@@ -0,0 +1,19 @@
+package com.baeldung.setenvironment;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.condition.EnabledIfEnvironmentVariable;
+
+class SettingDockerEnvironmentVariableUnitTest {
+
+    public static final String ENV_VARIABLE_NAME = "CUSTOM_DOCKER_ENV_VARIABLE";
+    public static final String ENV_VARIABLE_VALUE = "TRUE";
+
+    @Test
+    @EnabledIfEnvironmentVariable(named = ENV_VARIABLE_NAME, matches = ENV_VARIABLE_VALUE)
+    void givenDockerEnvironment_whenGetEnvironmentVariable_thenReturnsCorrectValue() {
+        String actual = System.getenv(ENV_VARIABLE_NAME);
+        assertEquals(ENV_VARIABLE_VALUE, actual);
+    }
+}

core-java-modules/core-java-lang-6/src/test/java/com/baeldung/setenvironment/SettingSameProcessEnvironmentVariableUnitTest.java

@@ -0,0 +1,83 @@
+package com.baeldung.setenvironment;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import java.lang.reflect.Field;
+import java.util.Collections;
+import java.util.Map;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.condition.EnabledForJreRange;
+import org.junit.jupiter.api.condition.EnabledIfEnvironmentVariable;
+import org.junit.jupiter.api.condition.JRE;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.CsvSource;
+import org.junitpioneer.jupiter.SetEnvironmentVariable;
+
+class SettingSameProcessEnvironmentVariableUnitTest {
+
+    private static final String PROCESS_ENVIRONMENT = "java.lang.ProcessEnvironment";
+    private static final String ENVIRONMENT = "theUnmodifiableEnvironment";
+    private static final String SOURCE_MAP = "m";
+    private static final Object STATIC_METHOD = null;
+    private static final Class<?> UMODIFIABLE_MAP_CLASS
+      = Collections.unmodifiableMap(Collections.emptyMap()).getClass();
+    private static final Class<?> MAP_CLASS = Map.class;
+    public static final String ENV_VARIABLE_NAME = "test";
+    public static final String ENV_VARIABLE_VALUE = "Hello World";
+
+    @ParameterizedTest
+    @CsvSource({ENV_VARIABLE_VALUE + "," + ENV_VARIABLE_NAME})
+    @EnabledForJreRange(max = JRE.JAVA_16)
+    void givenReflexiveAccess_whenGetSourceMap_thenSuccessfullyModifyVariables(String environmentVariable, String value)
+      throws ClassNotFoundException, NoSuchFieldException, IllegalAccessException {
+        Map<String, String> modifiableEnvironment = getModifiableEnvironment();
+        assertThat(modifiableEnvironment).isNotNull();
+
+        modifiableEnvironment.put(environmentVariable, value);
+        String actual = modifiableEnvironment.get(environmentVariable);
+        assertThat(actual).isEqualTo(value);
+    }
+
+    @Test
+    @EnabledIfEnvironmentVariable(named = "PATH", matches = ".*",
+      disabledReason = "The test relies on the presence of PATH variable")
+    void givenOS_whenGetPath_thenVariableIsPresent() {
+        String classPath = System.getenv("PATH");
+        assertThat(classPath).isNotNull();
+    }
+
+    @Test
+    void givenOS_whenGetEnv_thenVariablesArePresent() {
+        Map<String, String> environment = System.getenv();
+        assertThat(environment).isNotNull();
+    }
+
+    @Test
+    @SetEnvironmentVariable(key = ENV_VARIABLE_NAME, value = ENV_VARIABLE_VALUE)
+    @EnabledForJreRange(max = JRE.JAVA_16)
+    void givenVariableSet_whenGetEnvironmentVariable_thenReturnsCorrectValue() {
+        String actual = System.getenv(ENV_VARIABLE_NAME);
+        assertThat(actual).isEqualTo(ENV_VARIABLE_VALUE);
+    }
+
+    @SuppressWarnings("unchecked")
+    private static Map<String, String> getModifiableEnvironment()
+      throws ClassNotFoundException, NoSuchFieldException, IllegalAccessException {
+        Class<?> environmentClass = Class.forName(PROCESS_ENVIRONMENT);
+        Field environmentField = environmentClass.getDeclaredField(ENVIRONMENT);
+        assertThat(environmentField).isNotNull();
+        environmentField.setAccessible(true);
+
+        Object unmodifiableEnvironmentMap = environmentField.get(STATIC_METHOD);
+        assertThat(unmodifiableEnvironmentMap).isNotNull();
+        assertThat(unmodifiableEnvironmentMap).isInstanceOf(UMODIFIABLE_MAP_CLASS);
+
+        Field underlyingMapField = unmodifiableEnvironmentMap.getClass().getDeclaredField(SOURCE_MAP);
+        underlyingMapField.setAccessible(true);
+        Object underlyingMap = underlyingMapField.get(unmodifiableEnvironmentMap);
+        assertThat(underlyingMap).isNotNull();
+        assertThat(underlyingMap).isInstanceOf(MAP_CLASS);
+
+        return (Map<String, String>) underlyingMap;
+    }
+}

core-java-modules/core-java-lang-6/src/test/java/com/baeldung/setenvironment/SettingTestcontainerVariableUnitTest.java

@@ -0,0 +1,31 @@
+package com.baeldung.setenvironment;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import org.junit.jupiter.api.Disabled;
+import org.junit.jupiter.api.Test;
+import org.testcontainers.containers.GenericContainer;
+import org.testcontainers.images.builder.ImageFromDockerfile;
+
+class SettingTestcontainerVariableUnitTest {
+
+    public static final String CONTAINER_REPORT_FILE = "/app/target/surefire-reports/TEST-com.baeldung.setenvironment.SettingDockerEnvironmentVariableUnitTest.xml";
+    public static final String HOST_REPORT_FILE = "./container-test-report.xml";
+    public static final String DOCKERFILE = "./Dockerfile";
+
+    @Test
+    @Disabled("Requires working Docker environment ")
+    void givenTestcontainerEnvironment_whenGetEnvironmentVariable_thenReturnsCorrectValue() {
+        Path dockerfilePath = Paths.get(DOCKERFILE);
+        GenericContainer container = new GenericContainer(
+          new ImageFromDockerfile().withDockerfile(dockerfilePath));
+        assertThat(container).isNotNull();
+        container.start();
+        while (container.isRunning()) {
+            // Busy spin
+        }
+        container.copyFileFromContainer(CONTAINER_REPORT_FILE, HOST_REPORT_FILE);
+    }
+}

core-java-modules/core-java-lang-math-3/README.md

@@ -13,4 +13,8 @@
 - [Java Money and the Currency API](http://www.baeldung.com/java-money-and-currency)
 - [Clamp Function in Java](https://www.baeldung.com/java-clamp-function)
 - [Creating a Magic Square in Java](https://www.baeldung.com/java-magic-square)
+- [Check if a Point Is Between Two Points Drawn on a Straight Line in Java](https://www.baeldung.com/java-check-point-straight-line)
+- [Validate if a String Is a Valid Geo Coordinate](https://www.baeldung.com/java-geo-coordinates-validation)
+- [Rotate a Vertex Around a Certain Point in Java](https://www.baeldung.com/java-rotate-vertex-around-point)
+- [Calculating the Power of Any Number in Java Without Using Math pow() Method](https://www.baeldung.com/java-calculating-the-power-without-math-pow)
 - More articles: [[<-- Prev]](/core-java-modules/core-java-lang-math-2)

core-java-modules/core-java-lang-math-3/src/main/java/com/baeldung/math/rotatevertex/VertexRotation.java

@@ -0,0 +1,26 @@
+package com.baeldung.math.rotatevertex;
+
+import java.awt.geom.AffineTransform;
+import java.awt.geom.Point2D;
+
+public class VertexRotation {
+    public static Point2D.Double usingOriginAsRotationPoint(Point2D.Double vertex, Point2D.Double rotationPoint, double angle) {
+        double translatedToOriginX = vertex.x - rotationPoint.x;
+        double translatedToOriginY = vertex.y - rotationPoint.y;
+
+        double rotatedX = translatedToOriginX * Math.cos(angle) - translatedToOriginY * Math.sin(angle);
+        double rotatedY = translatedToOriginX * Math.sin(angle) + translatedToOriginY * Math.cos(angle);
+
+        double reverseTranslatedX = rotatedX + rotationPoint.x;
+        double reverseTranslatedY = rotatedY + rotationPoint.y;
+
+        return new Point2D.Double(reverseTranslatedX, reverseTranslatedY);
+    }
+
+    public static Point2D.Double usingAffineTransform(Point2D.Double vertex, Point2D.Double rotationPoint, double angle) {
+        AffineTransform affineTransform = AffineTransform.getRotateInstance(angle, rotationPoint.x, rotationPoint.y);
+        Point2D.Double rotatedVertex = new Point2D.Double();
+        affineTransform.transform(vertex, rotatedVertex);
+        return rotatedVertex;
+    }
+}

core-java-modules/core-java-lang-math-3/src/test/java/com/baeldung/com.baeldung.powerinsteadofmathpow/FindPowerInsteadOfUsingMathPowUnitTest.java

@@ -0,0 +1,57 @@
+package com.baeldung.powerinsteadofmathpow;
+
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+public class FindPowerInsteadOfUsingMathPowUnitTest {
+    double result = 1;
+    double base = 2;
+    int exponent = 3;
+
+    @Test
+    public void givenBaseAndExponentNumbers_whenUtilizingIterativeApproach_thenReturnThePower() {
+
+        for (int i = 0; i < exponent; i++) {
+            result *= base;
+        }
+
+        assertEquals(8, result);
+    }
+
+    @Test
+    public void givenBaseAndExponentNumbers_whenUtilizingRecursionApproach_thenReturnThePower() {
+
+        result = calculatePowerRecursively(base, exponent);
+
+        assertEquals(8, result);
+    }
+
+    private double calculatePowerRecursively(double base, int exponent) {
+        if (exponent == 0) {
+            return 1;
+        } else {
+            return base * calculatePowerRecursively(base, exponent - 1);
+        }
+    }
+
+    @Test
+    public void givenBaseAndExponentNumbers_whenUtilizingFastApproach_thenReturnThePower() {
+        result = calculatePowerFast(base, exponent);
+
+        assertEquals(8, result);
+    }
+
+    private double calculatePowerFast(double base, int exponent) {
+        if (exponent == 0) {
+            return 1;
+        }
+
+        double halfPower = calculatePowerFast(base, exponent / 2);
+        if (exponent % 2 == 0) {
+            return halfPower * halfPower;
+        } else {
+            return base * halfPower * halfPower;
+        }
+    }
+}

core-java-modules/core-java-lang-math-3/src/test/java/com/baeldung/math/rotatevertex/VertexRotationUnitTest.java

@@ -0,0 +1,31 @@
+package com.baeldung.math.rotatevertex;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import java.awt.geom.Point2D;
+
+import org.junit.jupiter.api.Test;
+
+public class VertexRotationUnitTest {
+    @Test
+    void givenRotationPoint_whenUseOrigin_thenRotateVertex() {
+        Point2D.Double vertex = new Point2D.Double(2.0, 2.0);
+        Point2D.Double rotationPoint = new Point2D.Double(0.0, 1.0);
+        double angle = Math.toRadians(45.0);
+        Point2D.Double rotatedVertex = VertexRotation.usingOriginAsRotationPoint(vertex, rotationPoint, angle);
+
+        assertEquals(0.707, rotatedVertex.getX(), 0.001);
+        assertEquals(3.121, rotatedVertex.getY(), 0.001);
+    }
+
+    @Test
+    void givenRotationPoint_whenUseAffineTransform_thenRotateVertex() {
+        Point2D.Double vertex = new Point2D.Double(2.0, 2.0);
+        Point2D.Double rotationPoint = new Point2D.Double(0.0, 1.0);
+        double angle = Math.toRadians(45.0);
+        Point2D.Double rotatedVertex = VertexRotation.usingAffineTransform(vertex, rotationPoint, angle);
+
+        assertEquals(0.707, rotatedVertex.getX(), 0.001);
+        assertEquals(3.121, rotatedVertex.getY(), 0.001);
+    }
+}

core-java-modules/core-java-lang-math/pom.xml

@@ -5,6 +5,14 @@
     <modelVersion>4.0.0</modelVersion>
     <artifactId>core-java-lang-math</artifactId>
     <name>core-java-lang-math</name>
+    <packaging>jar</packaging>
+
+    <parent>
+        <groupId>com.baeldung.core-java-modules</groupId>
+        <artifactId>core-java-modules</artifactId>
+        <version>0.0.1-SNAPSHOT</version>
+    </parent>
+
     <dependencies>
         <dependency>
             <groupId>org.projectlombok</groupId>
@@ -13,13 +21,6 @@
             <scope>compile</scope>
         </dependency>
     </dependencies>
-    <packaging>jar</packaging>
-
-    <parent>
-        <groupId>com.baeldung.core-java-modules</groupId>
-        <artifactId>core-java-modules</artifactId>
-        <version>0.0.1-SNAPSHOT</version>
-    </parent>
 
     <build>
         <finalName>core-java-lang-math</finalName>

core-java-modules/core-java-lang-oop-generics/README.md

@@ -10,3 +10,4 @@ This module contains articles about generics in Java
 - [Java Warning “unchecked conversion”](https://www.baeldung.com/java-unchecked-conversion)
 - [Java Warning “Unchecked Cast”](https://www.baeldung.com/java-warning-unchecked-cast)
 - [What Does the Holder<T> Class Do in Java?](https://www.baeldung.com/java-holder-class)
+- [Determine the Class of a Generic Type in Java](https://www.baeldung.com/java-generic-type-find-class-runtime)

core-java-modules/core-java-lang-oop-patterns/pom.xml

@@ -32,7 +32,7 @@
     </dependencies>
 
     <properties>
-        <gson.version>2.8.2</gson.version>
+        <gson.version>2.10.1</gson.version>
     </properties>
 
 </project>

core-java-modules/core-java-networking-4/urlnormalization/URLNormalizationUnitTest.java

@@ -0,0 +1,50 @@
+package com.baeldung.urlnormalization;
+
+import org.junit.jupiter.api.Test;
+import org.apache.commons.validator.routines.UrlValidator;
+
+import java.io.UnsupportedEncodingException;
+import java.net.URI;
+import java.net.URISyntaxException;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+public class URLNormalizationUnitTest {
+    String originalUrl = "https://www.example.com:8080/path/to/resource?param1=value1&param2=value2#fragment";
+    String expectedNormalizedUrl = "https://www.example.com:8080/path/to/resource";
+
+    @Test
+    public void givenOriginalUrl_whenUsingApacheCommonsValidator_thenValidatedAndMaybeManuallyNormalized() {
+        UrlValidator urlValidator = new UrlValidator();
+        if (urlValidator.isValid(originalUrl)) {
+            String normalizedUri = originalUrl.split("\\?")[0];
+            assertEquals(expectedNormalizedUrl, normalizedUri);
+        } else {
+            fail(originalUrl);
+        }
+    }
+
+    @Test
+    public void givenOriginalUrl_whenUsingJavaURIClass_thenNormalizedUrl() throws URISyntaxException {
+        URI uri = new URI(originalUrl);
+        URI normalizedUri = new URI(uri.getScheme(), uri.getAuthority(), uri.getPath(), null, null);
+        String normalizedUrl = normalizedUri.toString();
+        assertEquals(expectedNormalizedUrl, normalizedUrl);
+    }
+
+    @Test
+    public void givenOriginalUrl_whenUsingRegularExpression_thenNormalizedUrl() {
+        String regex = "^(https?://[^/]+/[^?#]+)";
+        Pattern pattern = Pattern.compile(regex);
+        Matcher matcher = pattern.matcher(originalUrl);
+
+        if (matcher.find()) {
+            String normalizedUrl = matcher.group(1);
+            assertEquals(expectedNormalizedUrl, normalizedUrl);
+        } else {
+            fail(originalUrl);
+        }
+    }
+}

core-java-modules/core-java-numbers-6/pom.xml

@@ -31,6 +31,7 @@
             <version>${guava.version}</version>
         </dependency>
     </dependencies>
+
     <build>
         <finalName>core-java-numbers-6</finalName>
         <resources>
@@ -44,4 +45,5 @@
     <properties>
         <commons-codec>1.16.0</commons-codec>
     </properties>
+
 </project>

core-java-modules/core-java-numbers-7/README.md

@@ -1,2 +1,4 @@
 ## Relevant Articles
 - [Check if a double Is an Integer in Java](https://www.baeldung.com/java-check-double-integer)
+- [Print a Double Value Without Scientific Notation in Java](https://www.baeldung.com/java-print-double-number-no-scientific-notation)
+- [Check if a Float Value is Equivalent to an Integer Value in Java](https://www.baeldung.com/java-float-integer-equal)

core-java-modules/core-java-numbers-7/pom.xml

@@ -25,6 +25,7 @@
             <version>${guava.version}</version>
         </dependency>
     </dependencies>
+
     <build>
         <finalName>core-java-numbers-7</finalName>
         <resources>
@@ -34,4 +35,5 @@
             </resource>
         </resources>
     </build>
+
 </project>

core-java-modules/core-java-numbers-conversions/README.md

@@ -2,7 +2,9 @@
 - [Convert a Number to a Letter in Java](https://www.baeldung.com/java-convert-number-to-letter)
 - [Convert Long to BigDecimal in Java](https://www.baeldung.com/java-convert-long-bigdecimal)
 - [Convert int to Long in Java](https://www.baeldung.com/java-convert-int-long)
-- [How To Convert Double To Float In Java](https://www.baeldung.com/java-convert-double-float)
+- [How to Convert Double to Float in Java](https://www.baeldung.com/java-convert-double-float)
 - [Converting from float to BigDecimal in Java](https://www.baeldung.com/java-convert-float-bigdecimal)
 - [Convert Positive Integer to Negative and Vice Versa in Java](https://www.baeldung.com/java-negating-integer)
 - [Rounding Up a Number to Nearest Multiple of 5 in Java](https://www.baeldung.com/java-round-nearest-multiple-five)
+- [Convert byte to int Type in Java](https://www.baeldung.com/java-byte-to-int-conversion)
+- [Converting Integer to BigDecimal in Java](https://www.baeldung.com/java-integer-bigdecimal-conversion)

core-java-modules/core-java-numbers-conversions/src/main/java/com/baeldung/bytetoint/ByteToIntConversion.java

@@ -0,0 +1,25 @@
+package com.baeldung.bytetoint;
+
+public class ByteToIntConversion {
+    static int usingTypeCasting(byte b){
+        int i = b;
+        return i;
+    }
+
+    static int usingIntegerValueOf(byte b){
+        return Integer.valueOf(b);
+    }
+
+    static int usingByteIntValue(byte b){
+        Byte byteObj = new Byte(b);
+        return byteObj.intValue();
+    }
+
+    static int usingMathToIntExact(byte b){
+        return Math.toIntExact(b);
+    }
+
+    static int usingByteUnsignedInt(byte b){
+        return Byte.toUnsignedInt(b);
+    }
+}

core-java-modules/core-java-numbers-conversions/src/test/java/com/baeldung/bytetoint/ByteToIntConversionUnitTest.java

@@ -0,0 +1,45 @@
+package com.baeldung.bytetoint;
+
+import org.junit.Test;
+import static org.junit.Assert.assertEquals;
+
+public class ByteToIntConversionUnitTest {
+    @Test
+    public void givenByte_whenUsingTypeCasting_thenConvertToInt() {
+        byte b = -51;
+        int result = ByteToIntConversion.usingTypeCasting(b);
+            assertEquals(-51, result);
+    }
+
+    @Test
+    void givenByte_whenUsingIntegerValueOf_thenConvertToInt() {
+        byte b = -51;
+        int result = ByteToIntConversion.usingIntegerValueOf(b);
+
+        assertEquals(-51, result);
+    }
+
+    @Test
+    void givenByte_whenUsingByteIntValue_thenConvertToInt() {
+        byte b = -51;
+        int result = ByteToIntConversion.usingByteIntValue(b);
+
+        assertEquals(-51, result);
+    }
+
+    @Test
+    void givenByte_whenUsingMathToIntExact_thenConvertToInt() {
+        byte b = -51;
+        int result = ByteToIntConversion.usingMathToIntExact(b);
+
+        assertEquals(-51, result);
+    }
+
+    @Test
+    void givenByte_whenUsingByteUnsignedInt_thenConvertToInt() {
+        byte b = -51;
+        int result = ByteToIntConversion.usingByteUnsignedInt(b);
+
+        assertEquals(205, result);
+    }
+}

core-java-modules/core-java-perf-2/src/test/java/com/baeldung/oom/OomCrashUnitTest.java

@@ -0,0 +1,52 @@
+package com.baeldung.oom;
+
+import java.util.ArrayList;
+import java.util.List;
+import org.junit.jupiter.api.Disabled;
+import org.junit.jupiter.api.Test;
+
+@Disabled
+class OomCrashUnitTest {
+
+    public static final Runnable MEMORY_LEAK = () -> {
+        List<byte[]> list = new ArrayList<>();
+        while (true) {
+            list.add(tenMegabytes());
+        }
+    };
+
+    @Test
+    void givenMemoryLeakCode_whenRunInsideThread_thenMainAppDoestFail() throws InterruptedException {
+        Thread memoryLeakThread = new Thread(MEMORY_LEAK);
+        memoryLeakThread.start();
+        memoryLeakThread.join();
+    }
+
+    @Test
+    void givenMemoryLeakCode_whenRunSeveralTimesInsideThread_thenMainAppDoestFail() throws InterruptedException {
+        for (int i = 0; i < 5; i++) {
+            Thread memoryLeakThread = new Thread(MEMORY_LEAK);
+            memoryLeakThread.start();
+            memoryLeakThread.join();
+        }
+    }
+
+    @Test
+    void givenBadExample_whenUseItInProductionCode_thenQuestionedByEmployerAndProbablyFired()
+      throws InterruptedException {
+        Thread npeThread = new Thread(() -> {
+            String nullString = null;
+            try {
+                nullString.isEmpty();
+            } catch (NullPointerException e) {
+                throw new OutOfMemoryError(e.getMessage());
+            }
+        });
+        npeThread.start();
+        npeThread.join();
+    }
+
+    private static byte[] tenMegabytes() {
+        return new byte[1024 * 1014 * 10];
+    }
+}

core-java-modules/core-java-records/pom.xml

@@ -2,14 +2,15 @@
 <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-records</artifactId>
+
     <parent>
         <artifactId>core-java-modules</artifactId>
         <groupId>com.baeldung.core-java-modules</groupId>
         <version>0.0.1-SNAPSHOT</version>
     </parent>
-    <modelVersion>4.0.0</modelVersion>
 
-    <artifactId>core-java-records</artifactId>
     <build>
         <plugins>
             <plugin>

core-java-modules/core-java-reflection-3/src/main/java/com/baeldung/reflection/innerclass/Person.java

@@ -0,0 +1,20 @@
+package com.baeldung.reflection.innerclass;
+
+public class Person {
+    String name;
+    Address address;
+
+    public Person() {
+    }
+
+    public class Address {
+        String zip;
+
+        public Address(String zip) {
+            this.zip = zip;
+        }
+    }
+
+    public static class Builder {
+    }
+}

core-java-modules/core-java-reflection-3/src/test/java/com/baeldung/reflection/innerclass/CreateInnerClassWithReflectionUnitTest.java

@@ -0,0 +1,67 @@
+package com.baeldung.reflection.innerclass;
+
+import java.lang.reflect.Constructor;
+import java.lang.reflect.InvocationTargetException;
+import java.util.Arrays;
+import java.util.stream.Collectors;
+
+import static org.junit.jupiter.api.Assertions.*;
+import org.junit.jupiter.api.Test;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class CreateInnerClassWithReflectionUnitTest {
+
+    static Logger logger = LoggerFactory.getLogger(CreateInnerClassWithReflectionUnitTest.class);
+
+    @Test
+    void givenInnerClass_whenUseReflection_thenShowConstructors() {
+        final String personBuilderClassName = "com.baeldung.reflection.innerclass.Person$Builder";
+        final String personAddressClassName = "com.baeldung.reflection.innerclass.Person$Address";
+        assertDoesNotThrow(() -> logConstructors(Class.forName(personAddressClassName)));
+        assertDoesNotThrow(() -> logConstructors(Class.forName(personBuilderClassName)));
+    }
+
+    private static void logConstructors(Class<?> clazz) {
+        Arrays.stream(clazz.getDeclaredConstructors())
+            .map(c -> formatConstructorSignature(c))
+            .forEach(logger::info);
+    }
+
+    private static String formatConstructorSignature(Constructor<?> constructor) {
+        String params = Arrays.stream(constructor.getParameters())
+            .map(parameter -> parameter.getType().getSimpleName() + " " + parameter.getName())
+            .collect(Collectors.joining(", "));
+        return constructor.getName() + "(" + params + ")";
+    }
+
+    @Test
+    void givenStaticInnerClass_whenUseReflection_thenInstantiate()
+        throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException,
+            InstantiationException, IllegalAccessException {
+        final String personBuilderClassName = "com.baeldung.reflection.innerclass.Person$Builder";
+        Class<Person.Builder> personBuilderClass = (Class<Person.Builder>) Class.forName(personBuilderClassName);
+        Person.Builder personBuilderObj = personBuilderClass.getDeclaredConstructor().newInstance();
+        assertTrue(personBuilderObj instanceof Person.Builder);
+    }
+
+    @Test
+    void givenNonStaticInnerClass_whenUseReflection_thenInstantiate()
+        throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException,
+            InstantiationException, IllegalAccessException {
+        final String personClassName = "com.baeldung.reflection.innerclass.Person";
+        final String personAddressClassName = "com.baeldung.reflection.innerclass.Person$Address";
+
+        Class<Person> personClass = (Class<Person>) Class.forName(personClassName);
+        Person personObj = personClass.getConstructor().newInstance();
+
+        Class<Person.Address> personAddressClass = (Class<Person.Address>) Class.forName(personAddressClassName);
+
+        assertThrows(NoSuchMethodException.class, () -> personAddressClass.getDeclaredConstructor(String.class));
+
+        Constructor<Person.Address> constructorOfPersonAddress = personAddressClass.getDeclaredConstructor(Person.class, String.class);
+        Person.Address personAddressObj = constructorOfPersonAddress.newInstance(personObj, "751003");
+        assertTrue(personAddressObj instanceof Person.Address);
+    }
+
+}

core-java-modules/core-java-regex-2/README.md

@@ -9,5 +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)
+- [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)

core-java-modules/core-java-regex-3/README.md

@@ -0,0 +1,3 @@
+### Relevant Articles:
+
+- More articles: [[<-- prev]](/core-java-modules/core-java-regex-2)

core-java-modules/core-java-regex-3/pom.xml

@@ -0,0 +1,24 @@
+<?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-regex-3</artifactId>
+    <name>core-java-regex-3</name>
+    <dependencies>
+        <dependency>
+            <groupId>org.junit.jupiter</groupId>
+            <artifactId>junit-jupiter</artifactId>
+            <version>5.8.1</version>
+            <scope>test</scope>
+        </dependency>
+    </dependencies>
+    <packaging>jar</packaging>
+
+    <parent>
+        <groupId>com.baeldung.core-java-modules</groupId>
+        <artifactId>core-java-modules</artifactId>
+        <version>0.0.1-SNAPSHOT</version>
+    </parent>
+
+</project>