How to store printStackTrace into a string

Your secret weapon: StringWriter & PrintWriter combo

Exception handling is a cake, and stack trace is the cherry on top. But a cherry that you can store as a String reaps some extra rewards. Let's unravel why StringWriter and PrintWriter were born for this mission.

The StringWriter brief

The magic of StringWriter and PrintWriter, key players from the java.io package, is all about I/O operations. The former being a character stream that collects output in a string buffer, and the latter adding formatting capabilities, are your secret weapon to catching the stack trace output as a string.

Secret mission: printStackTrace

The printStackTrace() method is from the Throwable class. Its job is to print the stack trace to the standard error stream until you assign it a new mission with a PrintWriter, as your mole, and redirecting the trace to a string.

The call sign: toString()

At this point, your stack trace is hidden within StringWriter. The secret handshake to retrieve it is performed by using toString().

Alternative strategies: stack trace management libraries

The golden rule of programming: There's more than one way to do it. While StringWriter and PrintWriter are standard-field agents, there are gee-whiz libraries offering easy methods to convert stack traces to strings.

Guava's clever play

Google’s Guava library comes with a slick trick:

String stackTraceString = Throwables.getStackTraceAsString(e);
// Quick, clean, done!


Apache Commons' tactical move

Apache Commons Lang deploys ExceptionUtils with a getStackTrace() tactic:

String stackTraceString = ExceptionUtils.getStackTrace(e);


For the full intel, getFullStackTrace() can be used to capture all the nested stack traces.

Custom operations with getStackTrace()

Sometimes you call the shots. For custom maneuvers, turn to Throwable’s getStackTrace() method which returns an array of stack trace elements.

StackTraceElement[] elements = e.getStackTrace();
StringBuilder sb = new StringBuilder();
String newLine = System.getProperty("line.separator");

for(StackTraceElement element : elements) {
    sb.append(element.toString());
    sb.append(newLine);
}

String customStackTrace = sb.toString();
// That's how you leave your mark!


This gives you full control over line separators and additional formatting.

Sidestepping the traps: tips and considerations

A quick head's up of some best practices and pitfalls that will ensure smooth error handling:

• A huge stack trace can hit the performance when converting to a string. You might just want to capture the breaking news.
• In multi-threaded applications, ensuring StringWriter remains thread safe can be a cat-and-mouse game.
• Introducing alternative libraries means adding external dependencies. Weigh this against using the more low-key Java classes.