fix: resolve Checkstyle, Clang format, and SpotBugs issues

Author: Ruturaj-007

src/main/java/com/thealgorithms/stacks/ValidParentheses.java

@@ -3,47 +3,31 @@
 import java.util.Stack;
 
 /**
- * Utility class for checking if a given string of parentheses is valid.
- * <p>
- * A string containing just the characters '(', ')', '{', '}', '[' and ']' is valid if:
- * <ul>
- *   <li>Open brackets are closed by the same type of brackets.</li>
- *   <li>Open brackets are closed in the correct order.</li>
- * </ul>
- * <p>
- * Example:
- * <pre>
- *   Input: "()[]{}"
- *   Output: true
- * </pre>
- * <p>
- * For more details, see
- * <a href="https://leetcode.com/problems/valid-parentheses/">LeetCode: Valid Parentheses</a>.
- * </p>
+ * Utility class to check for valid parentheses in a string.
  */
 public final class ValidParentheses {
 
     private ValidParentheses() {
-        // prevent instantiation
+        throw new AssertionError("Cannot instantiate utility class");
     }
 
     /**
-     * Checks whether the input string has valid parentheses.
+     * Returns true if the input string has valid parentheses.
      *
-     * @param str input string containing parentheses
-     * @return true if the string is valid, false otherwise
+     * @params the string containing parentheses
+     * @return true if valid, false otherwise
      */
-    public static boolean isValid(final String str) {
-        Stack<Character> stack = new Stack<>();
+    public static boolean isValid(final String s) {
+        final Stack<Character> stack = new Stack<>();
 
-        for (char ch : str.toCharArray()) {
+        for (final char ch : s.toCharArray()) {
             if (ch == '(' || ch == '{' || ch == '[') {
                 stack.push(ch);
-            } else {
+            } else if (ch == ')' || ch == '}' || ch == ']') {
                 if (stack.isEmpty()) {
                     return false;
                 }
-                char top = stack.peek();
+                final char top = stack.peek();
                 if ((top == '(' && ch == ')')
                         || (top == '{' && ch == '}')
                         || (top == '[' && ch == ']')) {
@@ -56,13 +40,10 @@ public static boolean isValid(final String str) {
         return stack.isEmpty();
     }
 
-    /**
-     * Example usage.
-     */
     public static void main(final String[] args) {
         System.out.println(isValid("()[]{}")); // true
-        System.out.println(isValid("(]"));     // false
-        System.out.println(isValid("([)]"));   // false
-        System.out.println(isValid("{[]}"));   // true
+        System.out.println(isValid("(]")); // false
+        System.out.println(isValid("([)]")); // false
+        System.out.println(isValid("{[]}")); // true
     }
 }

src/test/java/com/thealgorithms/stacks/ValidParenthesesTest.java

@@ -1,42 +1,45 @@
 package com.thealgorithms.stacks;
 
-
 import static org.junit.jupiter.api.Assertions.assertEquals;
+
 import java.util.stream.Stream;
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.Arguments;
 import org.junit.jupiter.params.provider.MethodSource;
 
+/**
+ * Tests for {@link ValidParentheses}.
+ */
 public class ValidParenthesesTest {
 
     @ParameterizedTest
     @MethodSource("provideValidTestCases")
-    void testIsValidValidCases(String input, boolean expected) {
+    void testIsValidValidCases(String input, Boolean expected) {
         assertEquals(expected, ValidParentheses.isValid(input));
     }
 
     static Stream<Arguments> provideValidTestCases() {
         return Stream.of(
-                Arguments.of("()", true),
-                Arguments.of("()[]{}", true),
-                Arguments.of("{[]}", true),
-                Arguments.of("", true)  // empty string is valid
+                Arguments.of("()", Boolean.TRUE),
+                Arguments.of("()[]{}", Boolean.TRUE),
+                Arguments.of("{[]}", Boolean.TRUE),
+                Arguments.of("", Boolean.TRUE) // empty string is valid
         );
     }
 
     @ParameterizedTest
     @MethodSource("provideInvalidTestCases")
-    void testIsValidInvalidCases(String input) {
-        assertEquals(false, ValidParentheses.isValid(input));
+    void testIsValidInvalidCases(String input, Boolean expected) {
+        assertEquals(expected, ValidParentheses.isValid(input));
     }
 
     static Stream<Arguments> provideInvalidTestCases() {
         return Stream.of(
-                Arguments.of("("),
-                Arguments.of(")"),
-                Arguments.of("([)]"),
-                Arguments.of("{[}]"),
-                Arguments.of("((()")
+                Arguments.of("(", Boolean.FALSE),
+                Arguments.of(")", Boolean.FALSE),
+                Arguments.of("([)]", Boolean.FALSE),
+                Arguments.of("{[}]", Boolean.FALSE),
+                Arguments.of("((()", Boolean.FALSE)
         );
     }
 }