{"id":7912,"date":"2025-02-27T13:34:11","date_gmt":"2025-02-27T13:34:11","guid":{"rendered":"https:\/\/msgprogramator.sk\/?p=7912"},"modified":"2026-04-01T11:55:57","modified_gmt":"2026-04-01T11:55:57","slug":"java-stack","status":"publish","type":"post","link":"https:\/\/msgprogramator.sk\/en\/java-stack\/","title":{"rendered":"Java Stack: Data Structure and Stack Class in Java"},"content":{"rendered":"

A Java Stack<\/strong> is one of a number of data structures (collections) for easier data manipulation. As part of our series on data structures<\/a>, we’ll introduce each structure, review its uses, available methods, advantages and disadvantages, and provide tips for when it’s appropriate to use it.<\/p>\n

In this section, we will discuss the collection that represents the stack – the Java Stack<\/strong>.<\/p>\n

Java Stack – data structure introduction<\/h2>\n

The Stack collection is implemented as a class in the java.util package<\/em>. It is a descendant of the Vector class<\/a>, from which it takes its properties and also adds features specific to stack data access.<\/p>\n

\"Inheritance
Inheritance hierarchy for the Stack collection.<\/strong>
SOURCE: d1jnx9ba8s6j9r.cloudfront.net\/blog\/wp-content\/uploads\/2019\/08\/Stack-Class-in-Java_.jpg<\/figcaption><\/figure>\n

The Stack class incorporates the LIFO (Last In, First Out)<\/a> principle, which means that the last element added is also the first one removed from the stack. This algorithm is useful in situations where we need to keep the order of operations (for example, when computing expressions or implementing recursion) and works in constant time.<\/p>\n

A typical example of using Stack is the Stack trace when debugging code. The last visited method is added last to the top of the stack, and when it is exited, it is removed from the stack and the method that called the previous method is on top of the stack.<\/p>\n

Although Stack class<\/strong> is built on top of the Vector class and inherits its dynamic behavior (automatic capacity increase), it is a structure that is currently less used in modern applications because the Deque<\/strong> interface and its implementations such as ArrayDeque<\/strong> from java.util can completely replace Stack with its implementation of the LIFO approach and a complete and consistent set of operations.<\/p>\n

Stack class constructor<\/h2>\n

The Stack class provides a single simple constructor that creates an empty stack. The capacity of the stack is initially set to a fixed value of 10, and like a vector, it doubles in size when the total size of the stack is exceeded. The difference with the vector is that it never shrinks once elements are removed from the stack.<\/p>\n

Empty stack<\/strong><\/p>\n

Creates an empty stack with a capacity of 10 (default value).<\/p>\n

Basic operations with the Stack collection<\/h2>\n

Basic operations with the Stack collection include:<\/p>\n

Inserting elements (push)<\/h3>\n

Adds a new element to the top of the stack.<\/p>\n

Removing an element (pop)<\/h3>\n

Removes and returns the top element. If this operation is called on an empty stack, throws an exception EmptyStackException<\/strong><\/em>.<\/p>\n

View of the top element (peek)<\/h3>\n

Returns the top element without removing it.<\/p>\n

Check if the stack is empty<\/h3>\n

Returns true<\/em> if the stack contains no elements, false<\/em> otherwise.<\/p>\n

Element search (search)<\/h3>\n

Searches for an element and returns its distance from the top of the stack. The distance of the topmost element is 1. The one below it is 2, and so on. If the element is not found, it returns -1.<\/p>\n

Java Stack: examples of basic operations<\/h2>\n

Adding elements<\/h3>\n

Adding elements to the stack can be done one element at a time or in bulk.<\/p>\n

Adding one element <\/strong><\/p>\n

stack.push(1);<\/code><\/pre>\n
Adding multiple elements at once <\/strong><\/p>\n
List<Integer> values = Arrays.asList(2, 3, 4, 5);\nstack.addAll(values);<\/code><\/pre>\n
View of the top element<\/h3>\n
If we want to see which element is currently at the top of the stack we use the peek() method.<\/p>\n
Information about the top element<\/strong><\/p>\n
stack.peek();<\/code><\/pre>\n
In our example, it returns the value 5.<\/strong><\/p>\n
Checking if the stack is empty<\/h3>\n
If we are interested in whether the stack contains any elements at all, we can call the empty() method.<\/p>\n
stack.empty();<\/code><\/pre>\n
In our example, it will return false as it contains elements.<\/p>\n
Searching for elements<\/h3>\n
If we want to find out if the stack contains a particular element X, we can call the search(X) method.<\/p>\n
stack.search(X);<\/code><\/pre>\n
stack.search(7) => returns -1<\/p>\n
stack.search(2) => returns 4<\/p>\n
Removal of elements<\/h3>\n
Most often we need to remove the top element of the stack – we do this by calling the pop() method. However, operations from the Vector class offer us other possibilities.<\/p>\n
Removing and returning the top element <\/strong><\/p>\n
In our example, it removes the top element from the stack (5) and stores it in a variable element. The top of the stack will contain the current element 4.<\/p>\n
Integer element = stack.pop();<\/code><\/pre>\n
Clearing the stack<\/strong><\/p>\n
There are two equivalent methods to clear all stack elements: clear(), removeAllElements().<\/p>\n
stack.removeAllElements();\nstack.clear();<\/code><\/pre>\n
Other operations<\/h2>\n
I will mention a few other useful methods.<\/p>\n
Removing elements using a filter (lambda expression) <\/strong><\/p>\n
stack.removeIf(elem -> elem < 2);<\/code><\/pre>\n
Detecting the number of elements in the stack <\/strong><\/p>\n
int size = stack.size();<\/code><\/pre>\n
Index of occurrence of the element closest to the top of the stack <\/strong><\/p>\n
stack.lastIndexOf(3);<\/code><\/pre>\n
Documentation of methods for the Stack collection<\/h2>\n
A complete overview of all available methods for Stack can be found here – Stack class documentation.<\/a><\/p>\n
Advantages and disadvantages of the Stack data structure<\/h2>\n
Benefits of Stack:<\/h3>\n