cleanup: improving code readability

Author: Alex Klymenko

src/main/java/com/thealgorithms/sorts/BeadSort.java

@@ -2,12 +2,6 @@
 
 import java.util.Arrays;
 
-/**
- * BeadSort cannot sort negative numbers, characters, or strings.
- * It only works for non-negative integers.
- *
- * @see <a href="https://en.wikipedia.org/wiki/Bead_sort">BeadSort Algorithm (Wikipedia)</a>
- */
 public class BeadSort {
     /**
      * Sorts the given array using the BeadSort algorithm.
@@ -17,37 +11,47 @@ public class BeadSort {
      * @throws IllegalArgumentException If the array contains negative numbers.
      */
     public int[] sort(int[] array) {
-        if (array.length == 0) {
-            return array;
-        }
+        allInputsMustBeNonNegative(array);
+        return extractSortedFromGrid(fillGrid(array));
+    }
 
+    private void allInputsMustBeNonNegative(final int[] array) {
         if (Arrays.stream(array).anyMatch(s -> s < 0)) {
             throw new IllegalArgumentException("BeadSort cannot sort negative numbers.");
         }
+    }
 
-        int[] sorted = new int[array.length];
-        int max = Arrays.stream(array).max().orElse(0);
-
-        char[][] grid = new char[array.length][max];
-        int[] count = new int[max];
-
-        for (int i = 0; i < array.length; i++) {
-            for (int j = 0; j < max; j++) {
-                grid[i][j] = '-';
-            }
-        }
+    private boolean[][] fillGrid(final int[] array) {
+        final var maxValue = Arrays.stream(array).max().orElse(0);
+        var grid = getEmptyGrid(array.length, maxValue);
 
+        int[] count = new int[maxValue];
         for (int i = 0, arrayLength = array.length; i < arrayLength; i++) {
             int k = 0;
             for (int j = 0; j < array[i]; j++) {
-                grid[count[max - k - 1]++][k] = '*';
+                grid[count[maxValue - k - 1]++][k] = true;
                 k++;
             }
         }
+        return grid;
+    }
+
+    private boolean[][] getEmptyGrid(final int arrayLength, final int maxValue) {
+        boolean[][] grid = new boolean[arrayLength][maxValue];
+        for (int i = 0; i < arrayLength; i++) {
+            for (int j = 0; j < maxValue; j++) {
+                grid[i][j] = false;
+            }
+        }
+
+        return grid;
+    }
 
-        for (int i = 0; i < array.length; i++) {
+    private int[] extractSortedFromGrid(final boolean[][] grid) {
+        int[] sorted = new int[grid.length];
+        for (int i = 0; i < grid.length; i++) {
             int k = 0;
-            for (int j = 0; j < max && grid[array.length - 1 - i][j] == '*'; j++) {
+            for (int j = 0; j < grid[grid.length - 1 - i].length && grid[grid.length - 1 - i][j]; j++) {
                 k++;
             }
             sorted[i] = k;

src/test/java/com/thealgorithms/sorts/BeadSortTest.java

@@ -10,8 +10,6 @@
 import org.junit.jupiter.params.provider.MethodSource;
 
 public class BeadSortTest {
-    // BeadSort can't sort negative number, Character, String. It can sort positive number only
-
     @ParameterizedTest
     @MethodSource("provideArraysForBeadSort")
     public void testBeadSort(int[] inputArray, int[] expectedArray) {
@@ -26,6 +24,6 @@ private static Stream<Arguments> provideArraysForBeadSort() {
 
     @Test
     public void testWithNegativeNumbers() {
-        assertThrows(IllegalArgumentException.class, () -> new BeadSort().sort(new int[] {3, -1, 4, 1, 5, -9}));
+        assertThrows(IllegalArgumentException.class, () -> new BeadSort().sort(new int[] {3, 1, 4, 1, 5, -9}));
     }
 }