How to Implement Stack in Java Using Array and Generics?
Last Updated :
14 Feb, 2023
Stack is a linear Data Structure that is based on the LIFO concept (last in first out). Instead of only an Integer Stack, Stack can be of String, Character, or even Float type. There are 4 primary operations in the stack as follows:
- push() Method adds element x to the stack.
- pop() Method removes the last element of the stack.
- top() Method returns the last element of the stack.
- empty() Method returns whether the stack is empty or not.
Note: Time Complexity is of order 1 for all operations of the stack
Illustration:

Stack 1
let s = empty stack of Integer type with size 4
Stack 2
push (100) : top = top + 1 and s[top] = 100
Stack 3
push (200) : top = top + 1 and s[top] = 200
Stack 4
push (300) : top = top + 1 and s[top] = 300
Stack 5
pop ( ) : top = top - 1
Stack 6
push (500) : top = top + 1 and s[top] = 500
Stack 7
push (600) : top = top + 1 and s[top] = 600
Note:
push (700) : top +1 == size of stack : Stack Overflow !
// Since top = 3 and size of stack = 4, no more elements can be pushed
Implementation:
Example
Java
// Java Program to Implement Stack in Java Using Array and
// Generics
// Importing input output classes
import java.io.*;
// Importing all utility classes
import java.util.*;
// user defined class for generic stack
class stack<T> {
// Empty array list
ArrayList<T> A;
// Default value of top variable when stack is empty
int top = -1;
// Variable to store size of array
int size;
// Constructor of this class
// To initialize stack
stack(int size)
{
// Storing the value of size into global variable
this.size = size;
// Creating array of Size = size
this.A = new ArrayList<T>(size);
}
// Method 1
// To push generic element into stack
void push(T X)
{
// Checking if array is full
if (top + 1 == size) {
// Display message when array is full
System.out.println("Stack Overflow");
}
else {
// Increment top to go to next position
top = top + 1;
// Over-writing existing element
if (A.size() > top)
A.set(top, X);
else
// Creating new element
A.add(X);
}
}
// Method 2
// To return topmost element of stack
T top()
{
// If stack is empty
if (top == -1) {
// Display message when there are no elements in
// the stack
System.out.println("Stack Underflow");
return null;
}
// else elements are present so
// return the topmost element
else
return A.get(top);
}
// Method 3
// To delete last element of stack
void pop()
{
// If stack is empty
if (top == -1) {
// Display message when there are no elements in
// the stack
System.out.println("Stack Underflow");
}
else
// Delete the last element
// by decrementing the top
top--;
}
// Method 4
// To check if stack is empty or not
boolean empty() { return top == -1; }
// Method 5
// To print the stack
// @Override
public String toString()
{
String Ans = "";
for (int i = 0; i < top; i++) {
Ans += String.valueOf(A.get(i)) + "->";
}
Ans += String.valueOf(A.get(top));
return Ans;
}
}
// Main Class
public class GFG {
// main driver method
public static void main(String[] args)
{
// Integer Stack
// Creating an object of Stack class
// Declaring objects of Integer type
stack<Integer> s1 = new stack<>(3);
// Pushing elements to integer stack - s1
// Element 1 - 10
s1.push(10);
// Element 2 - 20
s1.push(20);
// Element 3 - 30
s1.push(30);
// Print the stack elements after pushing the
// elements
System.out.println(
"s1 after pushing 10, 20 and 30 :\n" + s1);
// Now, pop from stack s1
s1.pop();
// Print the stack elements after popping few
// element/s
System.out.println("s1 after pop :\n" + s1);
// String Stack
// Creating an object of Stack class
// Declaring objects of Integer type
stack<String> s2 = new stack<>(3);
// Pushing elements to string stack - s2
// Element 1 - hello
s2.push("hello");
// Element 2 - world
s2.push("world");
// Element 3 - java
s2.push("java");
// Print string stack after pushing above string
// elements
System.out.println(
"\ns2 after pushing 3 elements :\n" + s2);
System.out.println(
"s2 after pushing 4th element :");
// Pushing another element to above stack
// Element 4 - GFG
s2.push("GFG");
// Float stack
// Creating an object of Stack class
// Declaring objects of Integer type
stack<Float> s3 = new stack<>(2);
// Pushing elements to float stack - s3
// Element 1 - 100.0
s3.push(100.0f);
// Element 2 - 200.0
s3.push(200.0f);
// Print string stack after pushing above float
// elements
System.out.println(
"\ns3 after pushing 2 elements :\n" + s3);
// Print and display top element of stack s3
System.out.println("top element of s3:\n"
+ s3.top());
}
}
Outputs1 after pushing 10, 20 and 30 :
10->20->30
s1 after pop :
10->20
s2 after pushing 3 elements :
hello->world->java
s2 after pushing 4th element :
Stack Overflow
s3 after pushing 2 elements :
100.0->200.0
top element of s3:
200.0
Time Complexity: O(n)
Auxiliary Space : O(n)
Similar Reads
How to Implement Queue in Java using Array and Generics? The queue is a linear data structure that follows the FIFO rule (first in first out). We can implement Queue for not only Integers but also Strings, Float, or Characters. There are 5 primary operations in Queue: enqueue() adds element x to the front of the queuedequeue() removes the last element of
4 min read
How to Implement Stack in Java using LinkedList and Generics? Prerequisites: Generics in JavaLinkedList in JavaWhat is Stack? Stack is a linear Data Structure that follows LIFO(Last In First Out) order while performing its operations. The main operations that are performed on the stack are mentioned below: push() : Â inserts an element at beginning of the stack
6 min read
How to Implement Generic LinkedList in Java? Linked List is Linear Data Structures that store values in nodes. As we do know here each Node possesses two properties namely the value of the node and link to the next node if present so. Linked List can not only be of Integer data type but String, boolean, Float, Character, etc. We can implement
8 min read
How to Use Deque as a Stack in Java? The Deque extends the Queue interface and provides additional methods to support operation at both ends. This interface is part of the java.util package. The Deque interface does not strictly enforce the order of elements, meaning that different implementations may behave differently. The standard i
2 min read
How to Implement a Generic Deep Copy Method for Multidimensional Arrays in Java? In Java, two types of copies can be made of any data structure that are Deep copy and Shallow copy. When we make a deep copy of an array, the array is assigned a new memory space, and the content is copied into the new memory space. This means that if we make changes in any of the two arrays it will
3 min read
Java Program to Implement ArrayDeque API The ArrayDeque in Java provides how to use resizable-array additionally to the implementation of the Deque interface. It is also referred to as Array Double Ended Queue or Array Deck. This is a special quite array that grows and allows users to feature or remove a component from each side of the que
3 min read
How to Declare an ArrayList with Values in Java? ArrayList is simply known as a resizable array. Declaring an ArrayList with values is a basic task that involves the initialization of a list with specific elements. It is said to be dynamic as the size of it can be changed. Proceeding with the declaration of ArrayList, we have to be aware of the co
2 min read
How to Fill (initialize at once) an Array in Java? An array is a group of like-typed variables that are referred to by a common name. In this, article we will learn about Filling array in Java while Initialization.Example:Java// Java program to fill the element in an array import java.util.*; public class Geeks { public static void main(String args[
3 min read
Java Program to Implement Stack API A stack is a linear data structure that follows a particular order in which insertion/deletion operations are performed. The order is either LIFO(Last In First Out) or FILO(First In Last Out). Stack uses the push() function in order to insert new elements into the Stack and pop() function in order t
3 min read
Java Program to Implement ArrayBlockingQueue API ArrayBlockingQueue class is a member of the Java Collection framework. ArrayBlockingQueue is a bounded blocking queue. The term bounded, means that the size of the Queue is fixed and cannot be changed. Any attempt to put element/elements into a full queue will lead to blocking operation. Similarly,
7 min read