🎓 Top 15 Udemy Courses (80-90% Discount): My Udemy Courses - Ramesh Fadatare — All my Udemy courses are real-time and project oriented courses.

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

▶️ For AI, ChatGPT, Web, Tech, and Generative AI, subscribe to another channel: Ramesh Fadatare 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

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

My Top and Bestseller Udemy Courses. The sale is going on with a 70 - 80% discount. The discount coupon has been added to each course below:

Spring Boot + RabbitMQ Course - The Practical Guide

Java Guides

Search This Blog