Fix some code inspection warnings

Author: andrei-punko

src/main/java/by/andd3dfx/collections/StackWithMinSupportO1.java

@@ -18,8 +18,8 @@
  */
 public class StackWithMinSupportO1 {
 
-    private Deque<Integer> stack = new ArrayDeque<>();
-    private Deque<Integer> minHistoryStack = new ArrayDeque<>();
+    private final Deque<Integer> stack = new ArrayDeque<>();
+    private final Deque<Integer> minHistoryStack = new ArrayDeque<>();
 
     public void push(int element) {
         stack.push(element);
@@ -30,7 +30,7 @@ public void push(int element) {
     }
 
     public int pop() {
-        Integer result = stack.pop();
+        var result = stack.pop();
         if (minHistoryStack.peek() == result) {
             minHistoryStack.pop();
         }

src/main/java/by/andd3dfx/multithreading/forkjoin/CustomRecursiveTask.java

@@ -41,7 +41,7 @@ private Collection<CustomRecursiveTask> createSubtasks() {
 
     private Integer processNLog(int[] arr) {
         String threadName = Thread.currentThread().getName();
-        logger.info(String.format("Work (%s) was processed by thread %s", arr, threadName));
+        logger.info(String.format("Work (%s) was processed by thread %s", Arrays.toString(arr), threadName));
 
         int result = process(arr);
         logger.info(String.format("Processed %s with result: %d", Arrays.toString(arr), result));

src/main/java/by/andd3dfx/numeric/MaxMultiplicationOf3InArray.java

@@ -1,7 +1,6 @@
 package by.andd3dfx.numeric;
 
 import java.util.Arrays;
-import java.util.stream.Collectors;
 
 import static java.lang.Math.max;
 

src/main/java/by/andd3dfx/proxy/SomeInterface1.java

@@ -1,7 +1,7 @@
 package by.andd3dfx.proxy;
 
 /**
- * Check usage of it in {@link ProxyCreationByInterfacesTest}
+ * Check usage of it in tests
  */
 public interface SomeInterface1 {
 

src/main/java/by/andd3dfx/proxy/SomeInterface2.java

@@ -1,7 +1,7 @@
 package by.andd3dfx.proxy;
 
 /**
- * Check usage of it in {@link ProxyCreationByInterfacesTest}
+ * Check usage of it in tests
  */
 public interface SomeInterface2 {
 

src/main/java/by/andd3dfx/refactoring/refactored/EventParser.java

@@ -8,7 +8,6 @@
 
 import java.util.EnumMap;
 import java.util.List;
-import java.util.stream.Collectors;
 
 /**
  * @see <a href="https://youtu.be/jdnNYxVk5BE">Video solution</a>
@@ -19,7 +18,7 @@ public class EventParser {
 
     static {
         Reflections reflections = new Reflections(IEventParser.class.getPackageName());
-        reflections.getSubTypesOf(IEventParser.class).stream()
+        reflections.getSubTypesOf(IEventParser.class)
                 .forEach(aClass -> extracted(aClass));
 
         for (EventType eventType : EventType.values()) {

src/main/java/by/andd3dfx/sorting/BubbleSort.java

@@ -5,7 +5,7 @@
  */
 public class BubbleSort {
 
-    public static <T extends Comparable> void apply(T[] array) {
+    public static <T extends Comparable<T>> void apply(T[] array) {
         var sorted = false;
         while (!sorted) {
             sorted = true;
@@ -19,7 +19,7 @@ public static <T extends Comparable> void apply(T[] array) {
         }
     }
 
-    public static <T extends Comparable> void apply2(T[] array) {
+    public static <T extends Comparable<T>> void apply2(T[] array) {
         for (var outIndex = array.length - 1; outIndex > 0; outIndex--) {
             for (var inIndex = 0; inIndex < outIndex; inIndex++) {
                 if (array[inIndex].compareTo(array[inIndex + 1]) > 0) {

src/main/java/by/andd3dfx/sorting/BucketSort.java

@@ -7,25 +7,25 @@ public class BucketSort {
 
     private static final int BUCKETS_COUNT = 10;
 
-    public static <T extends Comparable> void apply(T[] items) {
+    public static <T extends Comparable<T>> void apply(T[] items) {
         // Prepare empty buckets
-        List<List<Comparable>> buckets = new ArrayList<>(BUCKETS_COUNT);
+        List<List<Comparable<T>>> buckets = new ArrayList<>(BUCKETS_COUNT);
         for (int i = 0; i < BUCKETS_COUNT; i++) {
             buckets.add(new ArrayList<>());
         }
 
         // Fill in buckets
-        for (T t : items) {
-            var bucketIndex = determineBucketIndex(t, BUCKETS_COUNT);
+        for (var t : items) {
+            var bucketIndex = determineBucketIndex(t);
             buckets.get(bucketIndex).add(t);
         }
 
         int currIndex = 0;
         for (int bucketIndex = 0; bucketIndex < BUCKETS_COUNT; bucketIndex++) {
-            List<Comparable> bucket = buckets.get(bucketIndex);
+            var bucket = buckets.get(bucketIndex);
 
             // Sort elements in each bucket
-            Comparable[] array = bucket.toArray(new Comparable[0]);
+            var array = bucket.toArray(new Comparable[0]);
             InsertionSort.apply(array);
 
             // Populate the result array with values from bucket
@@ -39,29 +39,29 @@ public static <T extends Comparable> void apply(T[] items) {
     /**
      * Not found better way, but sorter parameterized now
      */
-    private static int determineBucketIndex(Comparable element, int bucketsCount) {
+    private static <T> int determineBucketIndex(Comparable<T> element) {
         if (element instanceof Integer) {
-            return (int) ((bucketsCount - 1) *
+            return (int) ((BUCKETS_COUNT - 1) *
                     ((Integer) element - (double) Integer.MIN_VALUE) / ((double) Integer.MAX_VALUE - (double) Integer.MIN_VALUE));
         }
         if (element instanceof Long) {
-            return (int) ((bucketsCount - 1) *
+            return (int) ((BUCKETS_COUNT - 1) *
                     ((Long) element - (double) Long.MIN_VALUE) / ((double) Long.MAX_VALUE - (double) Long.MIN_VALUE));
         }
         if (element instanceof Double) {
-            return (int) ((bucketsCount - 1) *
+            return (int) ((BUCKETS_COUNT - 1) *
                     ((Double) element - Double.MIN_VALUE) / (Double.MAX_VALUE - Double.MIN_VALUE));
         }
         if (element instanceof Float) {
-            return (int) ((bucketsCount - 1) *
+            return (int) ((BUCKETS_COUNT - 1) *
                     ((Float) element - Float.MIN_VALUE) / (Float.MAX_VALUE - Float.MIN_VALUE));
         }
         if (element instanceof Byte) {
-            return (bucketsCount - 1) *
+            return (BUCKETS_COUNT - 1) *
                     ((Byte) element - Byte.MIN_VALUE) / (Byte.MAX_VALUE - Byte.MIN_VALUE);
         }
         if (element instanceof Short) {
-            return (bucketsCount - 1) *
+            return (BUCKETS_COUNT - 1) *
                     ((Short) element - Byte.MIN_VALUE) / (Short.MAX_VALUE - Short.MIN_VALUE);
         }
 

src/main/java/by/andd3dfx/sorting/HeapSort.java

@@ -2,7 +2,7 @@
 
 public class HeapSort {
 
-    public static <T extends Comparable> void apply(T[] items) {
+    public static <T extends Comparable<T>> void apply(T[] items) {
         var n = items.length;
 
         // Build heap (rearrange array)
@@ -22,7 +22,7 @@ public static <T extends Comparable> void apply(T[] items) {
 
     // Heapify a subtree rooted with node items[root].
     // n is size of heap
-    private static <T extends Comparable> void heapify(T[] items, int n, int root) {
+    private static <T extends Comparable<T>> void heapify(T[] items, int n, int root) {
         var largest = root;
         var l = 2 * root + 1;
         var r = l + 1;
@@ -46,7 +46,7 @@ private static <T extends Comparable> void heapify(T[] items, int n, int root) {
         }
     }
 
-    private static <T extends Comparable> boolean greaterThan(T a, T b) {
+    private static <T extends Comparable<T>> boolean greaterThan(T a, T b) {
         return a.compareTo(b) > 0;
     }
 

src/main/java/by/andd3dfx/sorting/InsertionSort.java

@@ -7,7 +7,7 @@
  */
 public class InsertionSort {
 
-    public static <T extends Comparable> void apply(T[] array) {
+    public static <T extends Comparable<T>> void apply(T[] array) {
         for (int i = 1; i < array.length; i++) {
             var x = array[i];