Printing Stack Values in Java

1. Overview

Stack follows the Last In, First Out (LIFO) rule; printing its values correctly can sometimes be tricky. But don’t worry, we’ve got this covered!

In this tutorial, we’ll explore different ways to print stack values, from the simplest to the most efficient approaches. We’ll also discuss when to use each approach and why Deque is a better alternative to Stack in modern Java development.

2. Using Stack.toString()

If we just need a quick look at our stack, the toString() method is our best friend. It’s built into the Stack class (due to Vector), so it prints everything neatly.

Let’s consider a stack. We’ll use this example throughout our tutorial:

Stack<Integer> stack = new Stack<>();
stack.push(10);
stack.push(20);
stack.push(30);

Here is the implementation with Stack.toString():

public static void givenStack_whenUsingToString_thenPrintStack() {
    Stack<Integer> stack = new Stack<>();
    stack.push(10);
    stack.push(20);
    stack.push(30);
    System.out.println(stack.toString());
}

The output from this approach would be:

[10, 20, 30]

This approach is perfect for quickly debugging and checking the contents of a stack. Since it provides a direct and simple representation, it works best when formatting isn’t a concern and the goal is to inspect the stack’s elements at a glance.

This method is super simple and works instantly, making it ideal for quick debugging. However, it includes square brackets in the output, which might not always be desirable. Additionally, since the output resembles a list, it doesn’t explicitly indicate that the structure is a stack.

3. Using an Enhanced for Loop

If we have to print elements in a custom format, looping over them is a great option. Let’s see how:

public static void givenStack_whenUsingForEach_thenPrintStack() {
    Stack<Integer> stack = new Stack<>();
    stack.push(10);
    stack.push(20);
    stack.push(30);

    List<Integer> result = new ArrayList<>();
    for (Integer value : stack) {
        System.out.print(value + " ");
    }
}

The stack values would print like:

10 20 30

This method is proper when a cleaner or customized print format is needed. It works well when the order of elements isn’t critical, allowing more control over how the stack’s contents are displayed.

4. Using a forEach() Loop

We can use the Java 8 forEach() method instead of a traditional for-each loop. However, there’s an important caveat: The forEach() method on a Stack or Deque will not print elements in LIFO order. It follows the collection’s iteration order, which means elements are printed in the order they were inserted.

Here’s an example:

public static void givenStack_whenUsingDirectForEach_thenPrintStack() {
    Stack<Integer> stack = new Stack<>();
    stack.push(10);
    stack.push(20);
    stack.push(30);
    stack.forEach(element -> System.out.println(element));
}

Let’s have a look at the output:

10
20
30

Though this approach provides complete control over formatting, making it ideal for customised output, it doesn’t maintain LIFO order, as elements are printed in the insertion sequence instead of the expected stack order. We would require reversing it as done in the code above to print it in LIFO order.

If we need to print in LIFO order, we should first reverse the stack before calling forEach():

public static void givenStack_whenUsingStreamReverse_thenPrintStack() {
    Stack<Integer> stack = new Stack<>();
    stack.push(10);
    stack.push(20);
    stack.push(30);

    stack.stream()
      .sorted(Comparator.reverseOrder())
      .forEach(System.out::println);
}

So, this is how our output would look:

30
20
10

This way, we can get the stack elements in LIFO order.

5. Using an Iterator

An Iterator lets us step through each element one by one:

public static void givenStack_whenUsingIterator_thenPrintStack() {
    Stack<Integer> stack = new Stack<>();
    stack.push(10);
    stack.push(20);
    stack.push(30);

    Iterator<Integer> iterator = stack.iterator();
    while (iterator.hasNext()) {
        System.out.print(iterator.next() + " ");
    }
}

So, if we print our stack, we’ll get:

10 20 30

This approach is practical when more flexibility is needed than a basic loop can provide. It’s helpful for operations that might involve removing elements while iterating. However, it still doesn’t print elements in LIFO order, and this may not always be desirable. While it works for any data type, it adds more complexity than a simple loop.

6. Getting the Real LIFO Order with ListIterator

If we need to print elements in true stack order (LIFO), ListIterator is the way to go. Let’s see it in action:

public static void givenStack_whenUsingListIteratorReverseOrder_thenPrintStack() {
    Stack<Integer> stack = new Stack<>();
    stack.push(10);
    stack.push(20);
    stack.push(30);

    ListIterator<Integer> iterator = stack.listIterator(stack.size());
    while (iterator.hasPrevious()) {
        System.out.print(iterator.previous() + " ");
    }
}

The printed stack would follow the LIFO order:

30 20 10

This approach is ideal when elements need to be printed in the correct stack order (LIFO) without modifying the stack. It’s particularly useful when working with the Stack class and avoiding element removal. While it ensures proper order, it requires slightly more code and is limited to Stack, making it incompatible with Deque.

7. The Best Performance Option: Deque

If we’re working with stacks often, we should probably use Deque (ArrayDeque) instead of Stack. It’s faster, more efficient, and preferred in modern Java.

Let’s have a look:

public static void givenStack_whenUsingDeque_thenPrintStack() {
    Deque<Integer> stack = new ArrayDeque<>();
    stack.push(10);
    stack.push(20);
    stack.push(30);

    stack.forEach(e -> System.out.print(e + " "));
}

The stack values would be printed in LIFO order:

30 20 10

This approach is ideal for scenarios where a more efficient stack implementation is needed. It’s particularly recommended for high-performance applications since Deque performs better than Stack. Unlike Stack, Deque naturally maintains LIFO order while offering improved concurrency support. It is also the preferred choice in modern Java programming. However, adopting this method requires switching from Stack to Deque, which may require refactoring existing code.

8. Best Approach Based on Use Case

Let’s have a look at which approach fits under which situation.

• For Quick Debugging – toString()
• For Custom Formatting – forEach() or Java 8 forEach()
• For LIFO Order in Stack – ListIterator
• For Best Performance – Deque (preferred over Stack)

So, the choice is ours.

9. Conclusion

In this article, we saw that printing stack values isn’t just about displaying elements; it’s about understanding the right approach for the right situation. If we just need a quick look, toString() works fine.

When formatting matters, forEach() and Iterator provide flexibility, while ListIterator ensures a true LIFO order. And when we need to ensure better performance, Deque is the best choice. So, the best choice depends on the scenario in which we need to print the stack.

As always, the code presented in this article is available over on GitHub.