Generic Stack Implementation in Java

📘 Premium Read: Access my best content on Medium member-only articles — deep dives into Java, Spring Boot, Microservices, backend architecture, interview preparation, career advice, and industry-standard best practices.

✅ Some premium posts are free to read — no account needed. Follow me on Medium to stay updated and support my writing.

🎓 Top 10 Udemy Courses (Huge Discount): Explore My Udemy Courses — Learn through real-time, project-based development.

▶️ Subscribe to My YouTube Channel (172K+ subscribers): Java Guides on YouTube

---

< Previous Next >

DS and Algorithms in Java

---

In our couple of previous articles, we have seen a different implementation of Stack such as

• Stack Implementation using Array in Java
• Dynamic Stack Implementation using Array in Java
• Stack Implementation using Linked List in Java
• Stack Implementation using Array List

All above implementation store single type of data. What if we would like to store different type of data in a Stack like integers, dates, strings, doubles, user-defined types etc.  In order to store any kind of data, we should have a generic implementation right. 

In this article, we will discuss how to push and pop any data type to Stack.

Generic Stack Implementation

In this program, we will perform stack operations(push, pop etc.) on input Integer and String data.

package com.javaguides.javads.stacks;

import java.util.Arrays;

public class GenericStackOfArray<T> {

        private static final int MINIMUM_SIZE = 1024;

        @SuppressWarnings("unchecked")
  private T[] array = (T[]) new Object[MINIMUM_SIZE];
        private int size = 0;

        public boolean push(T value) {
            if (size >= array.length)
                grow();
            array[size++] = value;
            return true;
        }

        public T pop() {
            if (size <= 0) return null;

            T t = array[--size];
            array[size] = null;

            int shrinkSize = array.length>>1;
            if (shrinkSize >= MINIMUM_SIZE && size < shrinkSize)
                shrink();

            return t;
        }

        public T peek() {
            if (size <= 0) return null;

            T t = array[--size];
            return t;
        }

        /**
         * Get item at index.
         * 
         * @param index of item.
         * @return T at index.
         */
        public T get(int index) {
            if (index>=0 && index<size) return array[index];
            return null;
        }

        public boolean remove(T value) {
            for (int i = 0; i < size; i++) {
                T obj = array[i];
                if (obj.equals(value)) {
                    return (remove(i));
                }
            }
            return false;
        }

        private boolean remove(int index) {
            if (index != --size) {
                // Shift the array down one spot
                System.arraycopy(array, index + 1, array, index, size - index);
            }
            array[size] = null;

            int shrinkSize = array.length>>1;
            if (shrinkSize >= MINIMUM_SIZE && size < shrinkSize)
                shrink();

            return true;
        }

        // Grow the array by 50%
        private void grow() {
            int growSize = size + (size<<1);
            array = Arrays.copyOf(array, growSize);
        }

        // Shrink the array by 50%
        private void shrink() {
            int shrinkSize = array.length>>1;
            array = Arrays.copyOf(array, shrinkSize);
        }

        public void clear() {
            size = 0;
        }

        public boolean contains(T value) {
            for (int i = 0; i < size; i++) {
                T obj = array[i];
                if (obj.equals(value))
                    return true;
            }
            return false;
        }

        public int size() {
            return size;
        }

        public boolean validate() {
            int localSize = 0;
            for (int i=0; i<array.length; i++) {
                T t = array[i];
                if (i<size) {
                    if (t==null) return false;
                    localSize++;
                } else {
                    if (t!=null) return false;
                }
            }
            return (localSize==size);
        }

        public String toString() {
            StringBuilder builder = new StringBuilder();
            for (int i = size - 1; i >= 0; i--) {
                builder.append(array[i]).append(", ");
            }
            return builder.toString();
        }
        
        public static void main(String[] args) {
         GenericStackOfArray<String> myStack = new GenericStackOfArray<String>(); // Declare a stack of
      // Populate the stack
      myStack.push("abc");
      myStack.push("bcd");
      myStack.push("cdf");
      myStack.push("xyz");

      GenericStackOfArray<Integer> stackOfArray = new GenericStackOfArray<Integer>(); // Declare a stack of
      // Populate the stack
      stackOfArray.push(1);
      stackOfArray.push(3);
      stackOfArray.push(4);
      stackOfArray.push(6);
      
      System.out.println("*********************Print Strings*********************");
      System.out.println(myStack.peek()); 
      System.out.println(myStack.pop()); 
      System.out.println(myStack.peek());
      
      System.out.println("*********************Print integers*********************");
      System.out.println(stackOfArray.peek()); 
      System.out.println(stackOfArray.pop()); 
      System.out.println(stackOfArray.peek());
  }
}

Output:

*********************Print Strings*********************
xyz
cdf
bcd
*********************Print integers*********************
6
4
3

---

< Previous Next >

DS and Algorithms in Java

---