refactor: StackArrayList (#5356)

src/main/java/com/thealgorithms/datastructures/stacks/StackArrayList.java

@@ -6,110 +6,48 @@ import java.util.EmptyStackException;
 /**
  * This class implements a Stack using an ArrayList.
  *
- * <p>
- * A stack is exactly what it sounds like. An element gets added to the top of
- * the stack and only the element on the top may be removed.
- *
- * <p>
- * This is an ArrayList Implementation of a stack, where size is not a problem
- * we can extend the stack as much as we want.
+ * @param <T> the type of elements in this stack
  */
-public class StackArrayList {
+public class StackArrayList<T> implements Stack<T> {
 
-    /**
-     * Driver Code
-     */
-    public static void main(String[] args) {
-        StackArrayList stack = new StackArrayList();
-        assert stack.isEmpty();
+    private final ArrayList<T> stack;
 
-        for (int i = 1; i <= 5; ++i) {
-            stack.push(i);
-            assert stack.size() == i;
-        }
-
-        assert stack.size() == 5;
-        assert stack.peek() == 5 && stack.pop() == 5 && stack.peek() == 4;
-
-        /* pop elements at the top of this stack one by one */
-        while (!stack.isEmpty()) {
-            stack.pop();
-        }
-        assert stack.isEmpty();
-
-        try {
-            stack.pop();
-            assert false;
-            /* this should not happen */
-        } catch (EmptyStackException e) {
-            assert true;
-            /* this should happen */
-        }
-    }
-
-    /**
-     * ArrayList representation of the stack
-     */
-    private ArrayList<Integer> stack;
-
-    /**
-     * Constructor
-     */
     public StackArrayList() {
         stack = new ArrayList<>();
     }
 
-    /**
-     * Adds value to the end of list which is the top for stack
-     *
-     * @param value value to be added
-     */
-    public void push(int value) {
+    @Override
+    public void push(T value) {
         stack.add(value);
     }
 
-    /**
-     * Removes the element at the top of this stack and returns
-     *
-     * @return Element popped
-     * @throws EmptyStackException if the stack is empty.
-     */
-    public int pop() {
+    @Override
+    public T pop() {
         if (isEmpty()) {
             throw new EmptyStackException();
         }
-
-        /* remove the element on the top of the stack */
-        return stack.remove(stack.size() - 1);
+        return stack.removeLast();
     }
 
-    /**
-     * Test if the stack is empty.
-     *
-     * @return {@code true} if this stack is empty, {@code false} otherwise.
-     */
+    @Override
+    public T peek() {
+        if (isEmpty()) {
+            throw new EmptyStackException();
+        }
+        return stack.getLast();
+    }
+
+    @Override
     public boolean isEmpty() {
         return stack.isEmpty();
     }
 
-    /**
-     * Return the element at the top of this stack without removing it from the
-     * stack.
-     *
-     * @return the element at the top of this stack.
-     */
-    public int peek() {
-        if (isEmpty()) {
-            throw new EmptyStackException();
-        }
-        return stack.get(stack.size() - 1);
+    @Override
+    public void makeEmpty() {
+        stack.clear();
     }
 
-    /**
-     * Return size of this stack.
-     *
-     * @return size of this stack.
-     */
+    @Override
     public int size() {
         return stack.size();
     }

src/test/java/com/thealgorithms/datastructures/stacks/StackArrayListTest.java

@@ -0,0 +1,76 @@
+package com.thealgorithms.datastructures.stacks;
+
+import java.util.EmptyStackException;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+class StackArrayListTest {
+
+    private StackArrayList<Integer> stack;
+
+    @BeforeEach
+    void setUp() {
+        stack = new StackArrayList<>();
+    }
+
+    @Test
+    void testPushAndPop() {
+        stack.push(1);
+        stack.push(2);
+        stack.push(3);
+
+        Assertions.assertEquals(3, stack.pop());
+        Assertions.assertEquals(2, stack.pop());
+        Assertions.assertEquals(1, stack.pop());
+    }
+
+    @Test
+    void testPeek() {
+        stack.push(10);
+        stack.push(20);
+
+        Assertions.assertEquals(20, stack.peek());
+        stack.pop(); // Remove 20
+        Assertions.assertEquals(10, stack.peek());
+    }
+
+    @Test
+    void testIsEmpty() {
+        Assertions.assertTrue(stack.isEmpty());
+        stack.push(1);
+        Assertions.assertFalse(stack.isEmpty());
+        stack.pop();
+        Assertions.assertTrue(stack.isEmpty());
+    }
+
+    @Test
+    void testMakeEmpty() {
+        stack.push(1);
+        stack.push(2);
+        stack.push(3);
+        stack.makeEmpty();
+        Assertions.assertTrue(stack.isEmpty());
+        Assertions.assertEquals(0, stack.size());
+    }
+
+    @Test
+    void testSize() {
+        Assertions.assertEquals(0, stack.size());
+        stack.push(1);
+        stack.push(2);
+        Assertions.assertEquals(2, stack.size());
+        stack.pop();
+        Assertions.assertEquals(1, stack.size());
+    }
+
+    @Test
+    void testPopEmptyStackThrowsException() {
+        Assertions.assertThrows(EmptyStackException.class, stack::pop);
+    }
+
+    @Test
+    void testPeekEmptyStackThrowsException() {
+        Assertions.assertThrows(EmptyStackException.class, stack::peek);
+    }
+}