Java Stack
- Java Stack Tutorial Video
- Java Stack Basics
- Create a Stack
- Create a Stack with a Generic Type
- Push Element on Stack
- Pop Element From Stack
- Peek at Top Element of Stack
- Search the Stack
- Stack Size
- Iterate Elements of Stack
- Process Stack Using Stream
- Reverse List Using Stack
- Use a Java Deque as a Stack
- Stack Use Cases
Jakob Jenkov |
The Java Stack class, java.util.Stack, is a classical stack data structure.
You can push elements to the top of a Java Stack and pop them again, meaning read and remove
the elements from the top of the stack.
The Java Stack class actually implements the Java List interface,
but you rarely use a Stack as a List - except perhaps if you need to inspect
all elements currently stored on the stack.
Please note, that the Java Stack class is a subclass of Vector, an older Java class which is synchronized. This synchronization adds a small overhead to calls to all methods of a Stack. Additionally, the Vector class uses several older (no longer recommended) parts of Java, like the Enumeration which is superseded by the Iterator interface. If you want to avoid these issues you can use a Java Deque as a stack instead.
Java Stack Tutorial Video
If you prefer video, I have a Java Stack tutorial video here: Java Stack Tutorial Video.
Java Stack Basics
A Stack is a data structure where you add elements to the "top" of the stack, and also remove
elements from the top again. This is also referred to as the "Last In First Out (LIFO)" principle. In contrast, a
Java Queue uses a "First In First Out (FIFO)" principle, where elements are added
to the end of the queue, and removed from the beginning of the queue.
Create a Stack
To use a Java Stack you must first create an instance of the Stack class.
Here is an example of creating a Java Stack instance:
Stack stack = new Stack();
Create a Stack with a Generic Type
You can set a generic type on a Stack specifying the type of objects the Stack instance can contain. You specify the stack type when you declare the Stack variable. Here is an example of creating a Java Stack with a generic type:
Stack<String> stack = new Stack<String>();
The Stack created above can only contain String instances.
Using a generic type on your Stack instances is recommended as it simplifies your code (no casts needed when accessing objects on the Stack), and decreases the risk that you push an object of the wrong type on the Stack.
Push Element on Stack
Once you have a Java Stack instance, you can push elements to the top of the Stack.
The elements you push onto the Stack must be Java objects. Thus, you actually push objects
to the Stack.
You push elements onto a Java Stack using its push() method.
Here is an example of pushing an element (object) onto a Java Stack:
Stack<String> stack = new Stack<String>();
stack.push("1");
This Java example pushes a Java String with the text 1 onto the
Stack. The String 1 is then stored at the top of the Stack.
Pop Element From Stack
Once an element has been pushed onto a Java Stack, you can pop that element from the
Stack again. Once an element is popped off the Stack, the element is removed
from the Stack. The top element of the Stack is then whatever element that was
pushed onto the Stack just before the element just popped.
You pop an element off a Java Stack using the pop() method. Here is an example of
popping an element off a Stack using the pop() method:
Stack<String> stack = new Stack<String>();
stack.push("1");
String topElement = stack.pop();
Once an element is popped off a Stack, the element is no longer present on the Stack.
Peek at Top Element of Stack
The Java Stack class has a method called peek() which enables you to see what the top
element on the Stack is, without popping off the element. Here is an example of peeking at the top
of a Java Stack:
Stack<String> stack = new Stack<String>();
stack.push("1");
String topElement = stack.peek();
After running this Java example the topElement variable will contain the String object 1
which was pushed onto the Stack just before peek() was called. The String object
is still present on the Stack after calling peek().
Search the Stack
You can search for an object on the stack to get it's index, using the search()
method. The object's equals() method is called on every object on the Stack
to determine if the searched-for object is present on the Stack. The index you get
is the index from the top of the Stack, meaning the top element on the Stack
has index 1.
Here is how you search a Stack for an object:
Stack<String> stack = new Stack<String>();
stack.push("1");
stack.push("2");
stack.push("3");
int index = stack.search("3"); //index = 3
Stack Size
You can obtain the size of a Java Stack, meaning the number of elements currently stored on the Stack, via
the Stack size() method. Here is an example of obtaining the size of a Java Stack via its
size() method:
Stack<String> stack = new Stack<String>();
stack.push("1");
stack.push("2");
stack.push("3");
int size = stack.size();
After running this code the size variable will contain the value 3, since the Stack in the
example contains 3 elements at the time its size() method is called.
Iterate Elements of Stack
You can iterate the elements of a Java Stack by obtaining a Java Iterator
from the Stack. You obtain an Iterator by calling the Stack iterator()
method. Here is an example of obtaining an Iterator from a Java Stack and iterating it:
Stack<String> stack = new Stack<String>();
stack.push("123");
stack.push("456");
stack.push("789");
Iterator iterator = stack.iterator();
while(iterator.hasNext()){
Object value = iterator.next();
}
Process Stack Using Stream
It is also possible to process the elements on a Java Stack via the
Java Stream API. You do so by
first obtaining a Stream from the Stack via the stream() method.
Once you have obtained a Stream from the Stack, you can process the elements in the
stream. Here is an example of obtaining a Stream from a Stack and processing the
elements:
Stack<String> stack = new Stack<String>();
stack.push("A");
stack.push("B");
stack.push("C");
Stream stream = stack.stream();
stream.forEach((element) -> {
System.out.println(element); // print element
});
Notice, that this example uses a Java Lambda as parameter to the
Stream.forEach() method. The lambda just prints out the element to System.out
Reverse List Using Stack
You can use a Java Stack to reverse a Java List. You do so by pushing all the
elements from the List onto the Stack, starting with the element with index 0,
then 1 etc. Each element is removed from the List, then pushed onto the Stack.
Once all the elements are on the Stack, you pop the elements off one by one
and add them back to the empty list. Here is an example of reversing a Java List using a
Java Stack:
List<String> list = new ArrayList<String>();
list.add("A");
list.add("B");
list.add("C");
System.out.println(list);
Stack<String> stack = new Stack<String>();
while(list.size() > 0) {
stack.push(list.remove(0));
}
while(stack.size() > 0){
list.add(stack.pop());
}
System.out.println(list);
Use a Java Deque as a Stack
As mentioned at the top of this Java Stack tutorial, you can use a Java Deque as a stack too. The Java Deque tutorial also shows how you can do that - but I will show you a short example here too:
Deque<String> dequeAsStack = new ArrayDeque>String>();
dequeAsStack.push("one");
dequeAsStack.push("two");
dequeAsStack.push("three");
String one = dequeAsStack.pop();
String two = dequeAsStack.pop();
String three = dequeAsStack.pop();
As you can see, it looks pretty similar to using a regular Java Stack.
Stack Use Cases
A Stack is really handy for some types of data processing,
for instance if you are parsing an XML file using either SAX
or StAX. For an example, see my Java SAX Example
in my Java XML tutorial.
| Tweet | |
Jakob Jenkov | |
