Merge branch 'eugenp:master' into danielmcnally285_return_first_non_null

2023-10-31 20:21:00 +00:00
parent 9d66171dd5 0422349dab
commit a54e0ba8d2
414 changed files with 3612 additions and 381 deletions
@@ -0,0 +1,129 @@
+package com.baeldung.algorithms.connect4;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class GameBoard {
+    private final List<List<Piece>> columns;
+
+    private final int rows;
+
+    public GameBoard(int columns, int rows) {
+        this.rows = rows;
+        this.columns = new ArrayList<>();
+
+        for (int i = 0; i < columns; ++i) {
+            this.columns.add(new ArrayList<>());
+        }
+    }
+
+    public int getRows() {
+        return rows;
+    }
+
+    public int getColumns() {
+        return columns.size();
+    }
+
+    public Piece getCell(int x, int y) {
+        assert(x >= 0 && x < getColumns());
+        assert(y >= 0 && y < getRows());
+
+        List<Piece> column = columns.get(x);
+
+        if (column.size() > y) {
+            return column.get(y);
+        } else {
+            return null;
+        }
+    }
+
+    public boolean move(int x, Piece player) {
+        assert(x >= 0 && x < getColumns());
+
+        List<Piece> column = columns.get(x);
+
+        if (column.size() >= this.rows) {
+            throw new IllegalArgumentException("That column is full");
+        }
+
+        column.add(player);
+
+        return checkWin(x, column.size() - 1, player);
+    }
+
+    private boolean checkWin(int x, int y, Piece player) {
+        // Vertical line
+        if (checkLine(x, y, 0, -1, player)) {
+            return true;
+        }
+
+        for (int offset = 0; offset < 4; ++offset) {
+            // Horizontal line
+            if (checkLine(x - 3 + offset, y, 1, 0, player)) {
+                return true;
+            }
+
+            // Leading diagonal
+            if (checkLine(x - 3 + offset, y + 3 - offset, 1, -1, player)) {
+                return true;
+            }
+
+            // Trailing diagonal
+            if (checkLine(x - 3 + offset, y - 3 + offset, 1, 1, player)) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    private boolean checkLine(int x1, int y1, int xDiff, int yDiff, Piece player) {
+        for (int i = 0; i < 4; ++i) {
+            int x = x1 + (xDiff * i);
+            int y = y1 + (yDiff * i);
+
+            if (x < 0 || x > columns.size() - 1) {
+                return false;
+            }
+
+            if (y < 0 || y > rows - 1) {
+                return false;
+            }
+
+            if (player != getCell(x, y)) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    @Override
+    public String toString() {
+        StringBuilder result = new StringBuilder();
+
+        for (int y = getRows() - 1; y >= 0; --y) {
+            for (int x = 0; x < getColumns(); ++x) {
+                Piece piece = getCell(x, y);
+
+                result.append("|");
+                if (piece == null) {
+                    result.append(" ");
+                } else if (piece == Piece.PLAYER_1) {
+                    result.append("X");
+                } else if (piece == Piece.PLAYER_2) {
+                    result.append("O");
+                }
+            }
+
+            result.append("|\n");
+            for (int i = 0; i < getColumns(); ++i) {
+                result.append("+-");
+            }
+            result.append("+\n");
+        }
+
+        return result.toString();
+    }
+}
@@ -0,0 +1,40 @@
+package com.baeldung.algorithms.connect4;
+
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+public class GameUnitTest {
+    @Test
+    public void blankGame() {
+        GameBoard gameBoard = new GameBoard(8, 6);
+
+        System.out.println(gameBoard);
+    }
+
+    @Test
+    public void playedGame() {
+        GameBoard gameBoard = new GameBoard(8, 6);
+
+        assertFalse(gameBoard.move(3, Piece.PLAYER_1));
+        assertFalse(gameBoard.move(2, Piece.PLAYER_2));
+
+        assertFalse(gameBoard.move(4, Piece.PLAYER_1));
+        assertFalse(gameBoard.move(3, Piece.PLAYER_2));
+
+        assertFalse(gameBoard.move(5, Piece.PLAYER_1));
+        assertFalse(gameBoard.move(6, Piece.PLAYER_2));
+
+        assertFalse(gameBoard.move(5, Piece.PLAYER_1));
+        assertFalse(gameBoard.move(4, Piece.PLAYER_2));
+
+        assertFalse(gameBoard.move(5, Piece.PLAYER_1));
+        assertFalse(gameBoard.move(5, Piece.PLAYER_2));
+
+        assertFalse(gameBoard.move(6, Piece.PLAYER_1));
+        assertTrue(gameBoard.move(4, Piece.PLAYER_2));
+
+        System.out.println(gameBoard);
+    }
+}
@@ -0,0 +1,6 @@
+package com.baeldung.algorithms.connect4;
+
+public enum Piece {
+    PLAYER_1,
+    PLAYER_2
+}
@@ -5,6 +5,5 @@ This module contains articles about various Amazon Web Services (AWS) such as EC
 ### Relevant articles

 - [Managing EC2 Instances in Java](https://www.baeldung.com/ec2-java)
- [Integration Testing with a Local DynamoDB Instance](https://www.baeldung.com/dynamodb-local-integration-tests)
 - [Managing Amazon SQS Queues in Java](https://www.baeldung.com/aws-queues-java)
 - [Guide to AWS Aurora RDS with Java](https://www.baeldung.com/aws-aurora-rds-java)
@@ -11,5 +11,5 @@ This module contains articles about Java 8 core features
 - [Finding Min/Max in an Array with Java](https://www.baeldung.com/java-array-min-max)
 - [Internationalization and Localization in Java 8](https://www.baeldung.com/java-8-localization)
 - [Generalized Target-Type Inference in Java](https://www.baeldung.com/java-generalized-target-type-inference)
- [Monads in Java](https://www.baeldung.com/java-monads)
+- [Monads in Java – Optional](https://www.baeldung.com/java-monads)
 - [[More -->]](/core-java-modules/core-java-8-2)
@@ -0,0 +1,48 @@
+package com.baeldung.spliterator;
+
+import java.util.List;
+import java.util.Spliterator;
+import java.util.function.Consumer;
+
+public class CustomSpliterator implements Spliterator<Integer> {
+    private final List<Integer> elements;
+    private int currentIndex;
+    
+    public CustomSpliterator(List<Integer> elements) {
+        this.elements = elements;
+        this.currentIndex = 0;
+    }
+    
+    @Override
+    public boolean tryAdvance(Consumer<? super Integer> action) {
+        if (currentIndex < elements.size()) {
+            action.accept(elements.get(currentIndex));
+            currentIndex++;
+            return true;
+        }
+        return false;
+    }
+    
+    @Override
+    public Spliterator<Integer> trySplit() {
+        int currentSize = elements.size() - currentIndex;
+        if (currentSize < 2) {
+            return null;
+        }
+        
+        int splitIndex = currentIndex + currentSize / 2;
+        CustomSpliterator newSpliterator = new CustomSpliterator(elements.subList(currentIndex, splitIndex));
+        currentIndex = splitIndex;
+        return newSpliterator;
+    }
+    
+    @Override
+    public long estimateSize() {
+        return elements.size() - currentIndex;
+    }
+    
+    @Override
+    public int characteristics() {
+        return ORDERED | SIZED | SUBSIZED | NONNULL;
+    }
+} 
@@ -1,12 +0,0 @@
-package com.baeldung.spliterator;
-
-import java.util.stream.Stream;
-
-public class Executor {
-
-	public static int countAutors(Stream<Author> stream) {
-		RelatedAuthorCounter wordCounter = stream.reduce(new RelatedAuthorCounter(0, true),
-				RelatedAuthorCounter::accumulate, RelatedAuthorCounter::combine);
-		return wordCounter.getCounter();
-	}
-}
@@ -1,27 +0,0 @@
-package com.baeldung.spliterator;
-
-public class RelatedAuthorCounter {
-    private final int counter;
-    private final boolean isRelated;
-
-    public RelatedAuthorCounter(int counter, boolean isRelated) {
-        this.counter = counter;
-        this.isRelated = isRelated;
-    }
-
-    public RelatedAuthorCounter accumulate(Author author) {
-        if (author.getRelatedArticleId() == 0) {
-            return isRelated ? this : new RelatedAuthorCounter(counter, true);
-        } else {
-            return isRelated ? new RelatedAuthorCounter(counter + 1, false) : this;
-        }
-    }
-
-    public RelatedAuthorCounter combine(RelatedAuthorCounter RelatedAuthorCounter) {
-        return new RelatedAuthorCounter(counter + RelatedAuthorCounter.counter, RelatedAuthorCounter.isRelated);
-    }
-
-    public int getCounter() {
-        return counter;
-    }
-}
@@ -1,49 +0,0 @@
-package com.baeldung.spliterator;
-
-import java.util.List;
-import java.util.Spliterator;
-import java.util.concurrent.atomic.AtomicInteger;
-import java.util.function.Consumer;
-
-public class RelatedAuthorSpliterator implements Spliterator<Author> {
-	private final List<Author> list;
-	AtomicInteger current = new AtomicInteger();
-
-	public RelatedAuthorSpliterator(List<Author> list) {
-		this.list = list;
-	}
-
-	@Override
-	public boolean tryAdvance(Consumer<? super Author> action) {
-
-		action.accept(list.get(current.getAndIncrement()));
-		return current.get() < list.size();
-	}
-
-	@Override
-	public Spliterator<Author> trySplit() {
-		int currentSize = list.size() - current.get();
-		if (currentSize < 10) {
-			return null;
-		}
-		for (int splitPos = currentSize / 2 + current.intValue(); splitPos < list.size(); splitPos++) {
-			if (list.get(splitPos).getRelatedArticleId() == 0) {
-				Spliterator<Author> spliterator = new RelatedAuthorSpliterator(list.subList(current.get(), splitPos));
-				current.set(splitPos);
-				return spliterator;
-			}
-		}
-		return null;
-	}
-
-	@Override
-	public long estimateSize() {
-		return list.size() - current.get();
-	}
-
-	@Override
-	public int characteristics() {
-		return CONCURRENT;
-	}
-
-}
@@ -6,10 +6,10 @@ import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
 import java.util.Spliterator;
+import java.util.concurrent.ForkJoinPool;
+import java.util.concurrent.atomic.AtomicInteger;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
-import java.util.stream.StreamSupport;
-
 import org.junit.Before;
 import org.junit.Test;

@@ -18,22 +18,50 @@ import lombok.extern.slf4j.Slf4j;
@Slf4j
 public class ExecutorUnitTest {
    Article article;
-    Stream<Author> stream;
-    Spliterator<Author> spliterator;

    @Before
    public void init() {
        article = new Article(Arrays.asList(new Author("Ahmad", 0), new Author("Eugen", 0), new Author("Alice", 1), new Author("Alice", 1), new Author("Mike", 0), new Author("Alice", 1), new Author("Mike", 0), new Author("Alice", 1), new Author("Mike", 0),
            new Author("Alice", 1), new Author("Mike", 0), new Author("Mike", 0), new Author("Alice", 1), new Author("Mike", 0), new Author("Alice", 1), new Author("Mike", 0), new Author("Alice", 1), new Author("Mike", 0), new Author("Alice", 1),
            new Author("Mike", 0), new Author("Michał", 0), new Author("Loredana", 1)), 0);
-
-        spliterator = new RelatedAuthorSpliterator(article.getListOfAuthors());
    }

    @Test
-    public void givenAstreamOfAuthors_whenProcessedInParallelWithCustomSpliterator_coubtProducessRightOutput() {
-        Stream<Author> stream2 = StreamSupport.stream(spliterator, true);
-        assertThat(Executor.countAutors(stream2.parallel())).isEqualTo(9);
+    public void givenAStreamOfIntegers_whenProcessedSequentialCustomSpliterator_countProducesRightOutput() {
+        List<Integer> numbers = new ArrayList<>();
+        numbers.add(1);
+        numbers.add(2);
+        numbers.add(3);
+        numbers.add(4);
+        numbers.add(5);
+
+        CustomSpliterator customSpliterator = new CustomSpliterator(numbers);
+
+        AtomicInteger sum = new AtomicInteger();
+
+        customSpliterator.forEachRemaining(sum::addAndGet);
+        assertThat(sum.get()).isEqualTo(15);
+    }
+
+    @Test
+    public void givenAStreamOfIntegers_whenProcessedInParallelWithCustomSpliterator_countProducesRightOutput() {
+        List<Integer> numbers = new ArrayList<>();
+        numbers.add(1);
+        numbers.add(2);
+        numbers.add(3);
+        numbers.add(4);
+        numbers.add(5);
+
+        CustomSpliterator customSpliterator = new CustomSpliterator(numbers);
+
+        // Create a ForkJoinPool for parallel processing
+        ForkJoinPool forkJoinPool = ForkJoinPool.commonPool();
+
+        AtomicInteger sum = new AtomicInteger(0);
+
+        // Process elements in parallel using parallelStream
+        forkJoinPool.submit(() -> customSpliterator.forEachRemaining(sum::addAndGet)).join();
+        assertThat(sum.get()).isEqualTo(15);
    }

    @Test
@@ -43,9 +71,7 @@ public class ExecutorUnitTest {
            .collect(Collectors.toList());

        Spliterator<Article> spliterator = articles.spliterator();
-        while (spliterator.tryAdvance(article -> article.setName(article.getName()
-            .concat("- published by Baeldung"))))
-            ;
+        while(spliterator.tryAdvance(article -> article.setName(article.getName().concat("- published by Baeldung"))));

        articles.forEach(article -> assertThat(article.getName()).isEqualTo("Java- published by Baeldung"));
    }
@@ -57,5 +57,9 @@
            </plugin>
        </plugins>
    </build>
+    
+    <properties>
+        <maven.compiler.release>11</maven.compiler.release>
+    </properties>

 </project>
@@ -0,0 +1,29 @@
+package com.baeldung.arraycompare;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import java.util.Arrays;
+
+import org.junit.jupiter.api.Test;
+
+class ArraysCompareUnitTest {
+
+    @Test
+    void givenSameContents_whenCompare_thenCorrect() {
+        String[] array1 = new String[] { "A", "B", "C" };
+        String[] array2 = new String[] { "A", "B", "C" };
+
+        assertThat(Arrays.compare(array1, array2)).isEqualTo(0);
+    }
+
+    @Test
+    void givenDifferentContents_whenCompare_thenDifferent() {
+        String[] array1 = new String[] { "A", "B", "C" };
+        String[] array2 = new String[] { "A", "C", "B", "D" };
+
+        assertThat(Arrays.compare(array1, array2)).isLessThan(0);
+        assertThat(Arrays.compare(array2, array1)).isGreaterThan(0);
+        assertThat(Arrays.compare(array1, null)).isGreaterThan(0);
+    }
+
+}
@@ -0,0 +1,6 @@
+## Core Java Arrays - Basic Operations
+
+This module contains articles about Java array fundamentals. They assume no previous background knowledge on working with arrays.
+
+### Relevant Articles: 
+- [Arrays mismatch() Method in Java](https://www.baeldung.com/java-arrays-mismatch)
@@ -0,0 +1,16 @@
+<?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-arrays-operations-basic-2</artifactId>
+    <name>core-java-arrays-operations-basic-2</name>
+    <packaging>jar</packaging>
+
+    <parent>
+        <artifactId>core-java-modules</artifactId>
+        <groupId>com.baeldung.core-java-modules</groupId>
+        <version>0.0.1-SNAPSHOT</version>
+    </parent>
+
+</project>
@@ -0,0 +1,269 @@
+package com.baeldung.array.mismatch;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+import java.util.Arrays;
+import java.util.Comparator;
+
+import org.junit.jupiter.api.Test;
+
+class ArrayMismatchUnitTest {
+    
+    @Test
+    void givenTwoArraysWithACommonPrefix_whenMismatch_thenIndexOfFirstMismatch() {
+        int[] firstArray = {1, 2, 3, 4, 5};
+        int[] secondArray = {1, 2, 3, 5, 8};
+        assertEquals(3, Arrays.mismatch(firstArray, secondArray));
+    }
+    
+    @Test
+    void givenTwoIdenticalArrays_whenMismatch_thenMinusOne() {
+        int[] firstArray = {1, 2, 3, 4, 5};
+        int[] secondArray = {1, 2, 3, 4, 5};
+        assertEquals(-1, Arrays.mismatch(firstArray, secondArray));
+    }
+    
+    @Test
+    void givenFirstArrayIsAPrefixOfTheSecond_whenMismatch_thenFirstArrayLength() {
+        int[] firstArray = {1, 2, 3, 4, 5};
+        int[] secondArray = {1, 2, 3, 4, 5, 6, 7, 8, 9};
+        assertEquals(firstArray.length, Arrays.mismatch(firstArray, secondArray));
+    }
+    
+    @Test
+    void givenNoCommonPrefix_whenMismatch_thenZero() {
+        int[] firstArray = {1, 2, 3, 4, 5};
+        int[] secondArray = {9, 8, 7};
+        assertEquals(0, Arrays.mismatch(firstArray, secondArray));
+    }
+    
+    @Test
+    void givenAtLeastANullArray_whenMismatch_thenThrowsNullPointerException() {
+        int[] firstArray = null;
+        int[] secondArray = {1, 2, 3, 4, 5};
+        assertThrows(NullPointerException.class, () -> Arrays.mismatch(firstArray, secondArray));
+        assertThrows(NullPointerException.class, () -> Arrays.mismatch(secondArray, firstArray));
+        assertThrows(NullPointerException.class, () -> Arrays.mismatch(firstArray, firstArray));
+    }
+    
+    @Test
+    void givenExactlyOneAnEmptyArray_whenMismatch_thenZero() {
+        int[] firstArray = {};
+        int[] secondArray = {1, 2, 3};
+        assertEquals(0, Arrays.mismatch(firstArray, secondArray));
+        assertEquals(0, Arrays.mismatch(secondArray, firstArray));
+    }
+    
+    @Test
+    void givenTwoEmptyArrays_whenMismatch_thenMinusOne() {
+        assertEquals(-1, Arrays.mismatch(new int[] {}, new int[] {}));
+    }
+    
+    @Test
+    void givenTwoSubArraysWithACommonPrefix_whenMismatch_thenIndexOfFirstMismatch() {
+        int[] firstArray = {1, 2, 3, 4, 5};
+        int[] secondArray = {0, 1, 2, 3, 5, 8};
+        assertEquals(3, Arrays.mismatch(firstArray, 0, 4, secondArray, 1, 6));
+    }
+    
+    @Test
+    void givenTwoIdenticalSubArrays_whenMismatch_thenMinusOne() {
+        int[] firstArray = {0, 0, 1, 2};
+        int[] secondArray = {0, 1, 2, 3, 4};
+        assertEquals(-1, Arrays.mismatch(firstArray, 2, 4, secondArray, 1, 3));
+    }
+    
+    @Test
+    void givenFirstSubArrayIsAPrefixOfTheSecond_whenMismatch_thenFirstArrayLength() {
+        int[] firstArray = {2, 3, 4, 5, 4, 3, 2};
+        int[] secondArray = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
+        assertEquals(4, Arrays.mismatch(firstArray, 0, 4, secondArray, 2, 9));
+    }
+    
+    @Test
+    void givenNoCommonPrefixForSubArrays_whenMismatch_thenZero() {
+        int[] firstArray = {0, 0, 0, 0, 0};
+        int[] secondArray = {9, 8, 7, 6, 5};
+        assertEquals(0, Arrays.mismatch(firstArray, 1, 2, secondArray, 1, 2));
+    }
+    
+    @Test
+    void givenAtLeastANullSubArray_whenMismatch_thenThrowsNullPointerException() {
+        int[] firstArray = null;
+        int[] secondArray = {1, 2, 3, 4, 5};
+        assertThrows(NullPointerException.class, () -> Arrays.mismatch(firstArray, 0, 1, secondArray, 0, 1));
+        assertThrows(NullPointerException.class, () -> Arrays.mismatch(secondArray, 0, 1, firstArray, 0, 1));
+        assertThrows(NullPointerException.class, () -> Arrays.mismatch(firstArray, 0, 1, firstArray, 0, 1));
+    }
+    
+    @Test
+    void givenExactlyOneEmptySubArray_whenMismatch_thenZero() {
+        int[] firstArray = {1};
+        int[] secondArray = {1, 2, 3};
+        assertEquals(0, Arrays.mismatch(firstArray, 0, 0, secondArray, 0, 2));
+        assertEquals(0, Arrays.mismatch(firstArray, 0, 1, secondArray, 2, 2));
+    }
+    
+    @Test
+    void givenTwoEmptySubArrays_whenMismatch_thenMinusOne() {
+        int[] firstArray = {1};
+        int[] secondArray = {1, 2, 3};
+        assertEquals(-1, Arrays.mismatch(firstArray, 0, 0, secondArray, 2, 2));
+    }
+    
+    @Test
+    void givenToIndexGreaterThanFromIndex_whenMismatch_thenThrowsIllegalArgumentException() {
+        int[] firstArray = {2, 3, 4, 5, 4, 3, 2};
+        int[] secondArray = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
+        assertThrows(IllegalArgumentException.class, () -> Arrays.mismatch(firstArray, 4, 2, secondArray, 0, 6));
+        assertThrows(IllegalArgumentException.class, () -> Arrays.mismatch(firstArray, 2, 3, secondArray, 6, 0));
+    }
+    
+    @Test
+    void givenIllegalIndexes_whenMismatch_thenThrowsArrayIndexOutOfBoundsException() {
+        int[] firstArray = {2, 3, 4, 5, 4, 3, 2};
+        int[] secondArray = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
+        assertThrows(ArrayIndexOutOfBoundsException.class, () -> Arrays.mismatch(firstArray, -1, 2, secondArray, 0, 6));
+        assertThrows(ArrayIndexOutOfBoundsException.class, () -> Arrays.mismatch(firstArray, 0, 8, secondArray, 0, 6));
+        assertThrows(ArrayIndexOutOfBoundsException.class, () -> Arrays.mismatch(firstArray, 2, 3, secondArray, -5, 0));
+        assertThrows(ArrayIndexOutOfBoundsException.class, () -> Arrays.mismatch(firstArray, 2, 3, secondArray, 11, 12));
+    }
+    
+    @Test
+    void givenTwoStringArraysAndAComparator_whenMismatch_thenIndexOfFirstMismatch() {
+        String[] firstArray = {"one", "two", "three"};
+        String[] secondArray = {"ONE", "TWO", "FOUR"};
+        Comparator<String> comparator = String.CASE_INSENSITIVE_ORDER;
+        assertEquals(2, Arrays.mismatch(firstArray, secondArray, comparator));
+    }
+    
+    @Test
+    void givenTwoIdenticalStringArraysForTheComparator_whenMismatch_thenMinusOne() {
+        String[] firstArray = {"one", "two", "three"};
+        String[] secondArray = {"ONE", "TWO", "THREE"};
+        Comparator<String> comparator = String.CASE_INSENSITIVE_ORDER;
+        assertEquals(-1, Arrays.mismatch(firstArray, secondArray, comparator));
+    }
+    
+    @Test
+    void givenFirstStringArrayIsAPrefixOfTheSecondForTheComparator_whenMismatch_thenFirstArrayLength() {
+        String[] firstArray = {"one", "two", "three"};
+        String[] secondArray = {"ONE", "TWO", "THREE", "FOUR", "FIVE"};
+        Comparator<String> comparator = String.CASE_INSENSITIVE_ORDER;
+        assertEquals(firstArray.length, Arrays.mismatch(firstArray, secondArray, comparator));
+    }
+    
+    @Test
+    void givenNoCommonPrefixForTheComparator_whenMismatch_thenZero() {
+        String[] firstArray = {"one", "two", "three"};
+        String[] secondArray = {"six", "seven", "eight"};
+        Comparator<String> comparator = String.CASE_INSENSITIVE_ORDER;
+        assertEquals(0, Arrays.mismatch(firstArray, secondArray, comparator));
+    }
+    
+    @Test
+    void givenAtLeastANullArrayOrNullComparator_whenMismatch_thenThrowsNullPointerException() {
+        String[] firstArray = null;
+        String[] secondArray = {"one"};
+        Comparator<String> comparator = String.CASE_INSENSITIVE_ORDER;
+        assertThrows(NullPointerException.class, () -> Arrays.mismatch(firstArray, secondArray, comparator));
+        assertThrows(NullPointerException.class, () -> Arrays.mismatch(secondArray, firstArray, comparator));
+        assertThrows(NullPointerException.class, () -> Arrays.mismatch(secondArray, secondArray, null));
+    }
+    
+    @Test
+    void givenExactlyOneAnEmptyArrayAndAComparator_whenMismatch_thenZero() {
+        String[] firstArray = {};
+        String[] secondArray = {"one"};
+        Comparator<String> comparator = String.CASE_INSENSITIVE_ORDER;
+        assertEquals(0, Arrays.mismatch(firstArray, secondArray, comparator));
+        assertEquals(0, Arrays.mismatch(secondArray, firstArray, comparator));
+    }
+    
+    @Test
+    void givenTwoEmptyStringArraysForTheComparator_whenMismatch_thenMinusOne() {
+        assertEquals(-1, Arrays.mismatch(new String[] {}, new String[] {}, String.CASE_INSENSITIVE_ORDER));
+    }
+    
+    @Test
+    void givenTwoStringSubarraysAndAComparator_whenMismatch_thenIndexOfFirstMismatch() {
+        String[] firstArray = {"one", "two", "three", "four"};
+        String[] secondArray = {"ZERO", "ONE", "TWO", "FOUR", "EIGHT", "SIXTEEN"};
+        Comparator<String> comparator = String.CASE_INSENSITIVE_ORDER;
+        assertEquals(2, Arrays.mismatch(firstArray, 0, 4, secondArray, 1, 3, comparator));
+    }
+   
+    @Test
+    void givenTwoIdenticalStringSubArraysForTheComparator_whenMismatch_thenMinusOne() {
+        String[] firstArray = {"zero", "zero", "one", "two"};
+        String[] secondArray = {"zero", "one", "two", "three", "four"};
+        Comparator<String> comparator = String.CASE_INSENSITIVE_ORDER;
+        assertEquals(-1, Arrays.mismatch(firstArray, 2, 4, secondArray, 1, 3, comparator));
+    }
+    
+    @Test
+    void givenFirstSubArrayIsAPrefixOfTheSecondForTheComparator_whenMismatch_thenFirstArrayLength() {
+        String[] firstArray = {"two", "three", "four", "five", "four", "three", "two"};
+        String[] secondArray = {"ZERO", "ONE", "TWO", "THREE", "FOUR", "FIVE", "EIGHT", "NINE", "TEN"};
+        Comparator<String> comparator = String.CASE_INSENSITIVE_ORDER;
+        assertEquals(4, Arrays.mismatch(firstArray, 0, 4, secondArray, 2, 9, comparator));
+    }
+    
+    @Test
+    void givenNoCommonPrefixForSubArraysForTheComparator_whenMismatch_thenZero() {
+        String[] firstArray = {"zero", "one"};
+        String[] secondArray = {"TEN", "ELEVEN", "TWELVE"};
+        Comparator<String> comparator = String.CASE_INSENSITIVE_ORDER;
+        assertEquals(0, Arrays.mismatch(firstArray, 1, 2, secondArray, 1, 2, comparator));
+    }
+    
+    @Test
+    void givenAtLeastANullSubArrayOrNullComparator_whenMismatch_thenThrowsNullPointerException() {
+        String[] firstArray = null;
+        String[] secondArray = {"ONE", "TWO", "THREE", "FOUR", "FIVE"};
+        Comparator<String> comparator = String.CASE_INSENSITIVE_ORDER;
+        assertThrows(NullPointerException.class, () -> Arrays.mismatch(firstArray, 0, 1, secondArray, 0, 1, comparator));
+        assertThrows(NullPointerException.class, () -> Arrays.mismatch(secondArray, 0, 1, firstArray, 0, 1, comparator));
+        assertThrows(NullPointerException.class, () -> Arrays.mismatch(firstArray, 0, 1, firstArray, 0, 1, comparator));
+        assertThrows(NullPointerException.class, () -> Arrays.mismatch(secondArray, 0, 1, secondArray, 0, 1, null));
+    }
+    
+    @Test
+    void givenExactlyOneEmptySubArrayAndAComparator_whenMismatch_thenZero() {
+        String[] firstArray = {"one"};
+        String[] secondArray = {"ONE", "TWO", "THREE"};
+        Comparator<String> comparator = String.CASE_INSENSITIVE_ORDER;
+        assertEquals(0, Arrays.mismatch(firstArray, 0, 0, secondArray, 0, 2, comparator));
+        assertEquals(0, Arrays.mismatch(firstArray, 0, 1, secondArray, 2, 2, comparator));
+    }
+    
+    @Test
+    void givenTwoEmptySubArraysAndAComparator_whenMismatch_thenMinusOne() {
+        String[] firstArray = {"one"};
+        String[] secondArray = {"ONE", "TWO", "THREE"};
+        Comparator<String> comparator = String.CASE_INSENSITIVE_ORDER;
+        assertEquals(-1, Arrays.mismatch(firstArray, 0, 0, secondArray, 2, 2, comparator));
+    }
+    
+    @Test
+    void givenToIndexGreaterThanFromIndexAndAComparator_whenMismatch_thenThrowsIllegalArgumentException() {
+        String[] firstArray = {"two", "three", "four", "five", "four", "three", "two"};
+        String[] secondArray = {"ZERO", "ONE", "TWO", "THREE", "FOUR", "FIVE", "EIGHT", "NINE", "TEN"};
+        Comparator<String> comparator = String.CASE_INSENSITIVE_ORDER;
+        assertThrows(IllegalArgumentException.class, () -> Arrays.mismatch(firstArray, 4, 2, secondArray, 0, 6, comparator));
+        assertThrows(IllegalArgumentException.class, () -> Arrays.mismatch(firstArray, 2, 3, secondArray, 6, 0, comparator));
+    }
+    
+    @Test
+    void givenIllegalIndexesAndAComparator_whenMismatch_thenThrowsArrayIndexOutOfBoundsException() {
+        String[] firstArray = {"two", "three", "four", "five", "four", "three", "two"};
+        String[] secondArray = {"ZERO", "ONE", "TWO", "THREE", "FOUR", "FIVE", "EIGHT", "NINE", "TEN"};
+        Comparator<String> comparator = String.CASE_INSENSITIVE_ORDER;
+        assertThrows(ArrayIndexOutOfBoundsException.class, () -> Arrays.mismatch(firstArray, -1, 2, secondArray, 0, 6, comparator));
+        assertThrows(ArrayIndexOutOfBoundsException.class, () -> Arrays.mismatch(firstArray, 0, 8, secondArray, 0, 6, comparator));
+        assertThrows(ArrayIndexOutOfBoundsException.class, () -> Arrays.mismatch(firstArray, 2, 3, secondArray, -5, 0, comparator));
+        assertThrows(ArrayIndexOutOfBoundsException.class, () -> Arrays.mismatch(firstArray, 2, 3, secondArray, 11, 12, comparator));
+    }
+
+}
@@ -7,4 +7,5 @@
 - [Creating Custom Iterator in Java](https://www.baeldung.com/java-creating-custom-iterator)
 - [Difference Between Arrays.sort() and Collections.sort()](https://www.baeldung.com/java-arrays-collections-sort-methods)
 - [Skipping the First Iteration in Java](https://www.baeldung.com/java-skip-first-iteration)
+- [Remove Elements From a Queue Using Loop](https://www.baeldung.com/java-remove-elements-queue)
 - More articles: [[<-- prev]](/core-java-modules/core-java-collections-4)
@@ -12,7 +12,7 @@ public class RemoveQueueElementsUnitTest {
    @Test
    public void givenQueueWithEvenAndOddNumbers_whenRemovingEvenNumbers_thenOddNumbersRemain() {
        Queue<Integer> queue = new LinkedList<>();
-        Queue<Integer> evenElementsQueue = new LinkedList<>();
+        Queue<Integer> oddElementsQueue = new LinkedList<>();
        queue.add(1);
        queue.add(2);
        queue.add(3);
@@ -22,14 +22,14 @@ public class RemoveQueueElementsUnitTest {
        while (queue.peek() != null) {
            int element = queue.remove();
            if (element % 2 != 0) {
-                evenElementsQueue.add(element);
+                oddElementsQueue.add(element);
            }
        }

-        assertEquals(3, evenElementsQueue.size());
-        assertTrue(evenElementsQueue.contains(1));
-        assertTrue(evenElementsQueue.contains(3));
-        assertTrue(evenElementsQueue.contains(5));
+        assertEquals(3, oddElementsQueue.size());
+        assertTrue(oddElementsQueue.contains(1));
+        assertTrue(oddElementsQueue.contains(3));
+        assertTrue(oddElementsQueue.contains(5));
    }

    @Test
@@ -1,2 +1,3 @@
 ## Relevant Articles
 - [Difference Between putIfAbsent() and computeIfAbsent() in Java’s Map](https://www.baeldung.com/java-map-putifabsent-computeifabsent)
+- [How to Write Hashmap to CSV File](https://www.baeldung.com/java-write-hashmap-csv)
@@ -0,0 +1,3 @@
+
+### Relevant Articles:
+- [Why wait() Requires Synchronization?](https://www.baeldung.com/java-wait-necessary-synchronization)
@@ -10,4 +10,5 @@ This module contains articles about basic Java concurrency.
 - [Returning a Value After Finishing Thread’s Job in Java](https://www.baeldung.com/java-return-value-after-thread-finish)
 - [CompletableFuture and ThreadPool in Java](https://www.baeldung.com/java-completablefuture-threadpool)
 - [CompletableFuture allOf().join() vs. CompletableFuture.join()](https://www.baeldung.com/java-completablefuture-allof-join)
+- [Retry Logic with CompletableFuture](https://www.baeldung.com/java-completablefuture-retry-logic)
 - [[<-- Prev]](../core-java-concurrency-basic-2)
@@ -0,0 +1,63 @@
+package com.baeldung.concurrent.completablefuture.retry;
+
+import java.util.concurrent.CompletableFuture;
+import java.util.function.Function;
+import java.util.function.Supplier;
+
+public class RetryCompletableFuture {
+    public static <T> CompletableFuture<T> retryTask(Supplier<T> supplier, int maxRetries) {
+        Supplier<T> retryableSupplier = retryFunction(supplier, maxRetries);
+        return CompletableFuture.supplyAsync(retryableSupplier);
+    }
+
+    static <T> Supplier<T> retryFunction(Supplier<T> supplier, int maxRetries) {
+        return () -> {
+            int retries = 0;
+            while (retries < maxRetries) {
+                try {
+                    return supplier.get();
+                } catch (Exception e) {
+                    retries++;
+                }
+            }
+            throw new IllegalStateException(String.format("Task failed after %s attempts", maxRetries));
+        };
+    }
+
+    public static <T> CompletableFuture<T> retryUnsafe(Supplier<T> supplier, int maxRetries) {
+        CompletableFuture<T> cf = CompletableFuture.supplyAsync(supplier);
+        sleep(100l);
+        for (int i = 0; i < maxRetries; i++) {
+            cf = cf.exceptionally(__ -> supplier.get());
+        }
+        return cf;
+    }
+
+    public static <T> CompletableFuture<T> retryNesting(Supplier<T> supplier, int maxRetries) {
+        CompletableFuture<T> cf = CompletableFuture.supplyAsync(supplier);
+        sleep(100);
+        for (int i = 0; i < maxRetries; i++) {
+            cf = cf.thenApply(CompletableFuture::completedFuture)
+              .exceptionally(__ -> CompletableFuture.supplyAsync(supplier))
+              .thenCompose(Function.identity());
+        }
+        return cf;
+    }
+
+    public static <T> CompletableFuture<T> retryExceptionallyAsync(Supplier<T> supplier, int maxRetries) {
+        CompletableFuture<T> cf = CompletableFuture.supplyAsync(supplier);
+        sleep(100);
+        for (int i = 0; i < maxRetries; i++) {
+            cf = cf.exceptionallyAsync(__ -> supplier.get());
+        }
+        return cf;
+    }
+
+    private static void sleep(long millis) {
+        try {
+            Thread.sleep(millis);
+        } catch (InterruptedException e) {
+            throw new RuntimeException(e);
+        }
+    }
+}
@@ -0,0 +1,100 @@
+package com.baeldung.concurrent.completablefuturelist;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.Executors;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.stream.Collectors;
+
+public class Application {
+
+    ScheduledExecutorService asyncOperationEmulation;
+
+    Application initialize() {
+        asyncOperationEmulation = Executors.newScheduledThreadPool(10);
+        return this;
+    }
+
+    CompletableFuture<String> asyncOperation(String operationId) {
+        CompletableFuture<String> cf = new CompletableFuture<>();
+        asyncOperationEmulation.submit(() -> {
+            // The following lines simulate an exception happening on the 567th operation
+            //  if (operationId.endsWith("567")) {
+            //      cf.completeExceptionally(new Exception("Error on operation " + operationId));
+            //      return;
+            //  }
+            try {
+                Thread.sleep(100);
+                cf.complete(operationId);
+            } catch (InterruptedException e) {
+                System.err.println("Thread interrupted error");
+                cf.completeExceptionally(e);
+            }
+        });
+        return cf;
+    }
+
+    void startNaive() {
+        List<CompletableFuture<String>> futures = new ArrayList<>();
+        for (int i = 1; i <= 1000; i++) {
+            String operationId = "Naive-Operation-" + i;
+            futures.add(asyncOperation(operationId));
+        }
+
+        CompletableFuture<List<String>> aggregate = CompletableFuture.completedFuture(new ArrayList<>());
+        for (CompletableFuture<String> future : futures) {
+            aggregate = aggregate.thenCompose(list -> {
+                try {
+                    list.add(future.get());
+                    return CompletableFuture.completedFuture(list);
+                } catch (Exception e) {
+                    final CompletableFuture<List<String>> excFuture = new CompletableFuture<>();
+                    excFuture.completeExceptionally(e);
+                    return excFuture;
+                }
+            });
+        }
+
+        try {
+            final List<String> results = aggregate.join();
+            System.out.println("Printing first 10 results");
+            for (int i = 0; i < 10; i++) {
+                System.out.println("Finished " + results.get(i));
+            }
+        } finally {
+            close();
+        }
+    }
+
+    void start() {
+        List<CompletableFuture<String>> futures = new ArrayList<>();
+        for (int i = 1; i <= 1000; i++) {
+            String operationId = "Operation-" + i;
+            futures.add(asyncOperation(operationId));
+        }
+        CompletableFuture<?>[] futuresArray = futures.toArray(new CompletableFuture<?>[0]);
+        CompletableFuture<List<String>> listFuture = CompletableFuture.allOf(futuresArray).thenApply(v -> futures.stream().map(CompletableFuture::join).collect(Collectors.toList()));
+        try {
+            final List<String> results = listFuture.join();
+            System.out.println("Printing first 10 results");
+            for (int i = 0; i < 10; i++) {
+                System.out.println("Finished " + results.get(i));
+            }
+        } finally {
+            close();
+        }
+    }
+
+    void close() {
+        asyncOperationEmulation.shutdownNow();
+    }
+
+    public static void main(String[] args) {
+        new Application().initialize()
+        // Switch between .startNaive() and .start() to test both implementations
+        //  .startNaive();
+          .start();
+    }
+
+}
@@ -0,0 +1,120 @@
+package com.baeldung.concurrent.completablefuture.retry;
+
+import static com.baeldung.concurrent.completablefuture.retry.RetryCompletableFuture.retryExceptionallyAsync;
+import static com.baeldung.concurrent.completablefuture.retry.RetryCompletableFuture.retryNesting;
+import static com.baeldung.concurrent.completablefuture.retry.RetryCompletableFuture.retryTask;
+import static com.baeldung.concurrent.completablefuture.retry.RetryCompletableFuture.retryUnsafe;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.CompletionException;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.function.Supplier;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+class RetryCompletableFutureUnitTest {
+    private AtomicInteger retriesCounter = new AtomicInteger(0);
+
+    @BeforeEach
+    void beforeEach() {
+        retriesCounter.set(0);
+    }
+
+    @Test
+    void whenRetryingTask_thenReturnsCorrectlyAfterFourInvocations() {
+        Supplier<Integer> codeToRun = () -> failFourTimesThenReturn(100);
+
+        CompletableFuture<Integer> result = retryTask(codeToRun, 10);
+
+        assertThat(result.join()).isEqualTo(100);
+        assertThat(retriesCounter).hasValue(4);
+    }
+
+    @Test
+    void whenRetryingTask_thenThrowsExceptionAfterThreeInvocations() {
+        Supplier<Integer> codeToRun = () -> failFourTimesThenReturn(100);
+
+        CompletableFuture<Integer> result = retryTask(codeToRun, 3);
+
+        assertThatThrownBy(result::join)
+          .isInstanceOf(CompletionException.class)
+          .hasMessageContaining("IllegalStateException: Task failed after 3 attempts");
+    }
+
+    @Test
+    void whenRetryingExceptionally_thenReturnsCorrectlyAfterFourInvocations() {
+        Supplier<Integer> codeToRun = () -> failFourTimesThenReturn(100);
+
+        CompletableFuture<Integer> result = retryUnsafe(codeToRun, 10);
+
+        assertThat(result.join()).isEqualTo(100);
+        assertThat(retriesCounter).hasValue(4);
+    }
+
+    @Test
+    void whenRetryingExceptionally_thenThrowsExceptionAfterThreeInvocations() {
+        Supplier<Integer> codeToRun = () -> failFourTimesThenReturn(100);
+
+        CompletableFuture<Integer> result = retryUnsafe(codeToRun, 3);
+
+        assertThatThrownBy(result::join)
+          .isInstanceOf(CompletionException.class)
+          .hasMessageContaining("RuntimeException: task failed for 3 time(s)");
+    }
+
+    @Test
+    void whenRetryingExceptionallyAsync_thenReturnsCorrectlyAfterFourInvocations() {
+        Supplier<Integer> codeToRun = () -> failFourTimesThenReturn(100);
+
+        CompletableFuture<Integer> result = retryExceptionallyAsync(codeToRun, 10);
+
+        assertThat(result.join()).isEqualTo(100);
+        assertThat(retriesCounter).hasValue(4);
+    }
+
+    @Test
+    void whenRetryingExceptionallyAsync_thenThrowsExceptionAfterThreeInvocations() {
+        Supplier<Integer> codeToRun = () -> failFourTimesThenReturn(100);
+
+        CompletableFuture<Integer> result = retryExceptionallyAsync(codeToRun, 3);
+
+        assertThatThrownBy(result::join)
+          .isInstanceOf(CompletionException.class)
+          .hasMessageContaining("RuntimeException: task failed for 3 time(s)");
+    }
+
+    @Test
+    void whenRetryingNesting_thenReturnsCorrectlyAfterFourInvocations() {
+        Supplier<Integer> codeToRun = () -> failFourTimesThenReturn(100);
+
+        CompletableFuture<Integer> result = retryNesting(codeToRun, 10);
+
+        assertThat(result.join()).isEqualTo(100);
+        assertThat(retriesCounter).hasValue(4);
+    }
+
+    @Test
+    void whenRetryingNesting_thenThrowsExceptionAfterThreeInvocations() {
+        Supplier<Integer> codeToRun = () -> failFourTimesThenReturn(100);
+
+        CompletableFuture<Integer> result = retryNesting(codeToRun, 3);
+
+        assertThatThrownBy(result::join)
+          .isInstanceOf(CompletionException.class)
+          .hasMessageContaining("RuntimeException: task failed for 3 time(s)");
+    }
+
+    int failFourTimesThenReturn(int returnValue) {
+        int retryNr = retriesCounter.get();
+        System.out.println(String.format("invocation: %s, thread: %s", retryNr, Thread.currentThread().getName()));
+        if (retryNr < 4) {
+            retriesCounter.set(retryNr + 1);
+            throw new RuntimeException(String.format("task failed for %s time(s)", retryNr));
+        }
+        return returnValue;
+    }
+
+}
@@ -12,6 +12,7 @@ This module contains articles about Java Concurrency that are also part of an Eb
 - [Guide to the Volatile Keyword in Java](https://www.baeldung.com/java-volatile)
 - [A Guide to the Java ExecutorService](https://www.baeldung.com/java-executor-service-tutorial)
 - [Guide To CompletableFuture](https://www.baeldung.com/java-completablefuture)
+- [How To Manage Timeout for CompletableFuture](https://www.baeldung.com/java-completablefuture-timeout)

 ### NOTE:

@@ -12,6 +12,15 @@
        <version>0.0.1-SNAPSHOT</version>
    </parent>

+    <dependencies>
+        <dependency>
+            <groupId>org.wiremock</groupId>
+            <artifactId>wiremock</artifactId>
+            <version>3.1.0</version>
+            <scope>test</scope>
+        </dependency>
+    </dependencies>
+
    <build>
        <finalName>core-java-concurrency-simple</finalName>
        <resources>
@@ -0,0 +1,182 @@
+package com.baeldung.concurrent.completablefuture;
+
+import com.github.tomakehurst.wiremock.WireMockServer;
+import com.github.tomakehurst.wiremock.client.WireMock;
+import org.junit.jupiter.api.AfterAll;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.TestInstance;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.net.HttpURLConnection;
+import java.net.URL;
+import java.util.concurrent.*;
+
+import static com.github.tomakehurst.wiremock.client.WireMock.*;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+@TestInstance(TestInstance.Lifecycle.PER_CLASS)
+class CompletableFutureTimeoutUnitTest {
+    private WireMockServer wireMockServer;
+    private ScheduledExecutorService executorService;
+    private static final int DEFAULT_TIMEOUT = 1000; //1 seconds
+    private static final String DEFAULT_PRODUCT = """
+            {
+              "products": [
+                {
+                  "id": 2,
+                  "title": "iPhone X",
+                  "description": "SIM-Free, Model A19211 6.5-inch Super Retina HD display with OLED technology A12 Bionic chip with ...",
+                  "price": 899,
+                  "discountPercentage": 0.0,
+                  "rating": 4.44,
+                  "stock": 34,
+                  "brand": "Apple",
+                  "category": "smartphones"
+                },
+                {
+                  "id": 3,
+                  "title": "Samsung Universe 9",
+                  "description": "Samsung's new variant which goes beyond Galaxy to the Universe",
+                  "price": 1249,
+                  "discountPercentage": 0.0,
+                  "rating": 4.09,
+                  "stock": 36,
+                  "brand": "Samsung",
+                  "category": "smartphones"
+                }
+              ],
+              "total": 2
+            }""";
+    private static final String PRODUCT_OFFERS = """
+            {
+              "products": [
+                {
+                  "id": 1,
+                  "title": "iPhone 9",
+                  "description": "An apple mobile which is nothing like apple",
+                  "price": 549,
+                  "discountPercentage": 12.96,
+                  "rating": 4.69,
+                  "stock": 94,
+                  "brand": "Apple",
+                  "category": "smartphones"
+                },
+                {
+                  "id": 2,
+                  "title": "iPhone X",
+                  "description": "SIM-Free, Model A19211 6.5-inch Super Retina HD display with OLED technology A12 Bionic chip with ...",
+                  "price": 899,
+                  "discountPercentage": 17.94,
+                  "rating": 4.44,
+                  "stock": 34,
+                  "brand": "Apple",
+                  "category": "smartphones"
+                },
+                {
+                  "id": 3,
+                  "title": "Samsung Universe 9",
+                  "description": "Samsung's new variant which goes beyond Galaxy to the Universe",
+                  "price": 1249,
+                  "discountPercentage": 15.46,
+                  "rating": 4.09,
+                  "stock": 36,
+                  "brand": "Samsung",
+                  "category": "smartphones"
+                },
+                {
+                  "id": 4,
+                  "title": "OPPOF19",
+                  "description": "OPPO F19 is officially announced on April 2021.",
+                  "price": 280,
+                  "discountPercentage": 17.91,
+                  "rating": 4.3,
+                  "stock": 123,
+                  "brand": "OPPO",
+                  "category": "smartphones"
+                },
+                {
+                  "id": 5,
+                  "title": "Huawei P30",
+                  "description": "Huawei’s re-badged P30 Pro New Edition was officially unveiled yesterday in Germany and now the device has made its way to the UK.",
+                  "price": 499,
+                  "discountPercentage": 10.58,
+                  "rating": 4.09,
+                  "stock": 32,
+                  "brand": "Huawei",
+                  "category": "smartphones"
+                }
+              ],
+              "total": 5
+            }""";
+
+    @BeforeAll
+    void setUp() {
+        wireMockServer = new WireMockServer(8080);
+        wireMockServer.start();
+        WireMock.configureFor("localhost", 8080);
+
+        stubFor(get(urlEqualTo("/api/dummy"))
+                .willReturn(aResponse()
+                        .withFixedDelay(5000) // must be > DEFAULT_TIMEOUT for a timeout to occur.
+                        .withBody(PRODUCT_OFFERS)));
+
+        executorService = Executors.newScheduledThreadPool(1);
+    }
+
+    @AfterAll
+    void tearDown() {
+        executorService.shutdown();
+        wireMockServer.stop();
+    }
+
+    private CompletableFuture<String> fetchProductData() {
+        return CompletableFuture.supplyAsync(() -> {
+            try {
+                URL url = new URL("http://localhost:8080/api/dummy");
+                HttpURLConnection connection = (HttpURLConnection) url.openConnection();
+
+                try (BufferedReader in = new BufferedReader(new InputStreamReader(connection.getInputStream()))) {
+                    String inputLine;
+                    StringBuffer response = new StringBuffer();
+
+                    while ((inputLine = in.readLine()) != null) {
+                        response.append(inputLine);
+                    }
+
+                    return response.toString();
+                } finally {
+                    connection.disconnect();
+                }
+            } catch (IOException e) {
+                return "";
+            }
+        });
+    }
+
+
+    @Test
+    void whenorTimeout_thenGetThrow() {
+        CompletableFuture<String> productDataFuture = fetchProductData();
+        productDataFuture.orTimeout(DEFAULT_TIMEOUT, TimeUnit.MILLISECONDS);
+        assertThrows(ExecutionException.class, productDataFuture::get);
+    }
+
+    @Test
+    void whencompleteOnTimeout_thenReturnValue() throws ExecutionException, InterruptedException {
+        CompletableFuture<String> productDataFuture = fetchProductData();
+        productDataFuture.completeOnTimeout(DEFAULT_PRODUCT, DEFAULT_TIMEOUT, TimeUnit.MILLISECONDS);
+        assertEquals(DEFAULT_PRODUCT, productDataFuture.get());
+    }
+
+    @Test
+    void whencompleteExceptionally_thenGetThrow() {
+        CompletableFuture<String> productDataFuture = fetchProductData();
+        executorService.schedule(() -> productDataFuture
+                .completeExceptionally(new TimeoutException("Timeout occurred")), DEFAULT_TIMEOUT, TimeUnit.MILLISECONDS);
+        assertThrows(ExecutionException.class, productDataFuture::get);
+    }
+}
@@ -0,0 +1,61 @@
+package com.baeldung.firstdaymonth;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import java.time.LocalDate;
+import java.time.YearMonth;
+import java.time.temporal.TemporalAdjusters;
+import java.util.Calendar;
+import java.util.Date;
+import java.util.GregorianCalendar;
+
+import org.junit.jupiter.api.Test;
+
+public class FirstDayOfMonthUnitTest {
+
+    @Test
+    void givenMonth_whenUsingCalendar_thenReturnFirstDay() {
+        Date currentDate = new GregorianCalendar(2023, Calendar.NOVEMBER, 23).getTime();
+        Date expectedDate = new GregorianCalendar(2023, Calendar.NOVEMBER, 1).getTime();
+
+        Calendar cal = Calendar.getInstance();
+        cal.setTime(currentDate);
+        cal.set(Calendar.DAY_OF_MONTH, 1);
+
+        assertEquals(expectedDate, cal.getTime());
+    }
+
+    @Test
+    void givenMonth_whenUsingLocalDate_thenReturnFirstDay() {
+        LocalDate currentDate = LocalDate.of(2023, 9, 6);
+        LocalDate expectedDate = LocalDate.of(2023, 9, 1);
+
+        assertEquals(expectedDate, currentDate.withDayOfMonth(1));
+    }
+
+    @Test
+    void givenMonth_whenUsingTemporalAdjusters_thenReturnFirstDay() {
+        LocalDate currentDate = LocalDate.of(2023, 7, 19);
+        LocalDate expectedDate = LocalDate.of(2023, 7, 1);
+
+        assertEquals(expectedDate, currentDate.with(TemporalAdjusters.firstDayOfMonth()));
+    }
+
+    @Test
+    void givenMonth_whenUsingYearMonth_thenReturnFirstDay() {
+        YearMonth currentDate = YearMonth.of(2023, 4);
+        LocalDate expectedDate = LocalDate.of(2023, 4, 1);
+
+        assertEquals(expectedDate, currentDate.atDay(1));
+    }
+
+    @Test
+    void givenMonth_whenUsingJodaTime_thenReturnFirstDay() {
+        org.joda.time.LocalDate currentDate = org.joda.time.LocalDate.parse("2023-5-10");
+        org.joda.time.LocalDate expectedDate = org.joda.time.LocalDate.parse("2023-5-1");
+
+        assertEquals(expectedDate, currentDate.dayOfMonth()
+          .withMinimumValue());
+    }
+
+}
@@ -35,6 +35,21 @@
            <artifactId>simplemagic</artifactId>
            <version>${simplemagic.version}</version>
        </dependency>
+        <dependency>
+            <groupId>commons-io</groupId>
+            <artifactId>commons-io</artifactId>
+            <version>${commons-io.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.openjdk.jmh</groupId>
+            <artifactId>jmh-core</artifactId>
+            <version>${jmh.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.openjdk.jmh</groupId>
+            <artifactId>jmh-generator-annprocess</artifactId>
+            <version>${jmh.version}</version>
+        </dependency>
    </dependencies>

    <build>
@@ -62,5 +77,6 @@
        <jmime-magic.version>0.1.5</jmime-magic.version>
        <jodd-util.version>6.2.1</jodd-util.version>
        <simplemagic.version>1.17</simplemagic.version>
+        <jmh.version>1.37</jmh.version>
    </properties>
 </project>
@@ -0,0 +1,112 @@
+package com.baeldung.zip;
+
+import java.io.*;
+import java.util.concurrent.TimeUnit;
+import java.util.*;
+import java.util.zip.*;
+
+import org.openjdk.jmh.annotations.*;
+import org.openjdk.jmh.infra.Blackhole;
+import org.openjdk.jmh.runner.Runner;
+import org.openjdk.jmh.runner.options.Options;
+import org.openjdk.jmh.runner.options.OptionsBuilder;
+
+@State(Scope.Benchmark)
+@BenchmarkMode(Mode.AverageTime)
+@Warmup(iterations = 1, time = 2, timeUnit = TimeUnit.SECONDS)
+@Measurement(iterations = 3, time = 1, timeUnit = TimeUnit.SECONDS)
+@OutputTimeUnit(TimeUnit.MILLISECONDS)
+@Fork(value = 1)
+public class ZipBenchmark {
+
+    public static final int NUM_OF_FILES = 10;
+    public static final int DATA_SIZE = 204800;
+
+    @State(Scope.Thread)
+    public static class SourceState {
+
+        public File compressedFile;
+
+        @Setup(Level.Trial)
+        public void setup() throws IOException {
+            ZipSampleFileStore sampleFileStore = new ZipSampleFileStore(NUM_OF_FILES, DATA_SIZE);
+            compressedFile = sampleFileStore.getFile();
+        }
+
+        @TearDown(Level.Trial)
+        public void cleanup() {
+            if (compressedFile.exists()) {
+                compressedFile.delete();
+            }
+        }
+    }
+
+    @Benchmark
+    public static void readAllEntriesByZipFile(SourceState sourceState, Blackhole blackhole) throws IOException {
+
+        try (ZipFile zipFile = new ZipFile(sourceState.compressedFile)) {
+            Enumeration<? extends ZipEntry> zipEntries = zipFile.entries();
+            while (zipEntries.hasMoreElements())  {
+                ZipEntry zipEntry = zipEntries.nextElement();
+                try (InputStream inputStream = new BufferedInputStream(zipFile.getInputStream(zipEntry))) {
+                    blackhole.consume(ZipSampleFileStore.getString(inputStream));
+                }
+            }
+        }
+    }
+
+    @Benchmark
+    public static void readAllEntriesByZipInputStream(SourceState sourceState, Blackhole blackhole) throws IOException {
+
+        try (
+            BufferedInputStream bis = new BufferedInputStream(new FileInputStream(sourceState.compressedFile));
+            ZipInputStream zipInputStream = new ZipInputStream(bis)
+        ) {
+            ZipEntry entry;
+            while ((entry = zipInputStream.getNextEntry()) != null) {
+                blackhole.consume(ZipSampleFileStore.getString(zipInputStream));
+            }
+        }
+    }
+
+    @Benchmark
+    public static void readLastEntryByZipFile(SourceState sourceState, Blackhole blackhole) throws IOException {
+
+        try (ZipFile zipFile = new ZipFile(sourceState.compressedFile)) {
+           ZipEntry zipEntry = zipFile.getEntry(getLastEntryName());
+            try (InputStream inputStream = new BufferedInputStream(zipFile.getInputStream(zipEntry))) {
+                blackhole.consume(ZipSampleFileStore.getString(inputStream));
+            }
+        }
+    }
+
+    @Benchmark
+    public static void readLastEntryByZipInputStream(SourceState sourceState, Blackhole blackhole) throws IOException {
+
+        try (
+            BufferedInputStream bis = new BufferedInputStream(new FileInputStream(sourceState.compressedFile));
+            ZipInputStream zipInputStream = new ZipInputStream(bis)
+        ) {
+            ZipEntry entry;
+            while ((entry = zipInputStream.getNextEntry()) != null) {
+                if (Objects.equals(entry.getName(), getLastEntryName())){
+                    blackhole.consume(ZipSampleFileStore.getString(zipInputStream));
+                }
+            }
+        }
+    }
+
+    private static String getLastEntryName() {
+        return String.format(ZipSampleFileStore.ENTRY_NAME_PATTERN, NUM_OF_FILES);
+    }
+
+    public static void main(String[] args) throws Exception {
+        Options options = new OptionsBuilder()
+          .include(ZipBenchmark.class.getSimpleName()).threads(1)
+          .shouldFailOnError(true)
+          .shouldDoGC(true)
+          .jvmArgs("-server").build();
+        new Runner(options).run();
+    }
+
+}
@@ -0,0 +1,70 @@
+package com.baeldung.zip;
+
+import java.io.*;
+import java.nio.charset.Charset;
+import java.nio.charset.StandardCharsets;
+import java.util.*;
+import java.util.zip.ZipEntry;
+import java.util.zip.ZipOutputStream;
+
+import org.apache.commons.io.IOUtils;
+
+public class ZipSampleFileStore {
+
+    public static final String ENTRY_NAME_PATTERN = "str-data-%s.txt";
+    private static final Charset DEFAULT_ENCODING = StandardCharsets.UTF_8;
+
+    private final File file;
+    private final List<String> dataList;
+
+    public ZipSampleFileStore(int numOfFiles, int fileSize) throws IOException {
+
+        dataList = new ArrayList<>(numOfFiles);
+        file = File.createTempFile("zip-sample", "");
+
+        try (ZipOutputStream zos = new ZipOutputStream(new FileOutputStream(file))) {
+
+            for (int idx=0; idx<=numOfFiles; idx++) {
+
+                byte[] data = createRandomStringInByte(fileSize);
+                dataList.add(new String(data, DEFAULT_ENCODING));
+
+                ZipEntry entry = new ZipEntry(String.format(ENTRY_NAME_PATTERN, idx));
+                zos.putNextEntry(entry);
+                zos.write(data);
+                zos.closeEntry();
+            }
+        }
+    }
+
+    public static byte[] createRandomStringInByte(int size) {
+        Random random = new Random();
+        byte[] data = new byte[size];
+        for (int n = 0; n < data.length; n++) {
+            char randomChar;
+            int choice = random.nextInt(2); // 0 for uppercase, 1 for lowercase
+            if (choice == 0) {
+                randomChar = (char) ('A' + random.nextInt(26)); // 'A' to 'Z'
+            } else {
+                randomChar = (char) ('a' + random.nextInt(26)); // 'a' to 'z'
+            }
+            data[n] = (byte) randomChar;
+        }
+        return data;
+    }
+
+    public File getFile() {
+        return file;
+    }
+
+    public List<String> getDataList() {
+        return dataList;
+    }
+
+    public static String getString(InputStream inputStream) throws IOException {
+        ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
+        IOUtils.copy(inputStream, byteArrayOutputStream);
+        return byteArrayOutputStream.toString(DEFAULT_ENCODING);
+    }
+
+}
--- a/Show More
+++ b/Show More