New unit test format

core-java-modules/core-java-arrays/.gitignore

@@ -0,0 +1,25 @@
+*.class
+
+0.*
+
+#folders#
+/target
+/neoDb*
+/data
+/src/main/webapp/WEB-INF/classes
+*/META-INF/*
+.resourceCache
+
+# Packaged files #
+*.jar
+*.war
+*.ear
+
+# Files generated by integration tests
+backup-pom.xml
+/bin/
+/temp
+
+#IntelliJ specific
+.idea/
+*.iml

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

@@ -0,0 +1,19 @@
+=========
+
+## Core Java Arrays Cookbooks and Examples
+
+### Relevant Articles: 
+- [How to Copy an Array in Java](http://www.baeldung.com/java-array-copy)
+- [Check if a Java Array Contains a Value](http://www.baeldung.com/java-array-contains-value)
+- [Initializing Arrays in Java](http://www.baeldung.com/java-initialize-array)
+- [Guide to the java.util.Arrays Class](http://www.baeldung.com/java-util-arrays)
+- [Multi-Dimensional Arrays In Java](http://www.baeldung.com/java-jagged-arrays)
+- [Find Sum and Average in a Java Array](http://www.baeldung.com/java-array-sum-average)
+- [Arrays in Java: A Reference Guide](https://www.baeldung.com/java-arrays-guide)
+- [How to Invert an Array in Java](http://www.baeldung.com/java-invert-array)
+- [Array Operations in Java](http://www.baeldung.com/java-common-array-operations)
+- [Intersection Between two Integer Arrays](https://www.baeldung.com/java-array-intersection)
+- [Sorting Arrays in Java](https://www.baeldung.com/java-sorting-arrays)
+- [Convert a Float to a Byte Array in Java](https://www.baeldung.com/java-convert-float-to-byte-array)
+- [Converting Between Stream and Array in Java](https://www.baeldung.com/java-stream-to-array)
+- [Removing an Element from an Array in Java](https://www.baeldung.com/java-array-remove-element)

core-java-modules/core-java-arrays/src/main/java/com/baeldung/array/AddElementToEndOfArray.java

@@ -0,0 +1,34 @@
+package com.baeldung.array;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+
+public class AddElementToEndOfArray {
+
+    public Integer[] addElementUsingArraysCopyOf(Integer[] srcArray, int elementToAdd) {
+        Integer[] destArray = Arrays.copyOf(srcArray, srcArray.length + 1);
+
+        destArray[destArray.length - 1] = elementToAdd;
+        return destArray;
+    }
+
+    public Integer[] addElementUsingArrayList(Integer[] srcArray, int elementToAdd) {
+        Integer[] destArray = new Integer[srcArray.length + 1];
+
+        ArrayList<Integer> arrayList = new ArrayList<>(Arrays.asList(srcArray));
+        arrayList.add(elementToAdd);
+
+        return arrayList.toArray(destArray);
+    }
+
+    public Integer[] addElementUsingSystemArrayCopy(Integer[] srcArray, int elementToAdd) {
+        Integer[] destArray = new Integer[srcArray.length + 1];
+
+        System.arraycopy(srcArray, 0, destArray, 0, srcArray.length);
+
+        destArray[destArray.length - 1] = elementToAdd;
+
+        return destArray;
+    }
+
+}

core-java-modules/core-java-arrays/src/main/java/com/baeldung/array/ArrayBenchmarkRunner.java

@@ -0,0 +1,21 @@
+package com.baeldung.array;
+
+import org.openjdk.jmh.runner.Runner;
+import org.openjdk.jmh.runner.options.Options;
+import org.openjdk.jmh.runner.options.OptionsBuilder;
+
+public class ArrayBenchmarkRunner {
+
+  public static void main(String[] args) throws Exception {
+
+    Options options = new OptionsBuilder()
+        .include(SearchArrayUnitTest.class.getSimpleName()).threads(1)
+        .forks(1).shouldFailOnError(true).shouldDoGC(true)
+        .jvmArgs("-server").build();
+
+    new Runner(options).run();
+
+
+  }
+
+}

core-java-modules/core-java-arrays/src/main/java/com/baeldung/array/ArrayInitializer.java

@@ -0,0 +1,78 @@
+package com.baeldung.array;
+
+import java.util.Arrays;
+
+import org.apache.commons.lang3.ArrayUtils;
+
+public class ArrayInitializer {
+
+    static int[] initializeArrayInLoop() {
+        int array[] = new int[5];
+        for (int i = 0; i < array.length; i++) {
+            array[i] = i + 2;
+        }
+        return array;
+    }
+
+    static int[][] initializeMultiDimensionalArrayInLoop() {
+        int array[][] = new int[2][5];
+        for (int i = 0; i < 2; i++) {
+            for (int j = 0; j < 5; j++) {
+                array[i][j] = j + 1;
+            }
+        }
+
+        return array;
+    }
+
+    static String[] initializeArrayAtTimeOfDeclarationMethod1() {
+        String array[] = new String[] { "Toyota", "Mercedes", "BMW", "Volkswagen", "Skoda" };
+        return array;
+    }
+
+    static int[] initializeArrayAtTimeOfDeclarationMethod2() {
+        int[] array = new int[] { 1, 2, 3, 4, 5 };
+        return array;
+    }
+
+    static int[] initializeArrayAtTimeOfDeclarationMethod3() {
+        int array[] = { 1, 2, 3, 4, 5 };
+        return array;
+    }
+
+    static long[] initializeArrayUsingArraysFill() {
+        long array[] = new long[5];
+        Arrays.fill(array, 30);
+        return array;
+    }
+
+    static int[] initializeArrayRangeUsingArraysFill() {
+        int array[] = new int[5];
+        Arrays.fill(array, 0, 3, -50);
+        return array;
+    }
+
+    static int[] initializeArrayUsingArraysCopy() {
+        int array[] = { 1, 2, 3, 4, 5 };
+        int[] copy = Arrays.copyOf(array, 5);
+        return copy;
+    }
+
+    static int[] initializeLargerArrayUsingArraysCopy() {
+        int array[] = { 1, 2, 3, 4, 5 };
+        int[] copy = Arrays.copyOf(array, 6);
+        return copy;
+    }
+
+    static int[] initializeArrayUsingArraysSetAll() {
+        int[] array = new int[20];
+
+        Arrays.setAll(array, p -> p > 9 ? 0 : p);
+        return array;
+    }
+
+    static char[] initializeArrayUsingArraysUtilClone() {
+        char[] array = new char[] { 'a', 'b', 'c' };
+        return ArrayUtils.clone(array);
+    }
+}

core-java-modules/core-java-arrays/src/main/java/com/baeldung/array/ArrayInverter.java

@@ -0,0 +1,43 @@
+package com.baeldung.array;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.stream.IntStream;
+
+import org.apache.commons.lang3.ArrayUtils;
+
+import com.google.common.collect.Lists;
+
+public class ArrayInverter {
+
+    public void invertUsingFor(Object[] array) {
+        for (int i = 0; i < array.length / 2; i++) {
+            Object temp = array[i];
+            array[i] = array[array.length - 1 - i];
+            array[array.length - 1 - i] = temp;
+        }
+    }
+
+    public void invertUsingCollectionsReverse(Object[] array) {
+        List<Object> list = Arrays.asList(array);
+        Collections.reverse(list);
+    }
+
+    public Object[] invertUsingStreams(final Object[] array) {
+        return IntStream.rangeClosed(1, array.length)
+            .mapToObj(i -> array[array.length - i])
+            .toArray();
+    }
+
+    public void invertUsingCommonsLang(Object[] array) {
+        ArrayUtils.reverse(array);
+    }
+
+    public Object[] invertUsingGuava(Object[] array) {
+        List<Object> list = Arrays.asList(array);
+        List<Object> reverted = Lists.reverse(list);
+        return reverted.toArray();
+    }
+
+}

core-java-modules/core-java-arrays/src/main/java/com/baeldung/array/ArrayReferenceGuide.java

@@ -0,0 +1,159 @@
+package com.baeldung.array;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Comparator;
+import java.util.List;
+import java.util.stream.IntStream;
+import java.util.stream.Stream;
+
+public class ArrayReferenceGuide {
+
+    public static void main(String[] args) {
+        declaration();
+
+        initialization();
+
+        access();
+
+        iterating();
+
+        varargs();
+
+        transformIntoList();
+
+        transformIntoStream();
+
+        sort();
+
+        search();
+
+        merge();
+    }
+
+    private static void declaration() {
+        int[] anArray;
+        int anotherArray[];
+    }
+
+    private static void initialization() {
+        int[] anArray = new int[10];
+        anArray[0] = 10;
+        anArray[5] = 4;
+
+        int[] anotherArray = new int[] {1, 2, 3, 4, 5};
+    }
+
+    private static void access() {
+        int[] anArray = new int[10];
+        anArray[0] = 10;
+        anArray[5] = 4;
+
+        System.out.println(anArray[0]);
+    }
+
+    private static void iterating() {
+        int[] anArray = new int[] {1, 2, 3, 4, 5};
+        for (int i = 0; i < anArray.length; i++) {
+            System.out.println(anArray[i]);
+        }
+
+        for (int element : anArray) {
+            System.out.println(element);
+        }
+    }
+
+    private static void varargs() {
+        String[] groceries = new String[] {"Milk", "Tomato", "Chips"};
+        varargMethod(groceries);
+        varargMethod("Milk", "Tomato", "Chips");
+    }
+
+    private static void varargMethod(String... varargs) {
+        for (String element : varargs) {
+            System.out.println(element);
+        }
+    }
+
+    private static void transformIntoList() {
+        Integer[] anArray = new Integer[] {1, 2, 3, 4, 5};
+
+        // Naïve implementation
+        List<Integer> aList = new ArrayList<>(); // We create an empty list
+        for (int element : anArray) {
+            // We iterate over array's elements and add them to the list
+            aList.add(element);
+        }
+
+        // Pretty implementation
+        aList = Arrays.asList(anArray);
+
+        // Drawbacks
+        try {
+            aList.remove(0);
+        } catch (UnsupportedOperationException e) {
+            System.out.println(e.getMessage());
+        }
+
+        try {
+            aList.add(6);
+        } catch (UnsupportedOperationException e) {
+            System.out.println(e.getMessage());
+        }
+
+        int[] anotherArray = new int[] {1, 2, 3, 4, 5};
+//        List<Integer> anotherList = Arrays.asList(anotherArray);
+    }
+
+    private static void transformIntoStream() {
+        int[] anArray = new int[] {1, 2, 3, 4, 5};
+        IntStream aStream = Arrays.stream(anArray);
+
+        Integer[] anotherArray = new Integer[] {1, 2, 3, 4, 5};
+        Stream<Integer> anotherStream = Arrays.stream(anotherArray, 2, 4);
+    }
+
+    private static void sort() {
+        int[] anArray = new int[] {5, 2, 1, 4, 8};
+        Arrays.sort(anArray); // anArray is now {1, 2, 4, 5, 8}
+
+        Integer[] anotherArray = new Integer[] {5, 2, 1, 4, 8};
+        Arrays.sort(anotherArray); // anArray is now {1, 2, 4, 5, 8}
+
+        String[] yetAnotherArray = new String[] {"A", "E", "Z", "B", "C"};
+        Arrays.sort(yetAnotherArray, 1, 3, Comparator.comparing(String::toString).reversed()); // yetAnotherArray is now {"A", "Z", "E", "B", "C"}
+    }
+
+    private static void search() {
+        int[] anArray = new int[] {5, 2, 1, 4, 8};
+        for (int i = 0; i < anArray.length; i++) {
+            if (anArray[i] == 4) {
+                System.out.println("Found at index " + i);
+                break;
+            }
+        }
+
+        Arrays.sort(anArray);
+        int index = Arrays.binarySearch(anArray, 4);
+        System.out.println("Found at index " + index);
+    }
+
+    private static void merge() {
+        int[] anArray = new int[] {5, 2, 1, 4, 8};
+        int[] anotherArray = new int[] {10, 4, 9, 11, 2};
+
+        int[] resultArray = new int[anArray.length + anotherArray.length];
+        for (int i = 0; i < resultArray.length; i++) {
+            resultArray[i] = (i < anArray.length ? anArray[i] : anotherArray[i - anArray.length]);
+        }
+        for (int element : resultArray) {
+            System.out.println(element);
+        }
+
+        Arrays.setAll(resultArray, i -> (i < anArray.length ? anArray[i] : anotherArray[i - anArray.length]));
+        for (int element : resultArray) {
+            System.out.println(element);
+        }
+    }
+
+}

core-java-modules/core-java-arrays/src/main/java/com/baeldung/array/Find2ndLargestInArray.java

@@ -0,0 +1,20 @@
+package com.baeldung.array;
+
+public class Find2ndLargestInArray {
+
+    public static int find2ndLargestElement(int[] array) {
+        int maxElement = array[0];
+        int secondLargestElement = -1;
+
+        for (int index = 0; index < array.length; index++) {
+            if (maxElement <= array[index]) {
+                secondLargestElement = maxElement;
+                maxElement = array[index];
+            } else if (secondLargestElement < array[index]) {
+                secondLargestElement = array[index];
+            }
+        }
+        return secondLargestElement;
+    }
+
+}

core-java-modules/core-java-arrays/src/main/java/com/baeldung/array/FindElementInArray.java

@@ -0,0 +1,22 @@
+package com.baeldung.array;
+
+import java.util.Arrays;
+
+public class FindElementInArray {
+
+    public static boolean findGivenElementInArrayWithoutUsingStream(int[] array, int element) {
+        boolean actualResult = false;
+
+        for (int index = 0; index < array.length; index++) {
+            if (element == array[index]) {
+                actualResult = true;
+                break;
+            }
+        }
+        return actualResult;
+    }
+
+    public static boolean findGivenElementInArrayUsingStream(int[] array, int element) {
+        return Arrays.stream(array).filter(x -> element == x).findFirst().isPresent();
+    }
+}

core-java-modules/core-java-arrays/src/main/java/com/baeldung/array/MultiDimensionalArray.java

@@ -0,0 +1,83 @@
+package com.baeldung.array;
+
+import java.util.Arrays;
+import java.util.Scanner;
+
+public class MultiDimensionalArray {
+
+    int[][] shortHandFormInitialization() {
+        int[][] multiDimensionalArray = { { 1, 2 }, { 3, 4, 5 }, { 6, 7, 8, 9 } };
+        return multiDimensionalArray;
+    }
+
+    int[][] declarationAndThenInitialization() {
+        int[][] multiDimensionalArray = new int[3][];
+        multiDimensionalArray[0] = new int[] { 1, 2 };
+        multiDimensionalArray[1] = new int[] { 3, 4, 5 };
+        multiDimensionalArray[2] = new int[] { 6, 7, 8, 9 };
+        return multiDimensionalArray;
+    }
+
+    int[][] declarationAndThenInitializationUsingUserInputs() {
+        int[][] multiDimensionalArray = new int[3][];
+        multiDimensionalArray[0] = new int[2];
+        multiDimensionalArray[1] = new int[3];
+        multiDimensionalArray[2] = new int[4];
+        initializeElements(multiDimensionalArray);
+        return multiDimensionalArray;
+    }
+
+    void initializeElements(int[][] multiDimensionalArray) {
+        Scanner sc = new Scanner(System.in);
+        for (int outer = 0; outer < multiDimensionalArray.length; outer++) {
+            for (int inner = 0; inner < multiDimensionalArray[outer].length; inner++) {
+                multiDimensionalArray[outer][inner] = sc.nextInt();
+            }
+        }
+    }
+
+    void initialize2DArray(int[][] multiDimensionalArray) {
+        for (int[] array : multiDimensionalArray) {
+            Arrays.fill(array, 7);
+        }
+    }
+
+    void printElements(int[][] multiDimensionalArray) {
+        for (int index = 0; index < multiDimensionalArray.length; index++) {
+            System.out.println(Arrays.toString(multiDimensionalArray[index]));
+        }
+    }
+
+    int[] getElementAtGivenIndex(int[][] multiDimensionalArray, int index) {
+        return multiDimensionalArray[index];
+    }
+
+    int[] findLengthOfElements(int[][] multiDimensionalArray) {
+        int[] arrayOfLengths = new int[multiDimensionalArray.length];
+        for (int i = 0; i < multiDimensionalArray.length; i++) {
+            arrayOfLengths[i] = multiDimensionalArray[i].length;
+        }
+        return arrayOfLengths;
+    }
+
+    Integer[] findLengthOfElements(Integer[][] multiDimensionalArray) {
+        return Arrays.stream(multiDimensionalArray)
+          .map(array -> array.length)
+          .toArray(Integer[]::new);
+    }
+
+    int[][] copy2DArray(int[][] arrayOfArrays) {
+        int[][] copied2DArray = new int[arrayOfArrays.length][];
+        for (int i = 0; i < arrayOfArrays.length; i++) {
+            int[] array = arrayOfArrays[i];
+            copied2DArray[i] = Arrays.copyOf(array, array.length);
+        }
+        return copied2DArray;
+    }
+
+    Integer[][] copy2DArray(Integer[][] arrayOfArrays) {
+        return Arrays.stream(arrayOfArrays)
+          .map(array -> Arrays.copyOf(array, array.length))
+          .toArray(Integer[][]::new);
+    }
+}

core-java-modules/core-java-arrays/src/main/java/com/baeldung/array/RemoveElementFromAnArray.java

@@ -0,0 +1,27 @@
+package com.baeldung.array;
+
+import org.apache.commons.lang3.ArrayUtils;
+
+public class RemoveElementFromAnArray {
+
+    public int[] removeAnElementWithAGivenIndex(int[] array, int index) {
+        return ArrayUtils.remove(array, index);
+    }
+
+    public int[] removeAllElementsWithGivenIndices(int[] array, int... indicies) {
+        return ArrayUtils.removeAll(array, indicies);
+    }
+
+    public int[] removeFirstOccurrenceOfGivenElement(int[] array, int element) {
+        return ArrayUtils.removeElement(array, element);
+    }
+
+    public int[] removeAllGivenElements(int[] array, int... elements) {
+        return ArrayUtils.removeElements(array, elements);
+    }
+
+    public int[] removeAllOccurrencesOfAGivenElement(int[] array, int element) {
+        return ArrayUtils.removeAllOccurences(array, element);
+    }
+
+}

core-java-modules/core-java-arrays/src/main/java/com/baeldung/array/SearchArrayUnitTest.java

@@ -0,0 +1,96 @@
+package com.baeldung.array;
+
+import org.openjdk.jmh.annotations.*;
+
+import java.util.*;
+import java.util.concurrent.TimeUnit;
+
+@BenchmarkMode(Mode.AverageTime)
+@Warmup(iterations = 5)
+@OutputTimeUnit(TimeUnit.MICROSECONDS)
+public class SearchArrayUnitTest {
+
+    @State(Scope.Benchmark)
+    public static class SearchData {
+        static int count = 1000;
+        static String[] strings = seedArray(1000);
+    }
+
+
+    @Benchmark
+    public void searchArrayLoop() {
+        for (int i = 0; i < SearchData.count; i++) {
+            searchLoop(SearchData.strings, "T");
+        }
+    }
+
+    @Benchmark
+    public void searchArrayAllocNewList() {
+        for (int i = 0; i < SearchData.count; i++) {
+            searchList(SearchData.strings, "T");
+        }
+
+    }
+
+    @Benchmark
+    public void searchArrayAllocNewSet() {
+        for (int i = 0; i < SearchData.count; i++) {
+            searchSet(SearchData.strings, "T");
+        }
+    }
+
+
+    @Benchmark
+    public void searchArrayReuseList() {
+        List<String> asList = Arrays.asList(SearchData.strings);
+        for (int i = 0; i < SearchData.count; i++) {
+            asList.contains("T");
+        }
+    }
+
+
+    @Benchmark
+    public void searchArrayReuseSet() {
+        Set<String> asSet = new HashSet<>(Arrays.asList(SearchData.strings));
+        for (int i = 0; i < SearchData.count; i++) {
+            asSet.contains("T");
+        }
+    }
+
+
+    @Benchmark
+    public void searchArrayBinarySearch() {
+        Arrays.sort(SearchData.strings);
+        for (int i = 0; i < SearchData.count; i++) {
+            Arrays.binarySearch(SearchData.strings, "T");
+        }
+    }
+
+    private boolean searchList(String[] strings, String searchString) {
+      return Arrays.asList(strings).contains(searchString);
+  }
+
+    private boolean searchSet(String[] strings, String searchString) {
+        Set<String> set = new HashSet<>(Arrays.asList(strings));
+        return set.contains(searchString);
+    }
+
+    private boolean searchLoop(String[] strings, String searchString) {
+        for (String s : strings) {
+            if (s.equals(searchString))
+            return true;
+        }
+        return false;
+    }
+
+    private static String[] seedArray(int length) {
+        String[] strings = new String[length];
+        Random random = new Random();
+        for (int i = 0; i < length; i++)
+        {
+            strings[i] = String.valueOf(random.nextInt());
+        }
+        return strings;
+    }
+
+}

core-java-modules/core-java-arrays/src/main/java/com/baeldung/array/SortedArrayChecker.java

@@ -0,0 +1,65 @@
+package com.baeldung.array;
+
+import com.baeldung.arraycopy.model.Employee;
+
+import java.util.Comparator;
+
+public class SortedArrayChecker {
+
+    boolean isSorted(int[] array, int length) {
+        if (array == null || length < 2)
+            return true;
+
+        if (array[length - 2] > array[length - 1])
+            return false;
+
+        return isSorted(array, length - 1);
+    }
+
+    boolean isSorted(int[] array) {
+        for (int i = 0; i < array.length - 1; i++) {
+            if (array[i] > array[i + 1])
+                return false;
+        }
+
+        return true;
+    }
+
+    boolean isSorted(Comparable[] array, int length) {
+        if (array == null || length < 2)
+            return true;
+
+        if (array[length - 2].compareTo(array[length - 1]) > 0)
+            return false;
+
+        return isSorted(array, length - 1);
+    }
+
+    boolean isSorted(Comparable[] array) {
+        for (int i = 0; i < array.length - 1; ++i) {
+            if (array[i].compareTo(array[i + 1]) > 0)
+                return false;
+        }
+
+        return true;
+    }
+
+    boolean isSorted(Object[] array, Comparator comparator) {
+        for (int i = 0; i < array.length - 1; ++i) {
+            if (comparator.compare(array[i], (array[i + 1])) > 0)
+                return false;
+        }
+
+        return true;
+    }
+
+    boolean isSorted(Object[] array, Comparator comparator, int length) {
+        if (array == null || length < 2)
+            return true;
+
+        if (comparator.compare(array[length - 2], array[length - 1]) > 0)
+            return false;
+
+        return isSorted(array, comparator, length - 1);
+    }
+}

core-java-modules/core-java-arrays/src/main/java/com/baeldung/array/SumAndAverageInArray.java

@@ -0,0 +1,31 @@
+package com.baeldung.array;
+
+import java.util.Arrays;
+
+public class SumAndAverageInArray {
+
+    public static int findSumWithoutUsingStream(int[] array) {
+        int sum = 0;
+        for (int value : array) {
+            sum += value;
+        }
+        return sum;
+    }
+
+    public static int findSumUsingStream(int[] array) {
+        return Arrays.stream(array).sum();
+    }
+
+    public static int findSumUsingStream(Integer[] array) {
+        return Arrays.stream(array).mapToInt(Integer::intValue).sum();
+    }
+
+    public static double findAverageWithoutUsingStream(int[] array) {
+        int sum = findSumWithoutUsingStream(array);
+        return (double) sum / array.length;
+    }
+
+    public static double findAverageUsingStream(int[] array) {
+        return Arrays.stream(array).average().orElse(Double.NaN);
+    }
+}

core-java-modules/core-java-arrays/src/main/java/com/baeldung/array/conversions/FloatToByteArray.java

@@ -0,0 +1,44 @@
+package com.baeldung.array.conversions;
+
+import java.nio.ByteBuffer;
+
+public class FloatToByteArray {
+    
+    /**
+     * convert float into byte array using Float API floatToIntBits 
+     * @param value
+     * @return byte[]
+     */
+    public static byte[] floatToByteArray(float value) {
+        int intBits =  Float.floatToIntBits(value);
+        return new byte[] {(byte) (intBits >> 24), (byte) (intBits >> 16), (byte) (intBits >> 8), (byte) (intBits) };
+    }
+    
+    /**
+     * convert byte array into float using Float API intBitsToFloat
+     * @param bytes
+     * @return float
+     */
+    public static float byteArrayToFloat(byte[] bytes) {
+        int intBits =  bytes[0] << 24 | (bytes[1] & 0xFF) << 16 | (bytes[2] & 0xFF) << 8 | (bytes[3] & 0xFF);
+        return Float.intBitsToFloat(intBits);
+    }
+    
+    /**
+     * convert float into byte array using ByteBuffer
+     * @param value
+     * @return byte[]
+     */
+    public static byte[] floatToByteArrayWithByteBuffer(float value) {
+        return ByteBuffer.allocate(4).putFloat(value).array();
+    }
+    
+    /**
+     * convert byte array into float using ByteBuffer
+     * @param bytes
+     * @return float
+     */
+    public static float byteArrayToFloatWithByteBuffer(byte[] bytes) {
+        return ByteBuffer.wrap(bytes).getFloat();
+    }
+}

core-java-modules/core-java-arrays/src/main/java/com/baeldung/array/operations/ArrayOperations.java

@@ -0,0 +1,211 @@
+package com.baeldung.array.operations;
+
+import java.lang.reflect.Array;
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.LinkedHashSet;
+import java.util.LinkedList;
+import java.util.Random;
+import java.util.Set;
+import java.util.function.Function;
+import java.util.function.IntPredicate;
+import java.util.function.Predicate;
+import java.util.stream.Stream;
+
+import org.apache.commons.lang3.ArrayUtils;
+
+public class ArrayOperations {
+
+    // Get the first and last item of an array
+    public static <T> T getFirstObject(T[] array) {
+        return array[0];
+    }
+
+    public static int getFirstInt(int[] array) {
+        return array[0];
+    }
+
+    public static <T> T getLastObject(T[] array) {
+        return array[array.length - 1];
+    }
+
+    public static int getLastInt(int[] array) {
+        return array[array.length - 1];
+    }
+
+    // Append a new item to an array
+    public static <T> T[] appendObject(T[] array, T newItem) {
+        return ArrayUtils.add(array, newItem);
+    }
+
+    public static int[] appendInt(int[] array, int newItem) {
+        int[] newArray = Arrays.copyOf(array, array.length + 1);
+        newArray[newArray.length - 1] = newItem;
+        return newArray;
+    }
+
+    public static int[] appendIntWithUtils(int[] array, int newItem) {
+        return ArrayUtils.add(array, newItem);
+    }
+
+    // Compare two arrays to check if they have the same elements
+    public static <T> boolean compareObjectArrays(T[] array1, T[] array2) {
+        return Arrays.equals(array1, array2);
+    }
+
+    public static boolean compareIntArrays(int[] array1, int[] array2) {
+        return Arrays.equals(array1, array2);
+    }
+
+    // Deep Compare (for nested arrays)
+    public static <T> boolean deepCompareObjectArrayUsingArrays(T[][] array1, T[][] array2) {
+        // We can use Objects.deepEquals for a broader approach
+        return Arrays.deepEquals(array1, array2);
+    }
+
+    public static boolean deepCompareIntArrayUsingArrays(int[][] array1, int[][] array2) {
+        return Arrays.deepEquals(array1, array2);
+    }
+
+    // Check if array is empty
+    public static <T> boolean isEmptyObjectArrayUsingUtils(T[] array1) {
+        return ArrayUtils.isEmpty(array1);
+    }
+
+    public static boolean isEmptyIntArrayUsingUtils(int[] array1) {
+        return ArrayUtils.isEmpty(array1);
+    }
+
+    // Remove duplicates
+    public static Integer[] removeDuplicateObjects(Integer[] array) {
+        // We can use other ways of converting the array to a set too
+        Set<Integer> set = new HashSet<>(Arrays.asList(array));
+        return set.toArray(new Integer[set.size()]);
+    }
+
+    public static int[] removeDuplicateInts(int[] array) {
+        // Box
+        Integer[] list = ArrayUtils.toObject(array);
+        // Remove duplicates
+        Set<Integer> set = new HashSet<Integer>(Arrays.asList(list));
+        // Create array and unbox
+        return ArrayUtils.toPrimitive(set.toArray(new Integer[set.size()]));
+    }
+
+    // Remove duplicates preserving the order
+    public static Integer[] removeDuplicateWithOrderObjectArray(Integer[] array) {
+        // We can use other ways of converting the array to a set too
+        Set<Integer> set = new LinkedHashSet<>(Arrays.asList(array));
+        return set.toArray(new Integer[set.size()]);
+    }
+
+    public static int[] removeDuplicateWithOrderIntArray(int[] array) {
+        // Box
+        Integer[] list = ArrayUtils.toObject(array);
+        // Remove duplicates
+        Set<Integer> set = new LinkedHashSet<Integer>(Arrays.asList(list));
+        // Create array and unbox
+        return ArrayUtils.toPrimitive(set.toArray(new Integer[set.size()]));
+    }
+
+    // Print an array
+    public static String printObjectArray(Integer[] array) {
+        return ArrayUtils.toString(array);
+    }
+
+    public static String printObjectArray(Integer[][] array) {
+        return ArrayUtils.toString(array);
+    }
+
+    public static String printIntArray(int[] array) {
+        return ArrayUtils.toString(array);
+    }
+
+    public static String printIntArray(int[][] array) {
+        return ArrayUtils.toString(array);
+    }
+
+    // Box or Unbox values
+    public static int[] unboxIntegerArray(Integer[] array) {
+        return ArrayUtils.toPrimitive(array);
+    }
+
+    public static Integer[] boxIntArray(int[] array) {
+        return ArrayUtils.toObject(array);
+    }
+
+    // Map array values
+    @SuppressWarnings("unchecked")
+    public static <T, U> U[] mapObjectArray(T[] array, Function<T, U> function, Class<U> targetClazz) {
+        U[] newArray = (U[]) Array.newInstance(targetClazz, array.length);
+        for (int i = 0; i < array.length; i++) {
+            newArray[i] = function.apply(array[i]);
+        }
+        return newArray;
+    }
+
+    public static String[] mapIntArrayToString(int[] array) {
+        return Arrays.stream(array)
+            .mapToObj(value -> String.format("Value: %s", value))
+            .toArray(String[]::new);
+    }
+
+    // Filter array values
+    public static Integer[] filterObjectArray(Integer[] array, Predicate<Integer> predicate) {
+        return Arrays.stream(array)
+            .filter(predicate)
+            .toArray(Integer[]::new);
+    }
+
+    public static int[] filterIntArray(int[] array, IntPredicate predicate) {
+        return Arrays.stream(array)
+            .filter(predicate)
+            .toArray();
+    }
+
+    // Insert item between others
+    public static int[] insertBetweenIntArray(int[] array, int... values) {
+        return ArrayUtils.insert(2, array, values);
+    }
+
+    @SuppressWarnings("unchecked")
+    public static <T> T[] insertBetweenObjectArray(T[] array, T... values) {
+        return ArrayUtils.insert(2, array, values);
+    }
+
+    // Shuffling arrays
+    public static int[] shuffleIntArray(int[] array) {
+        // we create a different array instance for testing purposes
+        int[] shuffled = Arrays.copyOf(array, array.length);
+        ArrayUtils.shuffle(shuffled);
+        return shuffled;
+    }
+
+    public static <T> T[] shuffleObjectArray(T[] array) {
+        // we create a different array instance for testing purposes
+        T[] shuffled = Arrays.copyOf(array, array.length);
+        ArrayUtils.shuffle(shuffled);
+        return shuffled;
+    }
+
+    // Get random number
+    public static int getRandomFromIntArray(int[] array) {
+        return array[new Random().nextInt(array.length)];
+    }
+
+    public static <T> T getRandomFromObjectArray(T[] array) {
+        return array[new Random().nextInt(array.length)];
+    }
+
+    public static Integer[] intersectionSimple(final Integer[] a, final Integer[] b){
+        return Stream.of(a).filter(Arrays.asList(b)::contains).toArray(Integer[]::new);
+    }
+
+    public static Integer[] intersectionSet(final Integer[] a, final Integer[] b){
+        return Stream.of(a).filter(Arrays.asList(b)::contains).distinct().toArray(Integer[]::new);
+    }
+
+    public static Integer[] intersectionMultiSet(final Integer[] a, final Integer[] b){
+        return Stream.of(a).filter(new LinkedList<>(Arrays.asList(b))::remove).toArray(Integer[]::new);
+    }
+}

core-java-modules/core-java-arrays/src/main/java/com/baeldung/arraycopy/model/Address.java

@@ -0,0 +1,61 @@
+package com.baeldung.arraycopy.model;
+
+public class Address implements Cloneable {
+    private String country;
+    private String state;
+    private String city;
+    private String street;
+    private String zipcode;
+
+    public String getCountry() {
+        return country;
+    }
+
+    public void setCountry(String country) {
+        this.country = country;
+    }
+
+    public String getState() {
+        return state;
+    }
+
+    public void setState(String state) {
+        this.state = state;
+    }
+
+    public String getCity() {
+        return city;
+    }
+
+    public void setCity(String city) {
+        this.city = city;
+    }
+
+    public String getStreet() {
+        return street;
+    }
+
+    public void setStreet(String street) {
+        this.street = street;
+    }
+
+    public String getZipcode() {
+        return zipcode;
+    }
+
+    public void setZipcode(String zipcode) {
+        this.zipcode = zipcode;
+    }
+
+    @Override
+    protected Object clone() throws CloneNotSupportedException {
+        super.clone();
+        Address address = new Address();
+        address.setCity(this.city);
+        address.setCountry(this.country);
+        address.setState(this.state);
+        address.setStreet(this.street);
+        address.setZipcode(this.zipcode);
+        return address;
+    }
+}

core-java-modules/core-java-arrays/src/main/java/com/baeldung/arraycopy/model/Employee.java

@@ -0,0 +1,48 @@
+package com.baeldung.arraycopy.model;
+
+import java.io.Serializable;
+
+public class Employee implements Serializable {
+    private static final long serialVersionUID = -2454619097207585825L;
+    private int id;
+    private String name;
+    private int age;
+
+    public Employee() {
+    }
+
+    public Employee(int id, String name) {
+        this.id = id;
+        this.name = name;
+    }
+
+    public Employee(int id, String name, int age) {
+        this.id = id;
+        this.name = name;
+        this.age = age;
+    }
+
+    public int getAge() {
+        return age;
+    }
+
+    public int getId() {
+        return id;
+    }
+
+    public void setAge(int age) {
+        this.age = age;
+    }
+
+    public void setId(int id) {
+        this.id = id;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+}

core-java-modules/core-java-arrays/src/main/java/com/baeldung/arrays/ParallelPrefixBenchmark.java

@@ -0,0 +1,44 @@
+package com.baeldung.arrays;
+
+import org.openjdk.jmh.annotations.*;
+import org.openjdk.jmh.infra.Blackhole;
+
+import java.util.Arrays;
+
+public class ParallelPrefixBenchmark {
+  private static final int ARRAY_SIZE = 200_000_000;
+
+  @State(Scope.Benchmark)
+  public static class BigArray {
+
+    int[] data;
+
+    @Setup(Level.Iteration)
+    public void prepare() {
+      data = new int[ARRAY_SIZE];
+      for(int j = 0; j< ARRAY_SIZE; j++) {
+        data[j] = 1;
+      }
+    }
+
+    @TearDown(Level.Iteration)
+    public void destroy() {
+      data = null;
+    }
+
+  }
+
+  @Benchmark
+  public void largeArrayLoopSum(BigArray bigArray, Blackhole blackhole) {
+    for (int i = 0; i < ARRAY_SIZE - 1; i++) {
+      bigArray.data[i + 1] += bigArray.data[i];
+    }
+    blackhole.consume(bigArray.data);
+  }
+
+  @Benchmark
+  public void largeArrayParallelPrefixSum(BigArray bigArray, Blackhole blackhole) {
+    Arrays.parallelPrefix(bigArray.data, (left, right) -> left + right);
+    blackhole.consume(bigArray.data);
+  }
+}

core-java-modules/core-java-arrays/src/test/java/com/baeldung/array/AddElementToEndOfArrayUnitTest.java

@@ -0,0 +1,49 @@
+package com.baeldung.array;
+
+import org.junit.Before;
+import org.junit.Test;
+
+import static org.junit.Assert.assertArrayEquals;
+
+public class AddElementToEndOfArrayUnitTest {
+
+    AddElementToEndOfArray addElementToEndOfArray;
+
+    @Before
+    public void init() {
+        addElementToEndOfArray = new AddElementToEndOfArray();
+    }
+
+    @Test
+    public void givenSourceArrayAndElement_whenAddElementUsingArraysCopyIsInvoked_thenNewElementMustBeAdded() {
+        Integer[] sourceArray = {1, 2, 3, 4};
+        int elementToAdd = 5;
+
+        Integer[] destArray = addElementToEndOfArray.addElementUsingArraysCopyOf(sourceArray, elementToAdd);
+
+        Integer[] expectedArray = {1, 2, 3, 4, 5};
+        assertArrayEquals(expectedArray, destArray);
+    }
+
+    @Test
+    public void givenSourceArrayAndElement_whenAddElementUsingArrayListIsInvoked_thenNewElementMustBeAdded() {
+        Integer[] sourceArray = {1, 2, 3, 4};
+        int elementToAdd = 5;
+
+        Integer[] destArray = addElementToEndOfArray.addElementUsingArrayList(sourceArray, elementToAdd);
+
+        Integer[] expectedArray = {1, 2, 3, 4, 5};
+        assertArrayEquals(expectedArray, destArray);
+    }
+
+    @Test
+    public void givenSourceArrayAndElement_whenAddElementUsingSystemArrayCopyIsInvoked_thenNewElementMustBeAdded() {
+        Integer[] sourceArray = {1, 2, 3, 4};
+        int elementToAdd = 5;
+
+        Integer[] destArray = addElementToEndOfArray.addElementUsingSystemArrayCopy(sourceArray, elementToAdd);
+
+        Integer[] expectedArray = {1, 2, 3, 4, 5};
+        assertArrayEquals(expectedArray, destArray);
+    }
+}

core-java-modules/core-java-arrays/src/test/java/com/baeldung/array/ArrayInitializerUnitTest.java

@@ -0,0 +1,74 @@
+package com.baeldung.array;
+
+import static com.baeldung.array.ArrayInitializer.initializeArrayAtTimeOfDeclarationMethod1;
+import static com.baeldung.array.ArrayInitializer.initializeArrayAtTimeOfDeclarationMethod2;
+import static com.baeldung.array.ArrayInitializer.initializeArrayAtTimeOfDeclarationMethod3;
+import static com.baeldung.array.ArrayInitializer.initializeArrayInLoop;
+import static com.baeldung.array.ArrayInitializer.initializeArrayRangeUsingArraysFill;
+import static com.baeldung.array.ArrayInitializer.initializeArrayUsingArraysCopy;
+import static com.baeldung.array.ArrayInitializer.initializeArrayUsingArraysFill;
+import static com.baeldung.array.ArrayInitializer.initializeArrayUsingArraysSetAll;
+import static com.baeldung.array.ArrayInitializer.initializeArrayUsingArraysUtilClone;
+import static com.baeldung.array.ArrayInitializer.initializeLargerArrayUsingArraysCopy;
+import static com.baeldung.array.ArrayInitializer.initializeMultiDimensionalArrayInLoop;
+import static org.junit.Assert.assertArrayEquals;
+
+import org.junit.Test;
+
+public class ArrayInitializerUnitTest {
+
+    @Test
+    public void whenInitializeArrayInLoop_thenCorrect() {
+        assertArrayEquals(new int[] { 2, 3, 4, 5, 6 }, initializeArrayInLoop());
+    }
+
+    @Test
+    public void whenInitializeMultiDimensionalArrayInLoop_thenCorrect() {
+        assertArrayEquals(new int[][] { { 1, 2, 3, 4, 5 }, { 1, 2, 3, 4, 5 } }, initializeMultiDimensionalArrayInLoop());
+    }
+
+    @Test
+    public void whenInitializeArrayAtTimeOfDeclarationMethod1_thenCorrect() {
+        assertArrayEquals(new String[] { "Toyota", "Mercedes", "BMW", "Volkswagen", "Skoda" }, initializeArrayAtTimeOfDeclarationMethod1());
+    }
+
+    @Test
+    public void whenInitializeArrayAtTimeOfDeclarationMethod2_thenCorrect() {
+        assertArrayEquals(new int[] { 1, 2, 3, 4, 5 }, initializeArrayAtTimeOfDeclarationMethod2());
+    }
+
+    @Test
+    public void whenInitializeArrayAtTimeOfDeclarationMethod3_thenCorrect() {
+        assertArrayEquals(new int[] { 1, 2, 3, 4, 5 }, initializeArrayAtTimeOfDeclarationMethod3());
+    }
+
+    @Test
+    public void whenInitializeArrayUsingArraysFill_thenCorrect() {
+        assertArrayEquals(new long[] { 30, 30, 30, 30, 30 }, initializeArrayUsingArraysFill());
+    }
+
+    @Test
+    public void whenInitializeArrayRangeUsingArraysFill_thenCorrect() {
+        assertArrayEquals(new int[] { -50, -50, -50, 0, 0 }, initializeArrayRangeUsingArraysFill());
+    }
+
+    @Test
+    public void whenInitializeArrayRangeUsingArraysCopy_thenCorrect() {
+        assertArrayEquals(new int[] { 1, 2, 3, 4, 5 }, initializeArrayUsingArraysCopy());
+    }
+
+    @Test
+    public void whenInitializeLargerArrayRangeUsingArraysCopy_thenCorrect() {
+        assertArrayEquals(new int[] { 1, 2, 3, 4, 5, 0 }, initializeLargerArrayUsingArraysCopy());
+    }
+
+    @Test
+    public void whenInitializeLargerArrayRangeUsingArraysSetAll_thenCorrect() {
+        assertArrayEquals(new int[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, initializeArrayUsingArraysSetAll());
+    }
+
+    @Test
+    public void whenInitializeArrayUsingArraysUtilClone_thenCorrect() {
+        assertArrayEquals(new char[] { 'a', 'b', 'c' }, initializeArrayUsingArraysUtilClone());
+    }
+}

core-java-modules/core-java-arrays/src/test/java/com/baeldung/array/ArrayInverterUnitTest.java

@@ -0,0 +1,49 @@
+package com.baeldung.array;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import org.junit.Test;
+
+public class ArrayInverterUnitTest {
+
+    private String[] fruits = { "apples", "tomatoes", "bananas", "guavas", "pineapples", "oranges" };
+
+    @Test
+    public void invertArrayWithForLoop() {
+        ArrayInverter inverter = new ArrayInverter();
+        inverter.invertUsingFor(fruits);
+
+        assertThat(new String[] { "oranges", "pineapples", "guavas", "bananas", "tomatoes", "apples" }).isEqualTo(fruits);
+    }
+
+    @Test
+    public void invertArrayWithCollectionsReverse() {
+        ArrayInverter inverter = new ArrayInverter();
+        inverter.invertUsingCollectionsReverse(fruits);
+
+        assertThat(new String[] { "oranges", "pineapples", "guavas", "bananas", "tomatoes", "apples" }).isEqualTo(fruits);
+    }
+
+    @Test
+    public void invertArrayWithStreams() {
+        ArrayInverter inverter = new ArrayInverter();
+
+        assertThat(new String[] { "oranges", "pineapples", "guavas", "bananas", "tomatoes", "apples" }).isEqualTo(inverter.invertUsingStreams(fruits));
+    }
+
+    @Test
+    public void invertArrayWithCommonsLang() {
+        ArrayInverter inverter = new ArrayInverter();
+        inverter.invertUsingCommonsLang(fruits);
+
+        assertThat(new String[] { "oranges", "pineapples", "guavas", "bananas", "tomatoes", "apples" }).isEqualTo(fruits);
+    }
+
+    @Test
+    public void invertArrayWithGuava() {
+        ArrayInverter inverter = new ArrayInverter();
+
+        assertThat(new String[] { "oranges", "pineapples", "guavas", "bananas", "tomatoes", "apples" }).isEqualTo(inverter.invertUsingGuava(fruits));
+    }
+
+}

core-java-modules/core-java-arrays/src/test/java/com/baeldung/array/Find2ndLargestInArrayUnitTest.java

@@ -0,0 +1,16 @@
+package com.baeldung.array;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+public class Find2ndLargestInArrayUnitTest {
+    @Test
+    public void givenAnIntArray_thenFind2ndLargestElement() {
+        int[] array = { 1, 3, 24, 16, 87, 20 };
+        int expected2ndLargest = 24;
+
+        int actualSecondLargestElement = Find2ndLargestInArray.find2ndLargestElement(array);
+
+        Assert.assertEquals(expected2ndLargest, actualSecondLargestElement);
+    }
+}

core-java-modules/core-java-arrays/src/test/java/com/baeldung/array/FindElementInArrayUnitTest.java

@@ -0,0 +1,35 @@
+package com.baeldung.array;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+public class FindElementInArrayUnitTest {
+    @Test
+    public void givenAnIntArray_whenNotUsingStream_thenFindAnElement() {
+        int[] array = { 1, 3, 4, 8, 19, 20 };
+        int element = 19;
+        boolean expectedResult = true;
+        boolean actualResult = FindElementInArray.findGivenElementInArrayWithoutUsingStream(array, element);
+        Assert.assertEquals(expectedResult, actualResult);
+
+        element = 78;
+        expectedResult = false;
+        actualResult = FindElementInArray.findGivenElementInArrayWithoutUsingStream(array, element);
+        Assert.assertEquals(expectedResult, actualResult);
+    }
+
+    @Test
+    public void givenAnIntArray_whenUsingStream_thenFindAnElement() {
+        int[] array = { 15, 16, 12, 18 };
+        int element = 16;
+        boolean expectedResult = true;
+        boolean actualResult = FindElementInArray.findGivenElementInArrayUsingStream(array, element);
+        Assert.assertEquals(expectedResult, actualResult);
+
+        element = 20;
+        expectedResult = false;
+        actualResult = FindElementInArray.findGivenElementInArrayUsingStream(array, element);
+        Assert.assertEquals(expectedResult, actualResult);
+    }
+
+}

core-java-modules/core-java-arrays/src/test/java/com/baeldung/array/MultiDimensionalArrayUnitTest.java

@@ -0,0 +1,86 @@
+package com.baeldung.array;
+
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.Assert.assertEquals;
+
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.InputStream;
+import java.io.PrintStream;
+
+import org.junit.Test;
+
+public class MultiDimensionalArrayUnitTest {
+
+    private MultiDimensionalArray obj = new MultiDimensionalArray();
+
+    @Test
+    public void whenInitializedUsingShortHandForm_thenCorrect() {
+        assertArrayEquals(new int[][] { { 1, 2 }, { 3, 4, 5 }, { 6, 7, 8, 9 } }, obj.shortHandFormInitialization());
+    }
+
+    @Test
+    public void whenInitializedWithDeclarationAndThenInitalization_thenCorrect() {
+        assertArrayEquals(new int[][] { { 1, 2 }, { 3, 4, 5 }, { 6, 7, 8, 9 } }, obj.declarationAndThenInitialization());
+    }
+
+    @Test
+    public void whenInitializedWithDeclarationAndThenInitalizationUsingUserInputs_thenCorrect() {
+        InputStream is = new ByteArrayInputStream("1 2 3 4 5 6 7 8 9".getBytes());
+        System.setIn(is);
+        assertArrayEquals(new int[][] { { 1, 2 }, { 3, 4, 5 }, { 6, 7, 8, 9 } }, obj.declarationAndThenInitializationUsingUserInputs());
+        System.setIn(System.in);
+    }
+
+    @Test
+    public void givenMultiDimensionalArrayAndAnIndex_thenReturnArrayAtGivenIndex() {
+        int[][] multiDimensionalArr = { { 1, 2 }, { 3, 4, 5 }, { 6, 7, 8, 9 } };
+        assertArrayEquals(new int[] { 1, 2 }, obj.getElementAtGivenIndex(multiDimensionalArr, 0));
+        assertArrayEquals(new int[] { 3, 4, 5 }, obj.getElementAtGivenIndex(multiDimensionalArr, 1));
+        assertArrayEquals(new int[] { 6, 7, 8, 9 }, obj.getElementAtGivenIndex(multiDimensionalArr, 2));
+    }
+
+    @Test
+    public void givenMultiDimensionalArray_whenUsingArraysAPI_thenVerifyPrintedElements() {
+        int[][] multiDimensionalArr = { { 1, 2 }, { 3, 4, 5 }, { 6, 7, 8, 9 } };
+        ByteArrayOutputStream outContent = new ByteArrayOutputStream();
+        System.setOut(new PrintStream(outContent));
+        obj.printElements(multiDimensionalArr);
+        assertEquals("[1, 2][3, 4, 5][6, 7, 8, 9]", outContent.toString().replace("\r", "").replace("\n", ""));
+        System.setOut(System.out);
+    }
+
+    @Test
+    public void givenMultiDimensionalArray_whenUsingArraysFill_thenVerifyInitialize2DArray() {
+        int[][] multiDimensionalArr = new int[3][];
+        multiDimensionalArr[0] = new int[2];
+        multiDimensionalArr[1] = new int[3];
+        multiDimensionalArr[2] = new int[4];
+        obj.initialize2DArray(multiDimensionalArr);
+        assertArrayEquals(new int[][] {{7,7}, {7,7,7}, {7,7,7,7}}, multiDimensionalArr);
+    }
+    
+    @Test
+    public void givenMultiDimensionalArray_whenUsingIteration_thenVerifyFindLengthOfElements() {
+        int[][] multiDimensionalArr = { { 1, 2 }, { 3, 4, 5 }, { 6, 7, 8, 9 } };
+        assertArrayEquals(new int[]{2,3,4}, obj.findLengthOfElements(multiDimensionalArr));
+    }
+    
+    @Test
+    public void givenMultiDimensionalArray_whenUsingArraysStream_thenVerifyFindLengthOfElements() {
+        Integer[][] multiDimensionalArr = { { 1, 2 }, { 3, 4, 5 }, { 6, 7, 8, 9 } };
+        assertArrayEquals(new Integer[]{2,3,4}, obj.findLengthOfElements(multiDimensionalArr));
+    }
+    
+    @Test
+    public void givenMultiDimensionalArray_whenUsingArraysCopyOf_thenVerifyCopy2DArray() {
+        int[][] multiDimensionalArr = { { 1, 2 }, { 3, 4, 5 }, { 6, 7, 8, 9 } };
+        assertArrayEquals(multiDimensionalArr, obj.copy2DArray(multiDimensionalArr));
+    }
+    
+    @Test
+    public void givenMultiDimensionalArray_whenUsingArraysStream_thenVerifyCopy2DArray() {
+        Integer[][] multiDimensionalArr = { { 1, 2 }, { 3, 4, 5 }, { 6, 7, 8, 9 } };
+        assertArrayEquals(multiDimensionalArr, obj.copy2DArray(multiDimensionalArr));
+    }
+}

core-java-modules/core-java-arrays/src/test/java/com/baeldung/array/RemoveElementFromAnArrayUnitTest.java

@@ -0,0 +1,85 @@
+package com.baeldung.array;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import org.apache.commons.lang3.ArrayUtils;
+import org.junit.jupiter.api.Test;
+
+class RemoveElementFromAnArrayUnitTest {
+
+    private final RemoveElementFromAnArray sut = new RemoveElementFromAnArray();
+    private final int[] inputArray = new int[] { 40, 10, 20, 30, 40, 50 };
+
+    @Test
+    void testRemoveAnElementWithAGivenIndex() {
+        int index = 2;
+        int[] modifiedArray = sut.removeAnElementWithAGivenIndex(inputArray, index);
+
+        assertFalse(ArrayUtils.contains(modifiedArray, inputArray[index]));
+    }
+
+    @Test
+    void testRemoveAllElementsWithGivenIndices() {
+        int first = 0;
+        int last = inputArray.length - 1;
+        int[] modifiedArray = sut.removeAllElementsWithGivenIndices(inputArray, first, last);
+
+        assertFalse(ArrayUtils.contains(modifiedArray, inputArray[first]) && ArrayUtils.contains(modifiedArray, inputArray[last]));
+    }
+
+    @Test
+    void testRemoveElement_WhenArrayIsNull_ThrowsIndexOutOfBoundEx() {
+        int index = 2;
+
+        assertThrows(IndexOutOfBoundsException.class, () -> {
+            sut.removeAnElementWithAGivenIndex(null, index);
+        });
+
+        assertThrows(IndexOutOfBoundsException.class, () -> {
+            sut.removeAllElementsWithGivenIndices(null, index);
+        });
+    }
+
+    @Test
+    void testRemoveFirstOccurrenceOfGivenElement() {
+        int element = 40;
+        int[] modifiedArray = sut.removeFirstOccurrenceOfGivenElement(inputArray, element);
+
+        int indexInInputArray = ArrayUtils.indexOf(inputArray, element);
+        int indexInModifiedArray = ArrayUtils.indexOf(modifiedArray, element);
+        assertFalse(indexInInputArray == indexInModifiedArray);
+    }
+
+    @Test
+    void testRemoveAllGivenElements() {
+        int duplicateElement = 40;
+        int[] elements = new int[] { duplicateElement, 10, 50 };
+        int[] modifiedArray = sut.removeAllGivenElements(inputArray, elements);
+
+        assertTrue(ArrayUtils.contains(modifiedArray, duplicateElement));
+        assertFalse(ArrayUtils.contains(modifiedArray, elements[1]));
+        assertFalse(ArrayUtils.contains(modifiedArray, elements[2]));
+    }
+
+    @Test
+    void testRemoveAllOccurrencesOfAGivenElement() {
+        int element = 40;
+        int[] modifiedArray = sut.removeAllOccurrencesOfAGivenElement(inputArray, element);
+
+        assertFalse(ArrayUtils.contains(modifiedArray, element));
+    }
+
+    @Test
+    void testRemoveElement_WhenArrayIsNull_ReturnsNull() {
+        int element = 20;
+
+        assertEquals(null, sut.removeFirstOccurrenceOfGivenElement(null, element));
+        assertEquals(null, sut.removeAllGivenElements(null, element));
+        assertEquals(null, sut.removeAllOccurrencesOfAGivenElement(null, element));
+
+    }
+
+}

core-java-modules/core-java-arrays/src/test/java/com/baeldung/array/SortedArrayCheckerUnitTest.java

@@ -0,0 +1,79 @@
+package com.baeldung.array;
+
+import com.baeldung.arraycopy.model.Employee;
+import org.junit.Before;
+import org.junit.Test;
+
+import java.util.Comparator;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class SortedArrayCheckerUnitTest {
+    private static final int[] INTEGER_SORTED = {1, 3, 5, 7, 9};
+    private static final int[] INTEGER_NOT_SORTED = {1, 3, 11, 7};
+
+    private static final String[] STRING_SORTED = {"abc", "cde", "fgh"};
+    private static final String[] STRING_NOT_SORTED = {"abc", "fgh", "cde", "ijk"};
+
+    private static final Employee[] EMPLOYEES_SORTED_BY_NAME = {
+            new Employee(1, "Carlos", 26),
+            new Employee(2, "Daniel", 31),
+            new Employee(3, "Marta", 27)};
+
+    private static final Employee[] EMPLOYEES_NOT_SORTED_BY_NAME = {
+            new Employee(1, "Daniel", 31),
+            new Employee(2, "Carlos", 26),
+            new Employee(3, "Marta", 27)};
+
+    private static final Employee[] EMPLOYEES_SORTED_BY_AGE = {
+            new Employee(1, "Carlos", 26),
+            new Employee(2, "Marta", 27),
+            new Employee(3, "Daniel", 31)};
+
+    private static final Employee[] EMPLOYEES_NOT_SORTED_BY_AGE = {
+            new Employee(1, "Marta", 27),
+            new Employee(2, "Carlos", 26),
+            new Employee(3, "Daniel", 31)};
+
+    private SortedArrayChecker sortedArrayChecker;
+
+    @Before
+    public void setup() {
+        sortedArrayChecker = new SortedArrayChecker();
+    }
+
+    @Test
+    public void givenIntegerArray_thenReturnIfItIsSortedOrNot() {
+        assertThat(sortedArrayChecker.isSorted(INTEGER_SORTED)).isEqualTo(true);
+        assertThat(sortedArrayChecker.isSorted(INTEGER_NOT_SORTED)).isEqualTo(false);
+
+        assertThat(sortedArrayChecker.isSorted(INTEGER_SORTED, INTEGER_SORTED.length)).isEqualTo(true);
+        assertThat(sortedArrayChecker.isSorted(INTEGER_NOT_SORTED, INTEGER_NOT_SORTED.length)).isEqualTo(false);
+    }
+
+    @Test
+    public void givenStringArray_thenReturnIfItIsSortedOrNot() {
+        assertThat(sortedArrayChecker.isSorted(STRING_SORTED)).isEqualTo(true);
+        assertThat(sortedArrayChecker.isSorted(STRING_NOT_SORTED)).isEqualTo(false);
+
+        assertThat(sortedArrayChecker.isSorted(STRING_SORTED, STRING_SORTED.length)).isEqualTo(true);
+        assertThat(sortedArrayChecker.isSorted(STRING_NOT_SORTED, STRING_NOT_SORTED.length)).isEqualTo(false);
+    }
+
+    @Test
+    public void givenEmployeeArray_thenReturnIfItIsSortedOrNot() {
+        assertThat(sortedArrayChecker.isSorted(EMPLOYEES_SORTED_BY_NAME, Comparator.comparing(Employee::getName))).isEqualTo(true);
+        assertThat(sortedArrayChecker.isSorted(EMPLOYEES_NOT_SORTED_BY_NAME, Comparator.comparing(Employee::getName))).isEqualTo(false);
+
+        assertThat(sortedArrayChecker.isSorted(EMPLOYEES_SORTED_BY_AGE, Comparator.comparingInt(Employee::getAge))).isEqualTo(true);
+        assertThat(sortedArrayChecker.isSorted(EMPLOYEES_NOT_SORTED_BY_AGE, Comparator.comparingInt(Employee::getAge))).isEqualTo(false);
+
+        assertThat(sortedArrayChecker
+                .isSorted(EMPLOYEES_SORTED_BY_AGE, Comparator.comparingInt(Employee::getAge), EMPLOYEES_SORTED_BY_AGE.length))
+                .isEqualTo(true);
+        assertThat(sortedArrayChecker
+                .isSorted(EMPLOYEES_NOT_SORTED_BY_AGE, Comparator.comparingInt(Employee::getAge), EMPLOYEES_NOT_SORTED_BY_AGE.length))
+                .isEqualTo(false);
+    }
+
+}

core-java-modules/core-java-arrays/src/test/java/com/baeldung/array/SumAndAverageInArrayUnitTest.java

@@ -0,0 +1,59 @@
+package com.baeldung.array;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+public class SumAndAverageInArrayUnitTest {
+    @Test
+    public void givenAnIntArray_whenNotUsingStream_thenFindSum() {
+        int[] array = { 1, 3, 4, 8, 19, 20 };
+        int expectedSumOfArray = 55;
+        int actualSumOfArray = SumAndAverageInArray.findSumWithoutUsingStream(array);
+        Assert.assertEquals(expectedSumOfArray, actualSumOfArray);
+    }
+
+    @Test
+    public void givenAnIntArray_whenUsingStream_thenFindSum() {
+        int[] array = { 1, 3, 4, 8, 19, 20 };
+        int expectedSumOfArray = 55;
+        int actualSumOfArray = SumAndAverageInArray.findSumUsingStream(array);
+
+        Assert.assertEquals(expectedSumOfArray, actualSumOfArray);
+    }
+
+    @Test
+    public void givenAnBoxedIntegerArray_whenUsingStream_thenFindSum() {
+        Integer[] array = new Integer[]{1, 3, 4, 8, 19, 20};
+        int expectedSumOfArray = 55;
+        int actualSumOfArray = SumAndAverageInArray.findSumUsingStream(array);
+
+        Assert.assertEquals(expectedSumOfArray, actualSumOfArray);
+    }
+
+    @Test
+    public void givenAnIntArray_whenNotUsingStream_thenFindAverage() {
+        int[] array = { 1, 3, 4, 8, 19, 20 };
+        double expectedAvgOfArray = 9.17;
+        double actualAvgOfArray = SumAndAverageInArray.findAverageWithoutUsingStream(array);
+
+        Assert.assertEquals(expectedAvgOfArray, actualAvgOfArray, 0.0034);
+    }
+
+    @Test
+    public void givenAnIntArray_whenUsingStream_thenFindAverage() {
+        int[] array = { 1, 3, 4, 8, 19, 20 };
+        double expectedAvgOfArray = 9.17;
+        double actualAvgOfArray = SumAndAverageInArray.findAverageUsingStream(array);
+
+        Assert.assertEquals(expectedAvgOfArray, actualAvgOfArray, 0.0034);
+    }
+
+    @Test
+    public void givenAnEmptyIntArray_whenUsingStream_thenFindAverage() {
+        int[] array = {};
+        double expectedAvgOfArray = Double.NaN;
+        double actualAvgOfArray = SumAndAverageInArray.findAverageUsingStream(array);
+
+        Assert.assertEquals(expectedAvgOfArray, actualAvgOfArray, 0.00);
+    }
+}

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

@@ -0,0 +1,46 @@
+package com.baeldung.array.conversions;
+
+import static com.baeldung.array.conversions.FloatToByteArray.byteArrayToFloat;
+import static com.baeldung.array.conversions.FloatToByteArray.byteArrayToFloatWithByteBuffer;
+import static com.baeldung.array.conversions.FloatToByteArray.floatToByteArray;
+import static com.baeldung.array.conversions.FloatToByteArray.floatToByteArrayWithByteBuffer;
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.Assert.assertEquals;
+import org.junit.Test;
+
+public class FloatToByteArrayUnitTest {
+
+    @Test
+    public void givenAFloat_thenConvertToByteArray() {
+        assertArrayEquals(new byte[] { 63, -116, -52, -51}, floatToByteArray(1.1f));
+    }
+
+    @Test
+    public void givenAByteArray_thenConvertToFloat() {
+        assertEquals(1.1f, byteArrayToFloat(new byte[] { 63, -116, -52, -51}), 0);
+    }
+
+    @Test
+    public void givenAFloat_thenConvertToByteArrayUsingByteBuffer() {
+        assertArrayEquals(new byte[] { 63, -116, -52, -51}, floatToByteArrayWithByteBuffer(1.1f));
+    }
+
+    @Test
+    public void givenAByteArray_thenConvertToFloatUsingByteBuffer() {
+        assertEquals(1.1f, byteArrayToFloatWithByteBuffer(new byte[] { 63, -116, -52, -51}), 0);
+    }
+
+    @Test
+    public void givenAFloat_thenConvertToByteArray_thenConvertToFloat() {
+        float floatToConvert = 200.12f;
+        byte[] byteArray = floatToByteArray(floatToConvert);
+        assertEquals(200.12f, byteArrayToFloat(byteArray), 0);
+    }
+    
+    @Test
+    public void givenAFloat_thenConvertToByteArrayWithByteBuffer_thenConvertToFloatWithByteBuffer() {
+        float floatToConvert = 30100.42f;
+        byte[] byteArray = floatToByteArrayWithByteBuffer(floatToConvert);
+        assertEquals(30100.42f, byteArrayToFloatWithByteBuffer(byteArray), 0);
+    }
+}