Partner – Moderne – NPI EA (cat=Spring Boot)
announcement - icon

Refactor Java code safely — and automatically — with OpenRewrite.

Refactoring big codebases by hand is slow, risky, and easy to put off. That’s where OpenRewrite comes in. The open-source framework for large-scale, automated code transformations helps teams modernize safely and consistently.

Each month, the creators and maintainers of OpenRewrite at Moderne run live, hands-on training sessions — one for newcomers and one for experienced users. You’ll see how recipes work, how to apply them across projects, and how to modernize code with confidence.

Join the next session, bring your questions, and learn how to automate the kind of work that usually eats your sprint time.

Course – Black Friday 2026 – NPI EA – main – before_post_content
announcement - icon

Yes, we're now running our Black Friday Sale. All Courses are 33% off until 1st December, 2026 at 17:00 Romania time:

>> EXPLORE ACCESS NOW

Course – Black Friday 2026 – NPI – main – before_post_content
announcement - icon

Yes, we're now running our Black Friday Sale. All Courses are 33% off until 1st December, 2026 at 17:00 Romania time:

>> EXPLORE ACCESS NOW

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(20);
    stack.push(10);
    stack.push(30);

    Collections.reverse(stack);
    stack.forEach(System.out::println);
}

So, this is how our output would look:

30
10
20

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.

The code backing this article is available on GitHub. Once you're logged in as a Baeldung Pro Member, start learning and coding on the project.
Partner – Moderne – NPI EA (tag=Refactoring)
announcement - icon

Modern Java teams move fast — but codebases don’t always keep up. Frameworks change, dependencies drift, and tech debt builds until it starts to drag on delivery. OpenRewrite was built to fix that: an open-source refactoring engine that automates repetitive code changes while keeping developer intent intact.

The monthly training series, led by the creators and maintainers of OpenRewrite at Moderne, walks through real-world migrations and modernization patterns. Whether you’re new to recipes or ready to write your own, you’ll learn practical ways to refactor safely and at scale.

If you’ve ever wished refactoring felt as natural — and as fast — as writing code, this is a good place to start.

Course – Black Friday 2026 – NPI EA – main – after_post_content

announcement - icon

Yes, we're now running our Black Friday Sale. All Courses are 33% off until 1st December, 2026 at 17:00 Romania time:

>> EXPLORE ACCESS NOW

Course – Black Friday 2026 – NPI – main – after_post_content

announcement - icon

Yes, we're now running our Black Friday Sale. All Courses are 33% off until 1st December, 2026 at 17:00 Romania time:

>> EXPLORE ACCESS NOW

1 Comment
Oldest
Newest