Use conditional breakpoints to pause execution only when specific conditions are met, reducing unnecessary stops in loops or frequent method calls. 2. Evaluate expressions on the fly during a debug session to inspect or modify state, test edge cases, or invoke methods without altering code. 3. Set field and method breakpoints to trigger debugging when specific fields are accessed/modified or methods are entered/exited, aiding in tracking unexpected state changes. 4. Enable remote debugging via JVM arguments like -agentlib:jdwp and connect IntelliJ to a running JVM for troubleshooting production-like environments. 5. Utilize Drop Frame to rewind execution to a previous method call, allowing re-execution of logic without restarting the entire debug session. 6. Apply Smart Step Into (Ctrl Shift F7) to selectively step into specific method calls on a line with multiple invocations, avoiding unwanted entry into library code. 7. Customize inline watches and object renderers to display meaningful representations of complex objects in the debugger, improving readability. 8. Configure non-suspending breakpoints to log messages or variable values to the console without interrupting program flow, ideal for tracing execution in loops or event handlers. 9. Analyze thread dumps using the Threads tab to identify blocked threads, detect deadlocks, and investigate concurrency issues in multi-threaded applications. 10. Attach the debugger to any running Java process directly from IntelliJ, enabling full debugging capabilities even when the app wasn’t launched from the IDE. Mastering these advanced IntelliJ IDEA debugging techniques significantly enhances efficiency in diagnosing complex issues in Java applications and eliminates reliance on basic breakpoints and print statements.

Debugging complex Java applications efficiently requires more than just setting breakpoints and stepping through code. IntelliJ IDEA offers a powerful set of advanced debugging tools that can drastically reduce troubleshooting time. Here are some lesser-known but highly effective techniques to master.

1. Conditional Breakpoints for Targeted Debugging

Sometimes a breakpoint triggers too often—like inside a loop processing thousands of items. Instead of manually resuming each time, use conditional breakpoints to pause only when specific criteria are met.

How to set one:

• Right-click the breakpoint (or press Ctrl F8 after placing it).
• Enter a boolean condition, e.g., userId == 12345 or list.size() > 100.
• The debugger will stop only when the condition evaluates to true.

? Pro tip: Use "Suspend policy" to control whether only the current thread or all threads are suspended. This is helpful in multi-threaded apps.

2. Evaluate Expressions on the Fly

While paused at a breakpoint, you can execute arbitrary Java expressions to inspect or modify state without changing your code.

To use:

• Open the Evaluate Expression dialog (Alt F8).
• Type any valid expression: userService.findById(1001), items.stream().map(Item::getName).toList(), etc.
• You can even assign values: debugFlag = true.

This is especially useful for testing edge cases or calling service methods directly during a debug session.

3. Field and Method Breakpoints (Not Just Line Breakpoints)

Standard breakpoints work on lines, but field breakpoints trigger when a specific field is accessed or modified.

Use case: You suspect a class field is being changed unexpectedly.

How to set:

• In the Project view, locate the field in your class.
• Right-click the field → Add Field Breakpoint.
• Choose "On read" or "On write" (or both).

Similarly, method breakpoints pause when a method is entered or exited. Just click the gutter next to the method signature.

?? Note: Method and field breakpoints rely on JVM instrumentation and may slow down execution slightly.

4. Remote Debugging with JVM Args

Debugging production-like environments or external services often requires connecting to a running JVM remotely.

Enable remote debugging in the target app:

-javaagent:idea_rt.jar -agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=5005

Then in IntelliJ:

• Go to Run → Edit Configurations → Add New Configuration → Remote JVM Debug.
• Set host and port (e.g., localhost:5005).
• Click Debug.

Use suspend=n to let the app start immediately; use suspend=y to pause until a debugger attaches.

5. Drop Frame to Retry Logic

Made a wrong step? Want to re-execute a method without restarting the entire debug session?

Use Drop Frame:

• In the Debug tool window, go to the Frames tab.
• Right-click a stack frame (e.g., a method call) and select Drop Frame.
• The JVM rewinds execution back to the start of that method.

? Variables modified after that frame will be lost, but it’s a huge time-saver for testing different paths.

6. Smart Step Into (Ctrl Shift F7)

When a line contains multiple method calls, Smart Step Into lets you choose which one to step into.

For example:

result = serviceA.process(userService.findActiveUsers().get(0));

Press Ctrl Shift F7 and a popup lets you pick process(), findActiveUsers(), or get(0).

Avoids the frustration of stepping into low-level library code by accident.

7. Use Inline Watches and Renderers

IntelliJ shows variable values inline during debugging, but you can customize how complex objects are displayed.

Add a custom toString() renderer:

• Right-click a variable in debug mode → View as → Configure Renderers.
• Define a custom expression like id " - " name for a User object.

Now, in the Variables pane, you’ll see meaningful summaries instead of User@2a132f.

8. Non-Suspending Breakpoints with Log Messages

Sometimes you just want to log state without interrupting execution.

Set a non-suspending breakpoint:

• Add a breakpoint.
• Right-click → Uncheck Suspend.
• Check Log message to console.
• Optionally, log a custom message like "User processed: " user.getName().

Great for tracing execution flow in loops or event handlers without freezing the app.

9. Analyze Thread Dumps and Deadlocks

IntelliJ’s debugger includes a Threads tab that shows all active threads, their states, and stack traces.

Look for:

• Threads in BLOCKED state.
• Use "Analyze Thread Dump" button to detect potential deadlocks.
• Filter threads by name or state.

Combine with jstack or JVM monitoring tools for deeper analysis.

10. Attach Debugger to a Running Process

You don’t always need to start the app from IntelliJ. You can attach the debugger to any running Java process.

Steps:

• Run → Attach to Process.
• Choose a local Java process from the list.
• IntelliJ connects and enables full debugging.

Useful for debugging Spring Boot apps started via Maven (mvn spring-boot:run) or standalone JARs.

These advanced techniques turn IntelliJ IDEA into a surgical debugging tool. Mastering them helps you diagnose race conditions, memory issues, and logic errors faster—without guesswork or excessive logging.

Basically, if you're still just using line breakpoints and System.out, you're missing half the picture.

The above is the detailed content of Advanced Java Debugging Techniques in IntelliJ IDEA. For more information, please follow other related articles on the PHP Chinese website!