Press "Enter" to skip to content

Stackwalking in Java with StackWalker and Stream API

One of the coolest (and totally impractical for most developers) features added to Java recently, is the StackWalking API.

In this short article, we’ll see what it is and how surprisingly easy it is to use it.

StackWalking Before Java 9

So far, the official solution was to obtain the current thread and call its getStackTrace() method:

StackTraceElement[] stackTraceElements = Thread.currentThread().getStackTrace();

The other smart solution involved… throwing an exception and extracting stack trace information from it. However, it wasn’t possible to manipulate the result, it would just get printed instantly:

new Exception().printStackTrace();

Both solutions suffer from the same problem – they eagerly capture a snapshot of the entire stack, and aren’t handy to use.

JEP-259: Stack-Walking API

JEP-259 was supposed to address those problems and it did. The new API provides a handy way of traversing stack traces lazily using Stream API.

We can create a StackWalker instance as easily as:

StackWalker stack = StackWalker.getInstance();

Additionally, we can provide some initial options:

StackWalker stack = StackWalker.getInstance(StackWalker.Option.RETAIN_CLASS_REFERENCE);

And if we want to traverse the whole stack, it’s simply a matter of calling the forEach() method:



If we look at the Java 1.4’s StackTraceElement – it’s pretty much a DTO containing String information about a declaring class, method name, classloader name, etc.

StackWalker.StackFrame is a much more type-safe-friendly upgrade of the above enriched with methods like:

public Class<?> getDeclaringClass();
public MethodType getMethodType();

…and even:

public StackTraceElement toStackTraceElement();

If we missed the legacy format.


Let’s put that into action and create a simple call hierarchy:

public static void main(String[] args) {

private static void foo() {

private static void bar() {

And if we run it, the result will be(notice the order of stack elements):

Advanced Features

If we want to leverage laziness or frame filtering, we can use the other dedicated API method called walk() that allows us to use Stream API to conveniently traverse the stack. While reading this, you probably imagined the walk() method to simply return a Stream instance – well, this is not the case.

The actual signature is:

public <T> T walk(Function<? super Stream<StackFrame>, ? extends T> function)

And there’s a good reason for it to be this way – the stack needs to be frozen for it to be traversed and this happens within the scope of the walk() method call – so it makes sense to utilize functional-interface-based Template Method implementation to achieve that.

Even if you try to trick it by returning a Stream instance, it won’t be usable (try it yourself!).

Once we know that limitation, we’re only bound by our imagination and Stream API capabilities – for example, we can gracefully skip some frames, and pick the first encountered one:

  .walk(s -> s.skip(1).limit(1).collect(Collectors.toList()))

// result

If you enjoyed the content, consider supporting the site: