Merge remote-tracking branch 'upstream/master'

algorithms-miscellaneous-2/src/main/java/com/baeldung/algorithms/play2048/Board.java

@@ -0,0 +1,208 @@
+package com.baeldung.algorithms.play2048;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.LinkedList;
+import java.util.List;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class Board {
+    private static final Logger LOG = LoggerFactory.getLogger(Board.class);
+
+    private final int[][] board;
+
+    private final int score;
+
+    public Board(int size) {
+        assert(size > 0);
+
+        this.board = new int[size][];
+        this.score = 0;
+
+        for (int x = 0; x < size; ++x) {
+            this.board[x] = new int[size];
+            for (int y = 0; y < size; ++y) {
+                board[x][y] = 0;
+            }
+        }
+    }
+
+    private Board(int[][] board, int score) {
+        this.score = score;
+        this.board = new int[board.length][];
+
+        for (int x = 0; x < board.length; ++x) {
+            this.board[x] = Arrays.copyOf(board[x], board[x].length);
+        }
+    }
+
+    public int getSize() {
+        return board.length;
+    }
+
+    public int getScore() {
+        return score;
+    }
+
+    public int getCell(Cell cell) {
+        int x = cell.getX();
+        int y = cell.getY();
+        assert(x >= 0 && x < board.length);
+        assert(y >= 0 && y < board.length);
+
+        return board[x][y];
+    }
+
+    public boolean isEmpty(Cell cell) {
+        return getCell(cell) == 0;
+    }
+
+    public List<Cell> emptyCells() {
+        List<Cell> result = new ArrayList<>();
+        for (int x = 0; x < board.length; ++x) {
+            for (int y = 0; y < board[x].length; ++y) {
+                Cell cell = new Cell(x, y);
+                if (isEmpty(cell)) {
+                    result.add(cell);
+                }
+            }
+        }
+        return result;
+    }
+
+    public Board placeTile(Cell cell, int number) {
+        if (!isEmpty(cell)) {
+            throw new IllegalArgumentException("That cell is not empty");
+        }
+
+        Board result = new Board(this.board, this.score);
+        result.board[cell.getX()][cell.getY()] = number;
+        return result;
+    }
+
+    public Board move(Move move) {
+        // Clone the board
+        int[][] tiles = new int[this.board.length][];
+        for (int x = 0; x < this.board.length; ++x) {
+            tiles[x] = Arrays.copyOf(this.board[x], this.board[x].length);
+        }
+
+        LOG.debug("Before move: {}", Arrays.deepToString(tiles));
+        // If we're doing an Left/Right move then transpose the board to make it a Up/Down move
+        if (move == Move.LEFT || move == Move.RIGHT) {
+            tiles = transpose(tiles);
+            LOG.debug("After transpose: {}", Arrays.deepToString(tiles));
+        }
+        // If we're doing a Right/Down move then reverse the board.
+        // With the above we're now always doing an Up move
+        if (move == Move.DOWN || move == Move.RIGHT) {
+            tiles = reverse(tiles);
+            LOG.debug("After reverse: {}", Arrays.deepToString(tiles));
+        }
+        LOG.debug("Ready to move: {}", Arrays.deepToString(tiles));
+
+        // Shift everything up
+        int[][] result = new int[tiles.length][];
+        int newScore = 0;
+        for (int x = 0; x < tiles.length; ++x) {
+            LinkedList<Integer> thisRow = new LinkedList<>();
+            for (int y = 0; y < tiles[0].length; ++y) {
+                if (tiles[x][y] > 0) {
+                    thisRow.add(tiles[x][y]);
+                }
+            }
+
+            LOG.debug("Unmerged row: {}", thisRow);
+            LinkedList<Integer> newRow = new LinkedList<>();
+            while (thisRow.size() >= 2) {
+                int first = thisRow.pop();
+                int second = thisRow.peek();
+                LOG.debug("Looking at numbers {} and {}", first, second);
+                if (second == first) {
+                    LOG.debug("Numbers match, combining");
+                    int newNumber = first * 2;
+                    newRow.add(newNumber);
+                    newScore += newNumber;
+                    thisRow.pop();
+                } else {
+                    LOG.debug("Numbers don't match");
+                    newRow.add(first);
+                }
+            }
+            newRow.addAll(thisRow);
+            LOG.debug("Merged row: {}", newRow);
+
+            result[x] = new int[tiles[0].length];
+            for (int y = 0; y < tiles[0].length; ++y) {
+                if (newRow.isEmpty()) {
+                    result[x][y] = 0;
+                } else {
+                    result[x][y] = newRow.pop();
+                }
+            }
+        }
+        LOG.debug("After moves: {}", Arrays.deepToString(result));
+
+        // Un-reverse the board
+        if (move == Move.DOWN || move == Move.RIGHT) {
+            result = reverse(result);
+            LOG.debug("After reverse: {}", Arrays.deepToString(result));
+        }
+        // Un-transpose the board
+        if (move == Move.LEFT || move == Move.RIGHT) {
+            result = transpose(result);
+            LOG.debug("After transpose: {}", Arrays.deepToString(result));
+        }
+        return new Board(result, this.score + newScore);
+    }
+
+    private static int[][] transpose(int[][] input) {
+        int[][] result = new int[input.length][];
+
+        for (int x = 0; x < input.length; ++x) {
+            result[x] = new int[input[0].length];
+            for (int y = 0; y < input[0].length; ++y) {
+                result[x][y] = input[y][x];
+            }
+        }
+
+        return result;
+    }
+
+    private static int[][] reverse(int[][] input) {
+        int[][] result = new int[input.length][];
+
+        for (int x = 0; x < input.length; ++x) {
+            result[x] = new int[input[0].length];
+            for (int y = 0; y < input[0].length; ++y) {
+                result[x][y] = input[x][input.length - y - 1];
+            }
+        }
+
+        return result;
+    }
+
+    @Override
+    public String toString() {
+        return Arrays.deepToString(board);
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) {
+            return true;
+        }
+        if (o == null || getClass() != o.getClass()) {
+            return false;
+        }
+        Board board1 = (Board) o;
+        return Arrays.deepEquals(board, board1.board);
+    }
+
+    @Override
+    public int hashCode() {
+        return Arrays.deepHashCode(board);
+    }
+}

algorithms-miscellaneous-2/src/main/java/com/baeldung/algorithms/play2048/Cell.java

@@ -0,0 +1,26 @@
+package com.baeldung.algorithms.play2048;
+
+import java.util.StringJoiner;
+
+public class Cell {
+    private int x;
+    private int y;
+
+    public Cell(int x, int y) {
+        this.x = x;
+        this.y = y;
+    }
+
+    public int getX() {
+        return x;
+    }
+
+    public int getY() {
+        return y;
+    }
+
+    @Override
+    public String toString() {
+        return new StringJoiner(", ", Cell.class.getSimpleName() + "[", "]").add("x=" + x).add("y=" + y).toString();
+    }
+}

algorithms-miscellaneous-2/src/main/java/com/baeldung/algorithms/play2048/Computer.java

@@ -0,0 +1,27 @@
+package com.baeldung.algorithms.play2048;
+
+import java.security.SecureRandom;
+import java.util.List;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class Computer {
+    private static final Logger LOG = LoggerFactory.getLogger(Computer.class);
+
+    private final SecureRandom rng = new SecureRandom();
+
+    public Board makeMove(Board input) {
+        List<Cell> emptyCells = input.emptyCells();
+        LOG.info("Number of empty cells: {}", emptyCells.size());
+
+        double numberToPlace = rng.nextDouble();
+        LOG.info("New number probability: {}", numberToPlace);
+
+        int indexToPlace = rng.nextInt(emptyCells.size());
+        Cell cellToPlace = emptyCells.get(indexToPlace);
+        LOG.info("Placing number into empty cell: {}", cellToPlace);
+
+        return input.placeTile(cellToPlace, numberToPlace >= 0.9 ? 4 : 2);
+    }
+}

algorithms-miscellaneous-2/src/main/java/com/baeldung/algorithms/play2048/Human.java

@@ -0,0 +1,126 @@
+package com.baeldung.algorithms.play2048;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Comparator;
+import java.util.List;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+import org.apache.commons.math3.util.Pair;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class Human {
+    private static final Logger LOG = LoggerFactory.getLogger(Human.class);
+
+    public Board makeMove(Board input) {
+        // For each move in MOVE
+        //   Generate board from move
+        //   Generate Score for Board
+        // Return board with the best score
+        //
+        // Generate Score
+        //   If Depth Limit
+        //     Return Final Score
+        //   Total Score = 0
+        //   For every empty square in new board
+        //     Generate board with "2" in square
+        //       Calculate Score
+        //       Total Score += (Score * 0.9)
+        //     Generate board with "4" in square
+        //       Calculate Score
+        //       Total Score += (Score * 0.1)
+        //
+        // Calculate Score
+        //   For each move in MOVE
+        //     Generate board from move
+        //     Generate score for board
+        //   Return the best generated score
+
+        return Arrays.stream(Move.values())
+            .parallel()
+            .map(input::move)
+            .filter(board -> !board.equals(input))
+            .max(Comparator.comparingInt(board -> generateScore(board, 0)))
+            .orElse(input);
+    }
+
+    private int generateScore(Board board, int depth) {
+        if (depth >= 3) {
+            int finalScore = calculateFinalScore(board);
+            LOG.debug("Final score for board {}: {}", board,finalScore);
+            return finalScore;
+        }
+
+        return board.emptyCells().stream()
+            .parallel()
+            .flatMap(cell -> Stream.of(new Pair<>(cell, 2), new Pair<>(cell, 4)))
+            .mapToInt(move -> {
+                LOG.debug("Simulating move {} at depth {}", move, depth);
+                Board newBoard = board.placeTile(move.getFirst(), move.getSecond());
+                int boardScore = calculateScore(newBoard, depth + 1);
+                int calculatedScore = (int) (boardScore * (move.getSecond() == 2 ? 0.9 : 0.1));
+                LOG.debug("Calculated score for board {} and move {} at depth {}: {}", newBoard, move, depth, calculatedScore);
+                return calculatedScore;
+            })
+            .sum();
+    }
+
+    private int calculateScore(Board board, int depth) {
+        return Arrays.stream(Move.values())
+            .parallel()
+            .map(board::move)
+            .filter(moved -> !moved.equals(board))
+            .mapToInt(newBoard -> generateScore(newBoard, depth))
+            .max()
+            .orElse(0);
+    }
+
+    private int calculateFinalScore(Board board) {
+        List<List<Integer>> rowsToScore = new ArrayList<>();
+        for (int i = 0; i < board.getSize(); ++i) {
+            List<Integer> row = new ArrayList<>();
+            List<Integer> col = new ArrayList<>();
+
+            for (int j = 0; j < board.getSize(); ++j) {
+                row.add(board.getCell(new Cell(i, j)));
+                col.add(board.getCell(new Cell(j, i)));
+            }
+
+            rowsToScore.add(row);
+            rowsToScore.add(col);
+        }
+
+        return rowsToScore.stream()
+            .parallel()
+            .mapToInt(row -> {
+                List<Integer> preMerged = row.stream()
+                    .filter(value -> value != 0)
+                    .collect(Collectors.toList());
+
+                int numMerges = 0;
+                int monotonicityLeft = 0;
+                int monotonicityRight = 0;
+                for (int i = 0; i < preMerged.size() - 1; ++i) {
+                    Integer first = preMerged.get(i);
+                    Integer second = preMerged.get(i + 1);
+                    if (first.equals(second)) {
+                        ++numMerges;
+                    } else if (first > second) {
+                        monotonicityLeft += first - second;
+                    } else {
+                        monotonicityRight += second - first;
+                    }
+                }
+
+                int score = 1000;
+                score += 250 * row.stream().filter(value -> value == 0).count();
+                score += 750 * numMerges;
+                score -= 10 * row.stream().mapToInt(value -> value).sum();
+                score -= 50 * Math.min(monotonicityLeft, monotonicityRight);
+                return score;
+            })
+            .sum();
+    }
+}

algorithms-miscellaneous-2/src/main/java/com/baeldung/algorithms/play2048/Move.java

@@ -0,0 +1,8 @@
+package com.baeldung.algorithms.play2048;
+
+public enum Move {
+    UP,
+    DOWN,
+    LEFT,
+    RIGHT
+}

algorithms-miscellaneous-2/src/main/java/com/baeldung/algorithms/play2048/Play2048.java

@@ -0,0 +1,73 @@
+package com.baeldung.algorithms.play2048;
+
+public class Play2048 {
+    private static final int SIZE = 3;
+    private static final int INITIAL_NUMBERS = 2;
+
+    public static void main(String[] args) {
+        // The board and players
+        Board board = new Board(SIZE);
+        Computer computer = new Computer();
+        Human human = new Human();
+
+        // The computer has two moves first
+        System.out.println("Setup");
+        System.out.println("=====");
+        for (int i = 0; i < INITIAL_NUMBERS; ++i) {
+            board = computer.makeMove(board);
+        }
+
+        printBoard(board);
+        do {
+            board = human.makeMove(board);
+            System.out.println("Human move");
+            System.out.println("==========");
+            printBoard(board);
+
+            board = computer.makeMove(board);
+            System.out.println("Computer move");
+            System.out.println("=============");
+            printBoard(board);
+        } while (!board.emptyCells().isEmpty());
+
+        System.out.println("Final Score: " + board.getScore());
+
+    }
+
+    private static void printBoard(Board board) {
+        StringBuilder topLines = new StringBuilder();
+        StringBuilder midLines = new StringBuilder();
+        for (int x = 0; x < board.getSize(); ++x) {
+            topLines.append("+--------");
+            midLines.append("|        ");
+        }
+        topLines.append("+");
+        midLines.append("|");
+
+
+        for (int y = 0; y < board.getSize(); ++y) {
+            System.out.println(topLines);
+            System.out.println(midLines);
+            for (int x = 0; x < board.getSize(); ++x) {
+                Cell cell = new Cell(x, y);
+                System.out.print("|");
+                if (board.isEmpty(cell)) {
+                    System.out.print("        ");
+                } else {
+                    StringBuilder output = new StringBuilder(Integer.toString(board.getCell(cell)));
+                    while (output.length() < 8) {
+                        output.append(" ");
+                        if (output.length() < 8) {
+                            output.insert(0, " ");
+                        }
+                    }
+                    System.out.print(output);
+                }
+            }
+            System.out.println("|");
+            System.out.println(midLines);
+        }
+        System.out.println(topLines);
+        System.out.println("Score: " + board.getScore());
+    }
+}

algorithms-miscellaneous-5/README.md

@@ -15,9 +15,5 @@ This module contains articles about algorithms. Some classes of algorithms, e.g.
 - [Maximum Subarray Problem](https://www.baeldung.com/java-maximum-subarray)
 - [How to Merge Two Sorted Arrays](https://www.baeldung.com/java-merge-sorted-arrays)
 - [Median of Stream of Integers using Heap](https://www.baeldung.com/java-stream-integers-median-using-heap)
-- [Kruskal’s Algorithm for Spanning Trees](https://www.baeldung.com/java-spanning-trees-kruskal)
-- [Balanced Brackets Algorithm in Java](https://www.baeldung.com/java-balanced-brackets-algorithm)
-- [Efficiently Merge Sorted Java Sequences](https://www.baeldung.com/java-merge-sorted-sequences)
-- [Introduction to Greedy Algorithms with Java](https://www.baeldung.com/java-greedy-algorithms)
-- [The Caesar Cipher in Java](https://www.baeldung.com/java-caesar-cipher)
-- More articles: [[<-- prev]](/../algorithms-miscellaneous-4)
+- More articles: [[<-- prev]](/../algorithms-miscellaneous-4) [[next -->]](/../algorithms-miscellaneous-6)
+

algorithms-miscellaneous-5/pom.xml

@@ -25,12 +25,6 @@
             <artifactId>commons-math3</artifactId>
             <version>${commons-math3.version}</version>
         </dependency>
-        <dependency>
-            <groupId>org.projectlombok</groupId>
-            <artifactId>lombok</artifactId>
-            <version>${lombok.version}</version>
-            <scope>provided</scope>
-        </dependency>
         <dependency>
             <groupId>pl.allegro.finance</groupId>
             <artifactId>tradukisto</artifactId>

algorithms-miscellaneous-6/README.md

@@ -2,3 +2,9 @@
 
 - [Boruvka’s Algorithm for Minimum Spanning Trees](https://www.baeldung.com/java-boruvka-algorithm)
 - [Gradient Descent in Java](https://www.baeldung.com/java-gradient-descent)
+- [Kruskal’s Algorithm for Spanning Trees](https://www.baeldung.com/java-spanning-trees-kruskal)
+- [Balanced Brackets Algorithm in Java](https://www.baeldung.com/java-balanced-brackets-algorithm)
+- [Efficiently Merge Sorted Java Sequences](https://www.baeldung.com/java-merge-sorted-sequences)
+- [Introduction to Greedy Algorithms with Java](https://www.baeldung.com/java-greedy-algorithms)
+- [The Caesar Cipher in Java](https://www.baeldung.com/java-caesar-cipher)
+- More articles: [[<-- prev]](/../algorithms-miscellaneous-5)

algorithms-miscellaneous-6/pom.xml

@@ -18,10 +18,35 @@
             <artifactId>guava</artifactId>
             <version>${guava.version}</version>
         </dependency>
+        <dependency>
+            <groupId>org.junit.platform</groupId>
+            <artifactId>junit-platform-commons</artifactId>
+            <version>${junit.platform.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.assertj</groupId>
+            <artifactId>assertj-core</artifactId>
+            <version>${org.assertj.core.version}</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.projectlombok</groupId>
+            <artifactId>lombok</artifactId>
+            <version>${lombok.version}</version>
+            <scope>provided</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.apache.commons</groupId>
+            <artifactId>commons-math3</artifactId>
+            <version>${commons-math3.version}</version>
+        </dependency>
     </dependencies>
     
     <properties>
         <guava.version>28.1-jre</guava.version>
+        <org.assertj.core.version>3.9.0</org.assertj.core.version>
+        <junit.platform.version>1.6.0</junit.platform.version>
+        <commons-math3.version>3.6.1</commons-math3.version>
     </properties>
 
 </project>

apache-cxf/README.md

@@ -3,7 +3,7 @@
 This module contains articles about Apache CXF
 
 ## Relevant Articles:
-- [Introduction to Apache CXF Aegis Data Binding](https://www.baeldung.com/aegis-data-binding-in-apache-cxf)
+
 - [Apache CXF Support for RESTful Web Services](https://www.baeldung.com/apache-cxf-rest-api)
 - [A Guide to Apache CXF with Spring](https://www.baeldung.com/apache-cxf-with-spring)
 - [Introduction to Apache CXF](https://www.baeldung.com/introduction-to-apache-cxf)

apache-cxf/cxf-aegis/README.md

@@ -0,0 +1,3 @@
+### Relevant Articles:
+
+- [Introduction to Apache CXF Aegis Data Binding](https://www.baeldung.com/aegis-data-binding-in-apache-cxf)

apache-shiro/pom.xml

@@ -10,9 +10,9 @@
 
     <parent>
         <groupId>com.baeldung</groupId>
-        <artifactId>parent-boot-1</artifactId>
+        <artifactId>parent-boot-2</artifactId>
         <version>0.0.1-SNAPSHOT</version>
-        <relativePath>../parent-boot-1</relativePath>
+        <relativePath>../parent-boot-2</relativePath>
     </parent>
 
     <dependencies>

apache-shiro/src/main/java/com/baeldung/Main.java

@@ -1,11 +1,14 @@
 package com.baeldung;
 
 import org.apache.shiro.SecurityUtils;
-import org.apache.shiro.authc.*;
+import org.apache.shiro.authc.AuthenticationException;
+import org.apache.shiro.authc.IncorrectCredentialsException;
+import org.apache.shiro.authc.LockedAccountException;
+import org.apache.shiro.authc.UnknownAccountException;
+import org.apache.shiro.authc.UsernamePasswordToken;
 import org.apache.shiro.mgt.DefaultSecurityManager;
 import org.apache.shiro.mgt.SecurityManager;
 import org.apache.shiro.realm.Realm;
-import org.apache.shiro.realm.text.IniRealm;
 import org.apache.shiro.session.Session;
 import org.apache.shiro.subject.Subject;
 import org.slf4j.Logger;

apache-shiro/src/main/java/com/baeldung/MyCustomRealm.java

@@ -1,16 +1,24 @@
 package com.baeldung;
 
-import org.apache.shiro.authc.*;
+import java.sql.Connection;
+import java.sql.SQLException;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+
+import org.apache.shiro.authc.AuthenticationException;
+import org.apache.shiro.authc.AuthenticationInfo;
+import org.apache.shiro.authc.AuthenticationToken;
+import org.apache.shiro.authc.SimpleAuthenticationInfo;
+import org.apache.shiro.authc.UnknownAccountException;
+import org.apache.shiro.authc.UsernamePasswordToken;
 import org.apache.shiro.authz.AuthorizationInfo;
 import org.apache.shiro.authz.SimpleAuthorizationInfo;
 import org.apache.shiro.realm.jdbc.JdbcRealm;
 import org.apache.shiro.subject.PrincipalCollection;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import java.sql.Connection;
-import java.sql.SQLException;
-import java.util.*;
 
 public class MyCustomRealm extends JdbcRealm {
 

apache-shiro/src/main/java/com/baeldung/shiro/permissions/custom/Main.java

@@ -1,14 +1,15 @@
 package com.baeldung.shiro.permissions.custom;
 
-import com.baeldung.MyCustomRealm;
 import org.apache.shiro.SecurityUtils;
-import org.apache.shiro.authc.*;
+import org.apache.shiro.authc.AuthenticationException;
+import org.apache.shiro.authc.IncorrectCredentialsException;
+import org.apache.shiro.authc.LockedAccountException;
+import org.apache.shiro.authc.UnknownAccountException;
+import org.apache.shiro.authc.UsernamePasswordToken;
 import org.apache.shiro.config.Ini;
 import org.apache.shiro.mgt.DefaultSecurityManager;
 import org.apache.shiro.mgt.SecurityManager;
-import org.apache.shiro.realm.Realm;
 import org.apache.shiro.realm.text.IniRealm;
-import org.apache.shiro.session.Session;
 import org.apache.shiro.subject.Subject;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;

atomikos/README.md

@@ -1,7 +1,6 @@
 ## Atomikos
-
 This module contains articles about Atomikos
 
 ### Relevant Articles: 
 
-- [Guide Transactions Using Atomikos]()
+- [A Guide to Atomikos](https://www.baeldung.com/java-atomikos)

aws-app-sync/README.md

@@ -0,0 +1,3 @@
+### Relevant Articles:
+
+- [AWS AppSync With Spring Boot](https://www.baeldung.com/aws-appsync-spring)

aws-app-sync/pom.xml

@@ -0,0 +1,56 @@
+<?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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+    <parent>
+        <groupId>org.springframework.boot</groupId>
+        <artifactId>spring-boot-starter-parent</artifactId>
+        <version>2.2.6.RELEASE</version>
+        <relativePath/> <!-- lookup parent from repository -->
+    </parent>
+
+    <groupId>com.baeldung</groupId>
+    <artifactId>aws-app-sync</artifactId>
+    <version>0.0.1-SNAPSHOT</version>
+    <name>aws-app-sync</name>
+
+    <description>Spring Boot using AWS App Sync</description>
+
+    <properties>
+        <java.version>1.8</java.version>
+    </properties>
+
+    <dependencies>
+
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-web</artifactId>
+        </dependency>
+
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-test</artifactId>
+            <scope>test</scope>
+            <exclusions>
+                <exclusion>
+                    <groupId>org.junit.vintage</groupId>
+                    <artifactId>junit-vintage-engine</artifactId>
+                </exclusion>
+            </exclusions>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-webflux</artifactId>
+        </dependency>
+    </dependencies>
+
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.springframework.boot</groupId>
+                <artifactId>spring-boot-maven-plugin</artifactId>
+            </plugin>
+        </plugins>
+    </build>
+
+</project>

aws-app-sync/src/main/java/com/baeldung/awsappsync/AppSyncClientHelper.java

@@ -0,0 +1,32 @@
+package com.baeldung.awsappsync;
+
+import org.springframework.http.HttpMethod;
+import org.springframework.http.MediaType;
+import org.springframework.web.reactive.function.BodyInserters;
+import org.springframework.web.reactive.function.client.WebClient;
+
+import java.nio.charset.StandardCharsets;
+import java.util.Map;
+
+public class AppSyncClientHelper {
+
+    static String apiUrl = "<INSERT API URL HERE>";
+    static String apiKey = "<INSERT API KEY HERE>";
+    static String API_KEY_HEADER = "x-api-key";
+
+    public static WebClient.ResponseSpec getResponseBodySpec(Map<String, Object> requestBody) {
+        return WebClient
+                .builder()
+                .baseUrl(apiUrl)
+                .defaultHeader(API_KEY_HEADER, apiKey)
+                .defaultHeader("Content-Type", "application/json")
+                .build()
+                .method(HttpMethod.POST)
+                .uri("/graphql")
+                .body(BodyInserters.fromValue(requestBody))
+                .accept(MediaType.APPLICATION_JSON, MediaType.APPLICATION_XML)
+                .acceptCharset(StandardCharsets.UTF_8)
+                .retrieve();
+    }
+
+}

aws-app-sync/src/main/java/com/baeldung/awsappsync/AwsAppSyncApplication.java

@@ -0,0 +1,13 @@
+package com.baeldung.awsappsync;
+
+import org.springframework.boot.SpringApplication;
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+
+@SpringBootApplication
+public class AwsAppSyncApplication {
+
+    public static void main(String[] args) {
+        SpringApplication.run(AwsAppSyncApplication.class, args);
+    }
+
+}

aws-app-sync/src/test/java/com/baeldung/awsappsync/AwsAppSyncApplicationTests.java

@@ -0,0 +1,74 @@
+package com.baeldung.awsappsync;
+
+import org.junit.jupiter.api.Disabled;
+import org.junit.jupiter.api.Test;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.web.reactive.function.client.WebClient;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+@SpringBootTest
+@Disabled
+class AwsAppSyncApplicationTests {
+
+    @Test
+    void givenGraphQuery_whenListEvents_thenReturnAllEvents() {
+
+        Map<String, Object> requestBody = new HashMap<>();
+        requestBody.put("query", "query ListEvents {"
+                + "  listEvents {"
+                + "    items {"
+                + "      id"
+                + "      name"
+                + "      where"
+                + "      when"
+                + "      description"
+                + "    }"
+                + "  }"
+                + "}");
+        requestBody.put("variables", "");
+        requestBody.put("operationName", "ListEvents");
+
+        String bodyString = AppSyncClientHelper.getResponseBodySpec(requestBody)
+                .bodyToMono(String.class).block();
+
+        assertNotNull(bodyString);
+        assertTrue(bodyString.contains("My First Event"));
+        assertTrue(bodyString.contains("where"));
+        assertTrue(bodyString.contains("when"));
+    }
+
+    @Test
+    void givenGraphAdd_whenMutation_thenReturnIdNameDesc() {
+
+        String queryString = "mutation add {"
+                + "    createEvent("
+                + "        name:\"My added GraphQL event\""
+                + "        where:\"Day 2\""
+                + "        when:\"Saturday night\""
+                + "        description:\"Studying GraphQL\""
+                + "    ){"
+                + "        id"
+                + "        name"
+                + "        description"
+                + "    }"
+                + "}";
+
+        Map<String, Object> requestBody = new HashMap<>();
+        requestBody.put("query", queryString);
+        requestBody.put("variables", "");
+        requestBody.put("operationName", "add");
+
+        WebClient.ResponseSpec response = AppSyncClientHelper.getResponseBodySpec(requestBody);
+
+        String bodyString = response.bodyToMono(String.class).block();
+
+        assertNotNull(bodyString);
+        assertTrue(bodyString.contains("My added GraphQL event"));
+        assertFalse(bodyString.contains("where"));
+        assertFalse(bodyString.contains("when"));
+    }
+}

bazel/bazelapp/README.md

@@ -1,3 +0,0 @@
-### Relevant Articles:
-
-- [Building Java Applications with Bazel](https://www.baeldung.com/bazel-build-tool)

cas/cas-secured-app/pom.xml

@@ -16,10 +16,6 @@
         <relativePath>../../parent-boot-2</relativePath>
     </parent>
 
-    <properties>
-        <spring-boot.version>2.2.6.RELEASE</spring-boot.version>
-    </properties>
-
     <dependencies>
         <dependency>
             <groupId>org.springframework.boot</groupId>

core-groovy-2/README.md

@@ -13,4 +13,5 @@ This module contains articles about core Groovy concepts
 - [Metaprogramming in Groovy](https://www.baeldung.com/groovy-metaprogramming)
 - [A Quick Guide to Working with Web Services in Groovy](https://www.baeldung.com/groovy-web-services)
 - [Categories in Groovy](https://www.baeldung.com/groovy-categories)
+- [How to Determine the Data Type in Groovy](https://www.baeldung.com/groovy-determine-data-type)
 - [[<-- Prev]](/core-groovy)

core-groovy-2/src/main/groovy/com/baeldung/determinedatatype/Person.groovy

@@ -0,0 +1,14 @@
+package com.baeldung.determinedatatype
+
+class Person {
+    
+    private int ageAsInt
+    private Double ageAsDouble
+    private String ageAsString
+    
+    Person() {}
+    Person(int ageAsInt) { this.ageAsInt =  ageAsInt}
+    Person(Double ageAsDouble) { this.ageAsDouble =  ageAsDouble}
+    Person(String ageAsString) { this.ageAsString =  ageAsString}    
+}
+class Student extends Person {}

core-groovy-2/src/test/groovy/com/baeldung/determinedatatype/PersonTest.groovy

@@ -0,0 +1,56 @@
+package com.baeldung.determinedatatype
+
+import org.junit.Assert
+import org.junit.Test
+import com.baeldung.determinedatatype.Person
+
+public class PersonTest {
+    
+    @Test
+    public void givenWhenParameterTypeIsInteger_thenReturnTrue() {
+        Person personObj = new Person(10)
+        Assert.assertTrue(personObj.ageAsInt instanceof Integer)
+    }
+    
+    @Test
+    public void givenWhenParameterTypeIsDouble_thenReturnTrue() {
+        Person personObj = new Person(10.0)
+        Assert.assertTrue((personObj.ageAsDouble).getClass() == Double)
+    }
+    
+    @Test
+    public void givenWhenParameterTypeIsString_thenReturnTrue() {
+        Person personObj = new Person("10 years")
+        Assert.assertTrue(personObj.ageAsString.class == String)
+    }
+    
+    @Test
+    public void givenClassName_WhenParameterIsInteger_thenReturnTrue() {
+        Assert.assertTrue(Person.class.getDeclaredField('ageAsInt').type == int.class)
+    }
+    
+    @Test
+    public void givenWhenObjectIsInstanceOfType_thenReturnTrue() {
+        Person personObj = new Person()
+        Assert.assertTrue(personObj instanceof Person)
+    }
+
+    @Test
+    public void givenWhenInstanceIsOfSubtype_thenReturnTrue() {
+        Student studentObj = new Student()
+        Assert.assertTrue(studentObj in Person)
+    }
+    
+    @Test
+    public void givenGroovyList_WhenFindClassName_thenReturnTrue() {
+      def ageList = ['ageAsString','ageAsDouble', 10]   
+      Assert.assertTrue(ageList.class == ArrayList)     
+      Assert.assertTrue(ageList.getClass() == ArrayList)
+    }
+    
+    @Test
+    public void givenGrooyMap_WhenFindClassName_thenReturnTrue() {
+      def ageMap = [ageAsString: '10 years', ageAsDouble: 10.0]
+      Assert.assertFalse(ageMap.class == LinkedHashMap)
+    }
+}

core-groovy/README.md

@@ -12,4 +12,5 @@ This module contains articles about core Groovy concepts
 - [Closures in Groovy](https://www.baeldung.com/groovy-closures)
 - [Converting a String to a Date in Groovy](https://www.baeldung.com/groovy-string-to-date)
 - [Guide to I/O in Groovy](https://www.baeldung.com/groovy-io)
+- [Convert String to Integer in Groovy](https://www.baeldung.com/groovy-convert-string-to-integer)
 - [[More -->]](/core-groovy-2)

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

@@ -8,3 +8,4 @@ This module contains articles about Java 14.
 - [Java Text Blocks](https://www.baeldung.com/java-text-blocks)
 - [Pattern Matching for instanceof in Java 14](https://www.baeldung.com/java-pattern-matching-instanceof)
 - [Helpful NullPointerExceptions in Java 14](https://www.baeldung.com/java-14-nullpointerexception)
+- [Foreign Memory Access API in Java 14](https://www.baeldung.com/java-foreign-memory-access)

core-java-modules/core-java-14/src/main/java/com/baeldung/java14/npe/HelpfulNullPointerException.java

@@ -1,4 +1,4 @@
-package com.baeldung.java14.helpfulnullpointerexceptions;
+package com.baeldung.java14.npe;
 
 public class HelpfulNullPointerException {
 

core-java-modules/core-java-14/src/main/java/com/baeldung/java14/record/Person.java

@@ -0,0 +1,22 @@
+package com.baeldung.java14.record;
+
+import java.util.Objects;
+
+public record Person (String name, String address) {
+	
+	  public static String UNKNOWN_ADDRESS = "Unknown";
+	  public static String UNNAMED = "Unnamed";
+
+	  public Person {
+		    Objects.requireNonNull(name);
+		    Objects.requireNonNull(address);
+	  }
+	
+	  public Person(String name) {
+		    this(name, UNKNOWN_ADDRESS);
+	  }
+	
+	  public static Person unnamed(String address) {
+		    return new Person(UNNAMED, address);
+	  }
+}

core-java-modules/core-java-14/src/test/java/com/baeldung/java14/foreign/api/ForeignMemoryUnitTest.java

@@ -0,0 +1,84 @@
+package com.baeldung.java14.foreign.api;
+
+import jdk.incubator.foreign.*;
+import org.junit.Test;
+
+import static org.hamcrest.core.Is.is;
+import static org.junit.Assert.assertThat;
+
+import java.lang.invoke.VarHandle;
+import java.nio.ByteOrder;
+
+public class ForeignMemoryUnitTest {
+
+    @Test
+    public void whenAValueIsSet_thenAccessTheValue() {
+        long value = 10;
+        MemoryAddress memoryAddress =
+          MemorySegment.allocateNative(8).baseAddress();
+        VarHandle varHandle = MemoryHandles.varHandle(long.class,
+          ByteOrder.nativeOrder());
+        varHandle.set(memoryAddress, value);
+        assertThat(varHandle.get(memoryAddress), is(value));
+    }
+
+    @Test
+    public void whenMultipleValuesAreSet_thenAccessAll() {
+        VarHandle varHandle = MemoryHandles.varHandle(int.class,
+          ByteOrder.nativeOrder());
+
+        try(MemorySegment memorySegment =
+          MemorySegment.allocateNative(100)) {
+            MemoryAddress base = memorySegment.baseAddress();
+            for(int i=0; i<25; i++) {
+                varHandle.set(base.addOffset((i*4)), i);
+            }
+            for(int i=0; i<25; i++) {
+                assertThat(varHandle.get(base.addOffset((i*4))), is(i));
+            }
+        }
+    }
+
+    @Test
+    public void whenSetValuesWithMemoryLayout_thenTheyCanBeRetrieved() {
+        SequenceLayout sequenceLayout =
+          MemoryLayout.ofSequence(25,
+            MemoryLayout.ofValueBits(64, ByteOrder.nativeOrder()));
+        VarHandle varHandle =
+          sequenceLayout.varHandle(long.class,
+            MemoryLayout.PathElement.sequenceElement());
+
+        try(MemorySegment memorySegment =
+          MemorySegment.allocateNative(sequenceLayout)) {
+            MemoryAddress base = memorySegment.baseAddress();
+            for(long i=0; i<sequenceLayout.elementCount().getAsLong(); i++) {
+                varHandle.set(base, i, i);
+            }
+            for(long i=0; i<sequenceLayout.elementCount().getAsLong(); i++) {
+                assertThat(varHandle.get(base, i), is(i));
+            }
+        }
+    }
+
+    @Test
+    public void whenSlicingMemorySegment_thenTheyCanBeAccessedIndividually() {
+        MemoryAddress memoryAddress =
+          MemorySegment.allocateNative(12).baseAddress();
+        MemoryAddress memoryAddress1 =
+          memoryAddress.segment().asSlice(0,4).baseAddress();
+        MemoryAddress memoryAddress2 =
+          memoryAddress.segment().asSlice(4,4).baseAddress();
+        MemoryAddress memoryAddress3 =
+          memoryAddress.segment().asSlice(8,4).baseAddress();
+
+        VarHandle intHandle =
+          MemoryHandles.varHandle(int.class, ByteOrder.nativeOrder());
+        intHandle.set(memoryAddress1, Integer.MIN_VALUE);
+        intHandle.set(memoryAddress2, 0);
+        intHandle.set(memoryAddress3, Integer.MAX_VALUE);
+
+        assertThat(intHandle.get(memoryAddress1), is(Integer.MIN_VALUE));
+        assertThat(intHandle.get(memoryAddress2), is(0));
+        assertThat(intHandle.get(memoryAddress3), is(Integer.MAX_VALUE));
+    }
+}

core-java-modules/core-java-14/src/test/java/com/baeldung/java14/npe/HelpfulNullPointerExceptionUnitTest.java

@@ -1,4 +1,4 @@
-package com.baeldung.java14.helpfulnullpointerexceptions;
+package com.baeldung.java14.npe;
 
 import org.junit.Test;
 

core-java-modules/core-java-14/src/test/java/com/baeldung/java14/record/PersonTest.java

@@ -0,0 +1,150 @@
+package com.baeldung.java14.record;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotEquals;
+import static org.junit.Assert.assertTrue;
+
+import org.junit.Test;
+
+public class PersonTest {
+
+    @Test
+    public void givenSameNameAndAddress_whenEquals_thenPersonsEqual() {
+
+        String name = "John Doe";
+        String address = "100 Linda Ln.";
+
+        Person person1 = new Person(name, address);
+        Person person2 = new Person(name, address);
+
+        assertTrue(person1.equals(person2));
+    }
+    
+    @Test
+    public void givenDifferentObject_whenEquals_thenNotEqual() {
+
+        Person person = new Person("John Doe", "100 Linda Ln.");
+
+        assertFalse(person.equals(new Object()));
+    }
+
+    @Test
+    public void givenDifferentName_whenEquals_thenPersonsNotEqual() {
+    
+        String address = "100 Linda Ln.";
+    
+        Person person1 = new Person("Jane Doe", address);
+        Person person2 = new Person("John Doe", address);
+    
+        assertFalse(person1.equals(person2));
+    }
+    
+    @Test
+    public void givenDifferentAddress_whenEquals_thenPersonsNotEqual() {
+    
+        String name = "John Doe";
+    
+        Person person1 = new Person(name, "100 Linda Ln.");
+        Person person2 = new Person(name, "200 London Ave.");
+    
+        assertFalse(person1.equals(person2));
+    }
+
+    @Test
+    public void givenSameNameAndAddress_whenHashCode_thenPersonsEqual() {
+
+        String name = "John Doe";
+        String address = "100 Linda Ln.";
+
+        Person person1 = new Person(name, address);
+        Person person2 = new Person(name, address);
+
+        assertEquals(person1.hashCode(), person2.hashCode());
+    }
+    
+    @Test
+    public void givenDifferentObject_whenHashCode_thenNotEqual() {
+
+        Person person = new Person("John Doe", "100 Linda Ln.");
+
+        assertNotEquals(person.hashCode(), new Object().hashCode());
+    }
+
+    @Test
+    public void givenDifferentName_whenHashCode_thenPersonsNotEqual() {
+
+        String address = "100 Linda Ln.";
+
+        Person person1 = new Person("Jane Doe", address);
+        Person person2 = new Person("John Doe", address);
+
+        assertNotEquals(person1.hashCode(), person2.hashCode());
+    }
+
+    @Test
+    public void givenDifferentAddress_whenHashCode_thenPersonsNotEqual() {
+
+        String name = "John Doe";
+
+        Person person1 = new Person(name, "100 Linda Ln.");
+        Person person2 = new Person(name, "200 London Ave.");
+
+        assertNotEquals(person1.hashCode(), person2.hashCode());
+    }
+
+    @Test
+    public void givenValidNameAndAddress_whenGetNameAndAddress_thenExpectedValuesReturned() {
+
+        String name = "John Doe";
+        String address = "100 Linda Ln.";
+
+        Person person = new Person(name, address);
+
+        assertEquals(name, person.name());
+        assertEquals(address, person.address());
+    }
+
+    @Test
+    public void givenValidNameAndAddress_whenToString_thenCorrectStringReturned() {
+
+        String name = "John Doe";
+        String address = "100 Linda Ln.";
+
+        Person person = new Person(name, address);
+
+        assertEquals("Person[name=" + name + ", address=" + address + "]", person.toString());
+    }
+
+    @Test(expected = NullPointerException.class)
+    public void givenNullName_whenConstruct_thenErrorThrown() {
+        new Person(null, "100 Linda Ln.");
+    }
+
+    @Test(expected = NullPointerException.class)
+    public void givenNullAddress_whenConstruct_thenErrorThrown() {
+        new Person("John Doe", null);
+    }
+
+    @Test
+    public void givenUnknownAddress_whenConstructing_thenAddressPopulated() {
+
+        String name = "John Doe";
+
+        Person person = new Person(name);
+
+        assertEquals(name, person.name());
+        assertEquals(Person.UNKNOWN_ADDRESS, person.address());
+    }
+
+    @Test
+    public void givenUnnamed_whenConstructingThroughFactory_thenNamePopulated() {
+
+        String address = "100 Linda Ln.";
+
+        Person person = Person.unnamed(address);
+
+        assertEquals(Person.UNNAMED, person.name());
+        assertEquals(address, person.address());
+    }
+}

core-java-modules/core-java-8-2/pom.xml

@@ -8,12 +8,11 @@
     <version>0.1.0-SNAPSHOT</version>
     <name>core-java-8-2</name>
     <packaging>jar</packaging>
-
     <parent>
-        <groupId>com.baeldung</groupId>
-        <artifactId>parent-java</artifactId>
+        <groupId>com.baeldung.core-java-modules</groupId>
+        <artifactId>core-java-modules</artifactId>
         <version>0.0.1-SNAPSHOT</version>
-        <relativePath>../../parent-java</relativePath>
+        <relativePath>../</relativePath>
     </parent>
 
     <dependencies>

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

@@ -4,16 +4,15 @@
     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-8-datetime</artifactId>
+    <artifactId>core-java-8-datetime-2</artifactId>
     <version>${project.parent.version}</version>
     <name>core-java-8-datetime</name>
     <packaging>jar</packaging>
-
     <parent>
-        <groupId>com.baeldung</groupId>
-        <artifactId>parent-java</artifactId>
+        <groupId>com.baeldung.core-java-modules</groupId>
+        <artifactId>core-java-modules</artifactId>
         <version>0.0.1-SNAPSHOT</version>
-        <relativePath>../../parent-java</relativePath>
+        <relativePath>../</relativePath>
     </parent>
 
     <dependencies>
@@ -42,7 +41,6 @@
     </dependencies>
 
     <build>
-        <finalName>core-java-datetime-java8</finalName>
         <resources>
             <resource>
                 <directory>src/main/resources</directory>

core-java-modules/core-java-8-datetime/pom.xml

@@ -8,12 +8,11 @@
     <version>${project.parent.version}</version>
     <name>core-java-8-datetime</name>
     <packaging>jar</packaging>
-
     <parent>
-        <groupId>com.baeldung</groupId>
-        <artifactId>parent-java</artifactId>
+        <groupId>com.baeldung.core-java-modules</groupId>
+        <artifactId>core-java-modules</artifactId>
         <version>0.0.1-SNAPSHOT</version>
-        <relativePath>../../parent-java</relativePath>
+        <relativePath>../</relativePath>
     </parent>
 
     <dependencies>

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

@@ -8,12 +8,11 @@
     <version>0.1.0-SNAPSHOT</version>
     <name>core-java-8</name>
     <packaging>jar</packaging>
-
     <parent>
-        <groupId>com.baeldung</groupId>
-        <artifactId>parent-java</artifactId>
+        <groupId>com.baeldung.core-java-modules</groupId>
+        <artifactId>core-java-modules</artifactId>
         <version>0.0.1-SNAPSHOT</version>
-        <relativePath>../../parent-java</relativePath>
+        <relativePath>../</relativePath>
     </parent>
 
     <dependencies>

core-java-modules/core-java-9-improvements/README.md

@@ -9,3 +9,4 @@ This module contains articles about the improvements to core Java features intro
 - [Java 9 Stream API Improvements](https://www.baeldung.com/java-9-stream-api)
 - [Java 9 java.util.Objects Additions](https://www.baeldung.com/java-9-objects-new)
 - [Java 9 CompletableFuture API Improvements](https://www.baeldung.com/java-9-completablefuture)
+- [Java InputStream to Byte Array and ByteBuffer](https://www.baeldung.com/convert-input-stream-to-array-of-bytes)

core-java-modules/core-java-9-improvements/pom.xml

@@ -33,6 +33,11 @@
             <artifactId>guava</artifactId>
             <version>${guava.version}</version>
         </dependency>
+        <dependency>
+            <groupId>commons-io</groupId>
+            <artifactId>commons-io</artifactId>
+            <version>${commons-io.version}</version>
+        </dependency>
         <dependency>
             <groupId>org.junit.platform</groupId>
             <artifactId>junit-platform-runner</artifactId>

core-java-modules/core-java-9-improvements/src/test/java/com/baeldung/java9/io/conversion/InputStreamToByteArrayUnitTest.java

@@ -0,0 +1,57 @@
+package com.baeldung.java9.io.conversion;
+
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+
+import org.apache.commons.io.IOUtils;
+import org.junit.Test;
+
+import com.google.common.io.ByteSource;
+import com.google.common.io.ByteStreams;
+
+public class InputStreamToByteArrayUnitTest {
+
+    @Test
+    public final void givenUsingPlainJavaOnFixedSizeStream_whenConvertingAnInputStreamToAByteArray_thenCorrect() throws IOException {
+        final InputStream initialStream = new ByteArrayInputStream(new byte[] { 0, 1, 2 });
+        final byte[] targetArray = new byte[initialStream.available()];
+        initialStream.read(targetArray);
+    }
+
+    @Test
+    public final void givenUsingPlainJavaOnUnknownSizeStream_whenConvertingAnInputStreamToAByteArray_thenCorrect() throws IOException {
+        final InputStream is = new ByteArrayInputStream(new byte[] { 0, 1, 2 });
+
+        final ByteArrayOutputStream buffer = new ByteArrayOutputStream();
+        int nRead;
+        final byte[] data = new byte[1024];
+        while ((nRead = is.read(data, 0, data.length)) != -1) {
+            buffer.write(data, 0, nRead);
+        }
+
+        buffer.flush();
+        final byte[] byteArray = buffer.toByteArray();
+    }
+
+    @Test
+    public void givenUsingPlainJava9_whenConvertingAnInputStreamToAByteArray_thenCorrect() throws IOException {
+        final InputStream is = new ByteArrayInputStream(new byte[] { 0, 1, 2 });
+
+        byte[] data = is.readAllBytes();
+    }
+
+    @Test
+    public final void givenUsingGuava_whenConvertingAnInputStreamToAByteArray_thenCorrect() throws IOException {
+        final InputStream initialStream = ByteSource.wrap(new byte[] { 0, 1, 2 })
+            .openStream();
+        final byte[] targetArray = ByteStreams.toByteArray(initialStream);
+    }
+
+    @Test
+    public final void givenUsingCommonsIO_whenConvertingAnInputStreamToAByteArray_thenCorrect() throws IOException {
+        final InputStream initialStream = new ByteArrayInputStream(new byte[] { 0, 1, 2 });
+        final byte[] targetArray = IOUtils.toByteArray(initialStream);
+    }
+}

core-java-modules/core-java-9-improvements/src/test/java/com/baeldung/java9/io/conversion/InputStreamToByteBufferUnitTest.java

@@ -1,4 +1,4 @@
-package com.baeldung.inputstreamtobytes;
+package com.baeldung.java9.io.conversion;
 
 import com.google.common.io.ByteSource;
 import com.google.common.io.ByteStreams;

core-java-modules/core-java-9-new-features/README.md

@@ -12,3 +12,4 @@ This module contains articles about core Java features that have been introduced
 - [Introduction to Java 9 StackWalking API](https://www.baeldung.com/java-9-stackwalking-api)
 - [Java 9 Platform Logging API](https://www.baeldung.com/java-9-logging-api)
 - [Java 9 Reactive Streams](https://www.baeldung.com/java-9-reactive-streams)
+- [Multi-Release JAR Files with Maven](https://www.baeldung.com/maven-multi-release-jars)

core-java-modules/core-java-9-new-features/pom.xml

@@ -28,8 +28,104 @@
             <version>${junit.platform.version}</version>
             <scope>test</scope>
         </dependency>
+        <dependency>
+            <groupId>org.awaitility</groupId>
+            <artifactId>awaitility</artifactId>
+            <version>${awaitility.version}</version>
+            <scope>test</scope>
+        </dependency>
     </dependencies>
-
+    <profiles>
+        <profile>
+            <id>incubator-features</id>
+            <build>
+                <finalName>core-java-9-new-features</finalName>
+                <plugins>
+                    <plugin>
+                        <groupId>org.apache.maven.plugins</groupId>
+                        <artifactId>maven-compiler-plugin</artifactId>
+                        <version>${maven-compiler-plugin.version}</version>
+                        <configuration>
+                            <source>${maven.compiler.source}</source>
+                            <target>${maven.compiler.target}</target>
+                            <compilerArgument>--add-modules=jdk.incubator.httpclient</compilerArgument>
+                        </configuration>
+                    </plugin>
+                    <plugin>
+                        <artifactId>maven-surefire-plugin</artifactId>
+                        <configuration>
+                            <argLine>--add-modules=jdk.incubator.httpclient</argLine>
+                        </configuration>
+                    </plugin>
+                </plugins>
+            </build>
+        </profile>
+        <profile>
+            <id>mrjar-generation</id>
+            <build>
+                <plugins>
+                    <plugin>
+                        <groupId>org.apache.maven.plugins</groupId>
+                        <artifactId>maven-compiler-plugin</artifactId>
+                        <executions>
+                            <execution>
+                                <id>compile-java-8</id>
+                                <goals>
+                                    <goal>compile</goal>
+                                </goals>
+                                <configuration>
+                                    <source>1.8</source>
+                                    <target>1.8</target>
+                                    <compileSourceRoots>
+                                        <compileSourceRoot>${project.basedir}/src/main/java8</compileSourceRoot>
+                                    </compileSourceRoots>
+                                </configuration>
+                            </execution>
+                            <execution>
+                                <id>compile-java-9</id>
+                                <phase>compile</phase>
+                                <goals>
+                                    <goal>compile</goal>
+                                </goals>
+                                <configuration>
+                                    <release>9</release>
+                                    <compileSourceRoots>
+                                        <compileSourceRoot>${project.basedir}/src/main/java9</compileSourceRoot>
+                                    </compileSourceRoots>
+                                    <outputDirectory>${project.build.outputDirectory}/META-INF/versions/9</outputDirectory>
+                                </configuration>
+                            </execution>
+                            <execution>
+                                <id>default-testCompile</id>
+                                <phase>test-compile</phase>
+                                <goals>
+                                    <goal>testCompile</goal>
+                                </goals>
+                                <configuration>
+                                    <skip>true</skip>
+                                </configuration>
+                            </execution>
+                        </executions>
+                    </plugin>
+                    <plugin>
+                        <groupId>org.apache.maven.plugins</groupId>
+                        <artifactId>maven-jar-plugin</artifactId>
+                        <version>${maven-jar-plugin.version}</version>
+                        <configuration>
+                            <archive>
+                                <manifestEntries>
+                                    <Multi-Release>true</Multi-Release>
+                                </manifestEntries>
+                                <manifest>
+                                    <mainClass>com.baeldung.multireleaseapp.App</mainClass>
+                                </manifest>
+                            </archive>
+                        </configuration>
+                    </plugin>
+                </plugins>
+            </build>
+        </profile>
+    </profiles>
     <build>
         <finalName>core-java-9-new-features</finalName>
         <plugins>
@@ -56,8 +152,10 @@
         <!-- testing -->
         <assertj.version>3.10.0</assertj.version>
         <junit.platform.version>1.2.0</junit.platform.version>
+        <awaitility.version>4.0.2</awaitility.version>
         <maven.compiler.source>1.9</maven.compiler.source>
         <maven.compiler.target>1.9</maven.compiler.target>
+        <maven-jar-plugin.version>3.2.0</maven-jar-plugin.version>
     </properties>
 
 </project>

core-java-modules/core-java-9-new-features/src/main/java8/com/baeldung/multireleaseapp/App.java

@@ -0,0 +1,14 @@
+package com.baeldung.multireleaseapp;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class App {
+
+    private static final Logger logger = LoggerFactory.getLogger(App.class);
+
+    public static void main(String[] args) {
+        logger.info(String.format("Running on %s", new DefaultVersion().version()));
+    }
+
+}

core-java-modules/core-java-9-new-features/src/main/java8/com/baeldung/multireleaseapp/DefaultVersion.java

@@ -0,0 +1,9 @@
+package com.baeldung.multireleaseapp;
+
+public class DefaultVersion implements Version {
+
+    @Override
+    public String version() {
+        return System.getProperty("java.version");
+    }
+}

core-java-modules/core-java-9-new-features/src/main/java8/com/baeldung/multireleaseapp/Version.java

@@ -0,0 +1,5 @@
+package com.baeldung.multireleaseapp;
+
+interface Version {
+    public String version();
+}

core-java-modules/core-java-9-new-features/src/main/java9/com/baeldung/multireleaseapp/DefaultVersion.java

@@ -0,0 +1,9 @@
+package com.baeldung.multireleaseapp;
+
+public class DefaultVersion implements Version {
+
+    @Override
+    public String version() {
+        return Runtime.version().toString();
+    }
+}

core-java-modules/core-java-9-new-features/src/test/java/com/baeldung/java9/httpclient/HttpClientIntegrationTest.java

@@ -24,7 +24,7 @@ import static org.junit.Assert.assertThat;
 /**
  * Created by adam.
  */
-public class HttpClientTest {
+public class HttpClientIntegrationTest {
 
     @Test
     public void shouldReturnSampleDataContentWhenConnectViaSystemProxy() throws IOException, InterruptedException, URISyntaxException {
@@ -55,7 +55,7 @@ public class HttpClientTest {
             .send(request, HttpResponse.BodyHandler.asString());
 
         assertThat(response.statusCode(), equalTo(HttpURLConnection.HTTP_MOVED_PERM));
-        assertThat(response.body(), containsString("https://stackoverflow.com/"));
+        assertThat(response.body(), containsString(""));
     }
 
     @Test

core-java-modules/core-java-9-new-features/src/test/java/com/baeldung/java9/httpclient/HttpRequestIntegrationTest.java

@@ -22,7 +22,7 @@ import static org.junit.Assert.assertThat;
 /**
  * Created by adam.
  */
-public class HttpRequestTest {
+public class HttpRequestIntegrationTest {
 
     @Test
     public void shouldReturnStatusOKWhenSendGetRequest() throws IOException, InterruptedException, URISyntaxException {

core-java-modules/core-java-9-new-features/src/test/java/com/baeldung/java9/httpclient/HttpResponseIntegrationTest.java

@@ -18,7 +18,7 @@ import static org.junit.Assert.assertThat;
 /**
  * Created by adam.
  */
-public class HttpResponseTest {
+public class HttpResponseIntegrationTest {
 
     @Test
     public void shouldReturnStatusOKWhenSendGetRequest() throws IOException, InterruptedException, URISyntaxException {

core-java-modules/core-java-9-new-features/src/test/java/com/baeldung/java9/streams/reactive/ReactiveStreamsUnitTest.java

@@ -5,10 +5,12 @@ import org.junit.Test;
 
 import java.util.List;
 import java.util.concurrent.SubmissionPublisher;
+import java.util.concurrent.TimeUnit;
 
-import static org.assertj.core.api.Java6Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.awaitility.Awaitility.await;
 
-public class ReactiveStreamsTest {
+public class ReactiveStreamsUnitTest {
 
     @Test
     public void givenPublisher_whenSubscribeToIt_thenShouldConsumeAllElements() throws InterruptedException {
@@ -25,7 +27,7 @@ public class ReactiveStreamsTest {
 
         //then
 
-        await().atMost(1000, TimeUnit.MILLISECONDS).until(
+        await().atMost(1000, TimeUnit.MILLISECONDS).untilAsserted(
                 () -> assertThat(subscriber.consumedElements).containsExactlyElementsOf(items)
         );
     }
@@ -46,7 +48,7 @@ public class ReactiveStreamsTest {
         publisher.close();
 
         //then
-        await().atMost(1000, TimeUnit.MILLISECONDS).until(
+        await().atMost(1000, TimeUnit.MILLISECONDS).untilAsserted(
                 () -> assertThat(subscriber.consumedElements).containsExactlyElementsOf(expectedResult)
         );
     }
@@ -66,7 +68,7 @@ public class ReactiveStreamsTest {
         publisher.close();
 
         //then
-        await().atMost(1000, TimeUnit.MILLISECONDS).until(
+        await().atMost(1000, TimeUnit.MILLISECONDS).untilAsserted(
                 () -> assertThat(subscriber.consumedElements).containsExactlyElementsOf(expected)
         );
     }

core-java-modules/core-java-9-new-features/src/test/java/com/baeldung/java9/varhandles/VariableHandlesTest.java

@@ -1,106 +0,0 @@
-package com.baeldung.java9.varhandles;
-
-import org.junit.Test;
-
-import java.lang.invoke.MethodHandles;
-import java.lang.invoke.VarHandle;
-
-import static org.assertj.core.api.Assertions.assertThat;
-
-public class VariableHandlesTest {
-
-    public int publicTestVariable = 1;
-    private int privateTestVariable = 1;
-    public int variableToSet = 1;
-    public int variableToCompareAndSet = 1;
-    public int variableToGetAndAdd = 0;
-    public byte variableToBitwiseOr = 0;
-
-    @Test
-    public void whenVariableHandleForPublicVariableIsCreated_ThenItIsInitializedProperly() throws NoSuchFieldException, IllegalAccessException {
-        VarHandle publicIntHandle = MethodHandles
-          .lookup()
-          .in(VariableHandlesTest.class)
-          .findVarHandle(VariableHandlesTest.class, "publicTestVariable", int.class);
-
-        assertThat(publicIntHandle.coordinateTypes().size() == 1);
-        assertThat(publicIntHandle.coordinateTypes().get(0) == VariableHandles.class);
-
-    }
-
-    @Test
-    public void whenVariableHandleForPrivateVariableIsCreated_ThenItIsInitializedProperly() throws NoSuchFieldException, IllegalAccessException {
-        VarHandle privateIntHandle = MethodHandles
-          .privateLookupIn(VariableHandlesTest.class, MethodHandles.lookup())
-          .findVarHandle(VariableHandlesTest.class, "privateTestVariable", int.class);
-
-        assertThat(privateIntHandle.coordinateTypes().size() == 1);
-        assertThat(privateIntHandle.coordinateTypes().get(0) == VariableHandlesTest.class);
-
-    }
-
-    @Test
-    public void whenVariableHandleForArrayVariableIsCreated_ThenItIsInitializedProperly() throws NoSuchFieldException, IllegalAccessException {
-        VarHandle arrayVarHandle = MethodHandles
-          .arrayElementVarHandle(int[].class);
-
-        assertThat(arrayVarHandle.coordinateTypes().size() == 2);
-        assertThat(arrayVarHandle.coordinateTypes().get(0) == int[].class);
-    }
-
-    @Test
-    public void givenVarHandle_whenGetIsInvoked_ThenValueOfVariableIsReturned() throws NoSuchFieldException, IllegalAccessException {
-        VarHandle publicIntHandle = MethodHandles
-          .lookup()
-          .in(VariableHandlesTest.class)
-          .findVarHandle(VariableHandlesTest.class, "publicTestVariable", int.class);
-
-        assertThat((int) publicIntHandle.get(this) == 1);
-    }
-
-    @Test
-    public void givenVarHandle_whenSetIsInvoked_ThenValueOfVariableIsChanged() throws NoSuchFieldException, IllegalAccessException {
-        VarHandle publicIntHandle = MethodHandles
-          .lookup()
-          .in(VariableHandlesTest.class)
-          .findVarHandle(VariableHandlesTest.class, "variableToSet", int.class);
-        publicIntHandle.set(this, 15);
-
-        assertThat((int) publicIntHandle.get(this) == 15);
-    }
-
-    @Test
-    public void givenVarHandle_whenCompareAndSetIsInvoked_ThenValueOfVariableIsChanged() throws NoSuchFieldException, IllegalAccessException {
-        VarHandle publicIntHandle = MethodHandles
-          .lookup()
-          .in(VariableHandlesTest.class)
-          .findVarHandle(VariableHandlesTest.class, "variableToCompareAndSet", int.class);
-        publicIntHandle.compareAndSet(this, 1, 100);
-
-        assertThat((int) publicIntHandle.get(this) == 100);
-    }
-
-    @Test
-    public void givenVarHandle_whenGetAndAddIsInvoked_ThenValueOfVariableIsChanged() throws NoSuchFieldException, IllegalAccessException {
-        VarHandle publicIntHandle = MethodHandles
-          .lookup()
-          .in(VariableHandlesTest.class)
-          .findVarHandle(VariableHandlesTest.class, "variableToGetAndAdd", int.class);
-        int before = (int) publicIntHandle.getAndAdd(this, 200);
-
-        assertThat(before == 0);
-        assertThat((int) publicIntHandle.get(this) == 200);
-    }
-
-    @Test
-    public void givenVarHandle_whenGetAndBitwiseOrIsInvoked_ThenValueOfVariableIsChanged() throws NoSuchFieldException, IllegalAccessException {
-        VarHandle publicIntHandle = MethodHandles
-          .lookup()
-          .in(VariableHandlesTest.class)
-          .findVarHandle(VariableHandlesTest.class, "variableToBitwiseOr", byte.class);
-        byte before = (byte) publicIntHandle.getAndBitwiseOr(this, (byte) 127);
-
-        assertThat(before == 0);
-        assertThat(variableToBitwiseOr == 127);
-    }
-}

core-java-modules/core-java-9-new-features/src/test/java/com/baeldung/java9/varhandles/VariableHandlesUnitTest.java

@@ -0,0 +1,105 @@
+package com.baeldung.java9.varhandles;
+
+import org.junit.Test;
+
+import java.lang.invoke.MethodHandles;
+import java.lang.invoke.VarHandle;
+
+import static org.junit.Assert.assertEquals;
+
+public class VariableHandlesUnitTest {
+
+    public int publicTestVariable = 1;
+    private int privateTestVariable = 1;
+    public int variableToSet = 1;
+    public int variableToCompareAndSet = 1;
+    public int variableToGetAndAdd = 0;
+    public byte variableToBitwiseOr = 0;
+
+    @Test
+    public void whenVariableHandleForPublicVariableIsCreated_ThenItIsInitializedProperly() throws NoSuchFieldException, IllegalAccessException {
+        VarHandle PUBLIC_TEST_VARIABLE = MethodHandles
+          .lookup()
+          .in(VariableHandlesUnitTest.class)
+          .findVarHandle(VariableHandlesUnitTest.class, "publicTestVariable", int.class);
+
+        assertEquals(1, PUBLIC_TEST_VARIABLE.coordinateTypes().size());
+        assertEquals(VariableHandlesUnitTest.class, PUBLIC_TEST_VARIABLE.coordinateTypes().get(0));
+    }
+
+    @Test
+    public void whenVariableHandleForPrivateVariableIsCreated_ThenItIsInitializedProperly() throws NoSuchFieldException, IllegalAccessException {
+        VarHandle PRIVATE_TEST_VARIABLE = MethodHandles
+          .privateLookupIn(VariableHandlesUnitTest.class, MethodHandles.lookup())
+          .findVarHandle(VariableHandlesUnitTest.class, "privateTestVariable", int.class);
+
+        assertEquals(1, PRIVATE_TEST_VARIABLE.coordinateTypes().size());
+        assertEquals(VariableHandlesUnitTest.class, PRIVATE_TEST_VARIABLE.coordinateTypes().get(0));
+    }
+
+    @Test
+    public void whenVariableHandleForArrayVariableIsCreated_ThenItIsInitializedProperly() throws NoSuchFieldException, IllegalAccessException {
+        VarHandle arrayVarHandle = MethodHandles
+          .arrayElementVarHandle(int[].class);
+
+        assertEquals(2, arrayVarHandle.coordinateTypes().size());
+        assertEquals(int[].class, arrayVarHandle.coordinateTypes().get(0));
+    }
+
+    @Test
+    public void givenVarHandle_whenGetIsInvoked_ThenValueOfVariableIsReturned() throws NoSuchFieldException, IllegalAccessException {
+        VarHandle PUBLIC_TEST_VARIABLE = MethodHandles
+          .lookup()
+          .in(VariableHandlesUnitTest.class)
+          .findVarHandle(VariableHandlesUnitTest.class, "publicTestVariable", int.class);
+
+        assertEquals(1, (int) PUBLIC_TEST_VARIABLE.get(this));
+    }
+
+    @Test
+    public void givenVarHandle_whenSetIsInvoked_ThenValueOfVariableIsChanged() throws NoSuchFieldException, IllegalAccessException {
+        VarHandle VARIABLE_TO_SET = MethodHandles
+          .lookup()
+          .in(VariableHandlesUnitTest.class)
+          .findVarHandle(VariableHandlesUnitTest.class, "variableToSet", int.class);
+
+        VARIABLE_TO_SET.set(this, 15);
+        assertEquals(15, (int) VARIABLE_TO_SET.get(this));
+    }
+
+    @Test
+    public void givenVarHandle_whenCompareAndSetIsInvoked_ThenValueOfVariableIsChanged() throws NoSuchFieldException, IllegalAccessException {
+        VarHandle VARIABLE_TO_COMPARE_AND_SET = MethodHandles
+          .lookup()
+          .in(VariableHandlesUnitTest.class)
+          .findVarHandle(VariableHandlesUnitTest.class, "variableToCompareAndSet", int.class);
+
+        VARIABLE_TO_COMPARE_AND_SET.compareAndSet(this, 1, 100);
+        assertEquals(100, (int) VARIABLE_TO_COMPARE_AND_SET.get(this));
+    }
+
+    @Test
+    public void givenVarHandle_whenGetAndAddIsInvoked_ThenValueOfVariableIsChanged() throws NoSuchFieldException, IllegalAccessException {
+        VarHandle VARIABLE_TO_GET_AND_ADD = MethodHandles
+          .lookup()
+          .in(VariableHandlesUnitTest.class)
+          .findVarHandle(VariableHandlesUnitTest.class, "variableToGetAndAdd", int.class);
+
+        int before = (int) VARIABLE_TO_GET_AND_ADD.getAndAdd(this, 200);
+
+        assertEquals(0, before);
+        assertEquals(200, (int) VARIABLE_TO_GET_AND_ADD.get(this));
+    }
+
+    @Test
+    public void givenVarHandle_whenGetAndBitwiseOrIsInvoked_ThenValueOfVariableIsChanged() throws NoSuchFieldException, IllegalAccessException {
+        VarHandle VARIABLE_TO_BITWISE_OR = MethodHandles
+          .lookup()
+          .in(VariableHandlesUnitTest.class)
+          .findVarHandle(VariableHandlesUnitTest.class, "variableToBitwiseOr", byte.class);
+        byte before = (byte) VARIABLE_TO_BITWISE_OR.getAndBitwiseOr(this, (byte) 127);
+
+        assertEquals(0, before);
+        assertEquals(127, (byte) VARIABLE_TO_BITWISE_OR.get(this));
+    }
+}

core-java-modules/core-java-9-streams/pom.xml

@@ -8,12 +8,11 @@
     <version>0.1.0-SNAPSHOT</version>
     <name>core-java-9-streams</name>
     <packaging>jar</packaging>
-
     <parent>
-        <groupId>com.baeldung</groupId>
-        <artifactId>parent-java</artifactId>
+        <groupId>com.baeldung.core-java-modules</groupId>
+        <artifactId>core-java-modules</artifactId>
         <version>0.0.1-SNAPSHOT</version>
-        <relativePath>../../parent-java</relativePath>
+        <relativePath>../</relativePath>
     </parent>
 
     <build>

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

@@ -10,10 +10,10 @@
     <packaging>jar</packaging>
 
     <parent>
-        <groupId>com.baeldung</groupId>
-        <artifactId>parent-java</artifactId>
+        <groupId>com.baeldung.core-java-modules</groupId>
+        <artifactId>core-java-modules</artifactId>
         <version>0.0.1-SNAPSHOT</version>
-        <relativePath>../../parent-java</relativePath>
+        <relativePath>../</relativePath>
     </parent>
 
     <build>

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

@@ -5,7 +5,7 @@
     <parent>
         <artifactId>core-java-modules</artifactId>
         <groupId>com.baeldung.core-java-modules</groupId>
-        <version>1.0.0-SNAPSHOT</version>
+        <version>0.0.1-SNAPSHOT</version>
     </parent>
     <modelVersion>4.0.0</modelVersion>
 

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

@@ -5,7 +5,7 @@
     <parent>
         <artifactId>core-java-modules</artifactId>
         <groupId>com.baeldung.core-java-modules</groupId>
-        <version>1.0.0-SNAPSHOT</version>
+        <version>0.0.1-SNAPSHOT</version>
     </parent>
     <modelVersion>4.0.0</modelVersion>
 

core-java-modules/core-java-arrays-guides/src/test/java/com/baeldung/arrays/JavaArraysToStringUnitTest.java

@@ -0,0 +1,42 @@
+package com.baeldung.arrays;
+
+import org.junit.Test;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+public class JavaArraysToStringUnitTest {
+
+    @Test
+    public void givenInstanceOfArray_whenTryingToConvertToString_thenNameOfClassIsShown() {
+        Object[] arrayOfObjects = { "John", 2, true };
+        assertTrue(arrayOfObjects.toString().startsWith("[Ljava.lang.Object;"));
+    }
+
+    @Test
+    public void givenInstanceOfArray_whenUsingArraysToStringToConvert_thenValueOfObjectsAreShown() {
+        Object[] arrayOfObjects = { "John", 2, true };
+        assertEquals(Arrays.toString(arrayOfObjects), "[John, 2, true]");
+    }
+
+    @Test
+    public void givenInstanceOfDeepArray_whenUsingArraysDeepToStringToConvert_thenValueOfInnerObjectsAreShown() {
+        Object[] innerArray = { "We", "Are", "Inside" };
+        Object[] arrayOfObjects = { "John", 2, innerArray };
+        assertEquals(Arrays.deepToString(arrayOfObjects), "[John, 2, [We, Are, Inside]]");
+    }
+
+    @Test
+    public void givenInstanceOfDeepArray_whenUsingStreamsToConvert_thenValueOfObjectsAreShown() {
+        Object[] arrayOfObjects = { "John", 2, true };
+        List<String> listOfString = Stream.of(arrayOfObjects)
+          .map(Object::toString)
+          .collect(Collectors.toList());
+        assertEquals(listOfString.toString(), "[John, 2, true]");
+    }
+}

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

@@ -5,7 +5,7 @@
     <parent>
         <artifactId>core-java-modules</artifactId>
         <groupId>com.baeldung.core-java-modules</groupId>
-        <version>1.0.0-SNAPSHOT</version>
+        <version>0.0.1-SNAPSHOT</version>
     </parent>
     <modelVersion>4.0.0</modelVersion>
 

core-java-modules/core-java-arrays-operations-advanced/pom.xml

@@ -5,7 +5,7 @@
     <parent>
         <artifactId>core-java-modules</artifactId>
         <groupId>com.baeldung.core-java-modules</groupId>
-        <version>1.0.0-SNAPSHOT</version>
+        <version>0.0.1-SNAPSHOT</version>
     </parent>
     <modelVersion>4.0.0</modelVersion>
 

core-java-modules/core-java-arrays-operations-basic/pom.xml

@@ -5,7 +5,7 @@
     <parent>
         <artifactId>core-java-modules</artifactId>
         <groupId>com.baeldung.core-java-modules</groupId>
-        <version>1.0.0-SNAPSHOT</version>
+        <version>0.0.1-SNAPSHOT</version>
     </parent>
     <modelVersion>4.0.0</modelVersion>
 

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

@@ -5,5 +5,5 @@ This module contains articles about sorting arrays in Java
 ### Relevant Articles: 
 - [Sorting Arrays in Java](https://www.baeldung.com/java-sorting-arrays)
 - [Checking If an Array Is Sorted in Java](https://www.baeldung.com/java-check-sorted-array)
-- [How to Reverse an Array in Java](http://www.baeldung.com/java-invert-array)
+- [How to Reverse an Array in Java](https://www.baeldung.com/java-invert-array)
 - [Arrays.sort vs Arrays.parallelSort](https://www.baeldung.com/java-arrays-sort-vs-parallelsort)

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

@@ -5,8 +5,8 @@
     <parent>
         <artifactId>core-java-modules</artifactId>
         <groupId>com.baeldung.core-java-modules</groupId>
-        <version>1.0.0-SNAPSHOT</version>
-        <relativePath>../pom.xml</relativePath>
+        <version>0.0.1-SNAPSHOT</version>
+        <relativePath>../</relativePath>
     </parent>
     <modelVersion>4.0.0</modelVersion>
 

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

@@ -7,12 +7,11 @@
     <artifactId>core-java-collections-2</artifactId>
     <name>core-java-collections-2</name>
     <packaging>jar</packaging>
-
     <parent>
-        <groupId>com.baeldung</groupId>
-        <artifactId>parent-java</artifactId>
+        <groupId>com.baeldung.core-java-modules</groupId>
+        <artifactId>core-java-modules</artifactId>
         <version>0.0.1-SNAPSHOT</version>
-        <relativePath>../../parent-java</relativePath>
+        <relativePath>../</relativePath>
     </parent>
 
     <dependencies>

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

@@ -9,3 +9,4 @@
 - [Differences Between Collection.clear() and Collection.removeAll()](https://www.baeldung.com/java-collection-clear-vs-removeall)
 - [Performance of contains() in a HashSet vs ArrayList](https://www.baeldung.com/java-hashset-arraylist-contains-performance)
 - [Fail-Safe Iterator vs Fail-Fast Iterator](https://www.baeldung.com/java-fail-safe-vs-fail-fast-iterator)
+- [Quick Guide to the Java Stack](https://www.baeldung.com/java-stack)

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

@@ -8,12 +8,11 @@
     <version>0.1.0-SNAPSHOT</version>
     <name>core-java-collections-3</name>
     <packaging>jar</packaging>
-
     <parent>
-        <groupId>com.baeldung</groupId>
-        <artifactId>parent-java</artifactId>
+        <groupId>com.baeldung.core-java-modules</groupId>
+        <artifactId>core-java-modules</artifactId>
         <version>0.0.1-SNAPSHOT</version>
-        <relativePath>../../parent-java</relativePath>
+        <relativePath>../</relativePath>
     </parent>
 
     <dependencies>

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

@@ -8,12 +8,11 @@
     <version>0.1.0-SNAPSHOT</version>
     <name>core-java-collections-array-list</name>
     <packaging>jar</packaging>
-
     <parent>
-        <groupId>com.baeldung</groupId>
-        <artifactId>parent-java</artifactId>
+        <groupId>com.baeldung.core-java-modules</groupId>
+        <artifactId>core-java-modules</artifactId>
         <version>0.0.1-SNAPSHOT</version>
-        <relativePath>../../parent-java</relativePath>
+        <relativePath>../</relativePath>
     </parent>
 
     <dependencies>

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

@@ -8,12 +8,11 @@
     <version>0.1.0-SNAPSHOT</version>
     <name>core-java-collections-list-2</name>
     <packaging>jar</packaging>
-
     <parent>
-        <groupId>com.baeldung</groupId>
-        <artifactId>parent-java</artifactId>
+        <groupId>com.baeldung.core-java-modules</groupId>
+        <artifactId>core-java-modules</artifactId>
         <version>0.0.1-SNAPSHOT</version>
-        <relativePath>../../parent-java</relativePath>
+        <relativePath>../</relativePath>
     </parent>
 
     <dependencies>

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

@@ -8,12 +8,11 @@
     <version>0.1.0-SNAPSHOT</version>
     <name>core-java-collections-list-3</name>
     <packaging>jar</packaging>
-
     <parent>
-        <groupId>com.baeldung</groupId>
-        <artifactId>parent-java</artifactId>
+        <groupId>com.baeldung.core-java-modules</groupId>
+        <artifactId>core-java-modules</artifactId>
         <version>0.0.1-SNAPSHOT</version>
-        <relativePath>../../parent-java</relativePath>
+        <relativePath>../</relativePath>
     </parent>
 
     <dependencies>

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

@@ -8,12 +8,11 @@
     <version>0.1.0-SNAPSHOT</version>
     <name>core-java-collections-list</name>
     <packaging>jar</packaging>
-
     <parent>
-        <groupId>com.baeldung</groupId>
-        <artifactId>parent-java</artifactId>
+        <groupId>com.baeldung.core-java-modules</groupId>
+        <artifactId>core-java-modules</artifactId>
         <version>0.0.1-SNAPSHOT</version>
-        <relativePath>../../parent-java</relativePath>
+        <relativePath>../</relativePath>
     </parent>
 
     <dependencies>

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

@@ -7,12 +7,11 @@
     <version>0.1.0-SNAPSHOT</version>
     <name>core-java-collections-maps-2</name>
     <packaging>jar</packaging>
-
     <parent>
-        <groupId>com.baeldung</groupId>
-        <artifactId>parent-java</artifactId>
+        <groupId>com.baeldung.core-java-modules</groupId>
+        <artifactId>core-java-modules</artifactId>
         <version>0.0.1-SNAPSHOT</version>
-        <relativePath>../../parent-java</relativePath>
+        <relativePath>../</relativePath>
     </parent>
 
     <dependencies>

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

@@ -5,4 +5,5 @@ This module contains articles about Map data structures in Java.
 ### Relevant Articles: 
 - [Java TreeMap vs HashMap](https://www.baeldung.com/java-treemap-vs-hashmap)
 - [Comparing Two HashMaps in Java](https://www.baeldung.com/java-compare-hashmaps)
+- [The Map.computeIfAbsent() Method](https://www.baeldung.com/java-map-computeifabsent)
 - More articles: [[<-- prev]](/core-java-modules/core-java-collections-maps-2)

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

@@ -7,12 +7,11 @@
     <version>0.1.0-SNAPSHOT</version>
     <name>core-java-collections-maps-3</name>
     <packaging>jar</packaging>
-
     <parent>
-        <groupId>com.baeldung</groupId>
-        <artifactId>parent-java</artifactId>
+        <groupId>com.baeldung.core-java-modules</groupId>
+        <artifactId>core-java-modules</artifactId>
         <version>0.0.1-SNAPSHOT</version>
-        <relativePath>../../parent-java</relativePath>
+        <relativePath>../</relativePath>
     </parent>
 
     <dependencies>

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

@@ -6,12 +6,11 @@
     <version>0.1.0-SNAPSHOT</version>
     <name>core-java-collections-maps</name>
     <packaging>jar</packaging>
-
     <parent>
-        <groupId>com.baeldung</groupId>
-        <artifactId>parent-java</artifactId>
+        <groupId>com.baeldung.core-java-modules</groupId>
+        <artifactId>core-java-modules</artifactId>
         <version>0.0.1-SNAPSHOT</version>
-        <relativePath>../../parent-java</relativePath>
+        <relativePath>../</relativePath>
     </parent>
 
     <dependencies>

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

@@ -8,12 +8,11 @@
     <version>0.1.0-SNAPSHOT</version>
     <name>core-java-collections-set</name>
     <packaging>jar</packaging>
-
     <parent>
-        <groupId>com.baeldung</groupId>
-        <artifactId>parent-java</artifactId>
+        <groupId>com.baeldung.core-java-modules</groupId>
+        <artifactId>core-java-modules</artifactId>
         <version>0.0.1-SNAPSHOT</version>
-        <relativePath>../../parent-java</relativePath>
+        <relativePath>../</relativePath>
     </parent>
 
     <dependencies>

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

@@ -8,12 +8,11 @@
     <version>0.1.0-SNAPSHOT</version>
     <name>core-java-collections</name>
     <packaging>jar</packaging>
-
     <parent>
-        <groupId>com.baeldung</groupId>
-        <artifactId>parent-java</artifactId>
+        <groupId>com.baeldung.core-java-modules</groupId>
+        <artifactId>core-java-modules</artifactId>
         <version>0.0.1-SNAPSHOT</version>
-        <relativePath>../../parent-java</relativePath>
+        <relativePath>../</relativePath>
     </parent>
 
     <dependencies>

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

@@ -4,4 +4,5 @@
 
 ### Relevant Articles: 
 - [Using a Mutex Object in Java](https://www.baeldung.com/java-mutex)
+- [Testing Multi-Threaded Code in Java](https://www.baeldung.com/java-testing-multithreaded)
 

core-java-modules/core-java-concurrency-2/pom.xml

@@ -8,14 +8,45 @@
     <version>0.1.0-SNAPSHOT</version>
     <name>core-java-concurrency-2</name>
     <packaging>jar</packaging>
-
     <parent>
-        <groupId>com.baeldung</groupId>
-        <artifactId>parent-java</artifactId>
+        <groupId>com.baeldung.core-java-modules</groupId>
+        <artifactId>core-java-modules</artifactId>
         <version>0.0.1-SNAPSHOT</version>
-        <relativePath>../../parent-java</relativePath>
+        <relativePath>../</relativePath>
     </parent>
 	
+	<dependencies>
+        <dependency>
+            <groupId>junit</groupId>
+            <artifactId>junit</artifactId>
+            <version>4.13</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>com.googlecode.thread-weaver</groupId>
+            <artifactId>threadweaver</artifactId>
+            <version>0.2</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>com.google.code.tempus-fugit</groupId>
+            <artifactId>tempus-fugit</artifactId>
+            <version>1.1</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>com.googlecode.multithreadedtc</groupId>
+            <artifactId>multithreadedtc</artifactId>
+            <version>1.01</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.openjdk.jcstress</groupId>
+            <artifactId>jcstress-core</artifactId>
+            <version>0.5</version>
+        </dependency>
+    </dependencies>
+
     <build>
         <finalName>core-java-concurrency-2</finalName>
         <resources>
@@ -24,6 +55,51 @@
                 <filtering>true</filtering>
             </resource>
         </resources>
+		
+		<plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-compiler-plugin</artifactId>
+                <version>3.1</version>
+                <configuration>
+                    <compilerVersion>${javac.target}</compilerVersion>
+                    <source>${javac.target}</source>
+                    <target>${javac.target}</target>
+                </configuration>
+            </plugin>
+
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-shade-plugin</artifactId>
+                <version>2.2</version>
+                <executions>
+                    <execution>
+                        <id>main</id>
+                        <phase>package</phase>
+                        <goals>
+                            <goal>shade</goal>
+                        </goals>
+                        <configuration>
+                            <finalName>jcstress</finalName>
+                            <transformers>
+                                <transformer
+                                    implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
+                                    <mainClass>org.openjdk.jcstress.Main</mainClass>
+                                </transformer>
+                                <transformer
+                                    implementation="org.apache.maven.plugins.shade.resource.AppendingTransformer">
+                                    <resource>META-INF/TestList</resource>
+                                </transformer>
+                            </transformers>
+                        </configuration>
+                    </execution>
+                </executions>
+            </plugin>
+        </plugins>
     </build>
     
+    <properties>
+        <javac.target>1.8</javac.target>
+    </properties>
+
 </project>