IntelliJ Tips and Tricks
The ones that actually save time. Not the ones that look impressive in a demo.
By Steve Armstrong | Senior Software Engineer
I have been using IntelliJ full time for years. Enterprise Java, large codebases, the kind of projects where you spend more time reading code than writing it. Over that time you stop caring about features that look cool and start caring about the ones that make you faster.
These are those ones. Some are obvious. Some most people never find. All of them are worth knowing.
1. Breakpoint Groups (hidden gem)
Open the Breakpoints dialog: Windows: Ctrl + Shift + F8 Mac: Cmd + Shift + F8
Most people scatter breakpoints across a codebase and then forget which ones belong to what. IntelliJ lets you group breakpoints and give each group a name. The way I use this: whenever I pick up a Jira ticket, I create a group named after the ticket number — say, PROJ-1042 — and add every breakpoint I set for that ticket to that group.
When you are done with the ticket, uncheck the group. All those breakpoints get disabled in one click without deleting them. When the ticket comes back for rework, you just re-enable the group and everything is exactly where you left it. No hunting through files trying to remember where you were debugging.
To create a group, right-click any breakpoint in the Breakpoints dialog and select Move to Group. Name it after the ticket number. It takes ten seconds to set up and saves a lot of confusion on longer tickets.
2. Search Everywhere
Windows: Shift Shift Mac: Shift Shift
Double tap Shift and a search box opens that finds literally anything — classes, files, symbols, actions, settings. If you are still using the file tree to navigate, stop. This is faster for everything.
3. Find Action (hidden gem)
Windows: Ctrl + Shift + A Mac: Cmd + Shift + A
Can’t remember a shortcut? Search for any action by name and run it directly. This is also how you discover features you didn’t know existed. Type “column selection” or “wrap with” and see what comes up.
4. Recent Files
Windows: Ctrl + E Mac: Cmd + E
Opens a popup of your recently accessed files. You can also start typing to filter. Faster than any tab management strategy you currently have.
5. Navigate to Last Edit Location (hidden gem)
Windows: Ctrl + Shift + Backspace Mac: Cmd + Shift + Backspace
Jumps you back to the exact line you last edited. Useful when you are reading code across multiple files and need to get back to where you were working. Most people do not know this exists.
6. Multiple Cursors (hidden gem)
Windows: Alt + Click Mac: Alt + Click
Click in multiple places while holding Alt and you get a cursor at each location. Edit all of them simultaneously. Useful for renaming repetitive patterns that a refactor tool would overcomplicate.
7. Select Next Occurrence
Windows: Alt + J Mac: Ctrl + G
Select a word, then keep pressing this shortcut to select the next occurrence of it in the file. Each one gets its own cursor. Edit all of them at once. Faster than find and replace for simple cases.
8. Expand and Shrink Selection
Windows: Ctrl + W / Ctrl + Shift + W Mac: Alt + Up / Alt + Down
Expands or shrinks your selection by syntax scope — word, expression, statement, block, method, class. Much more precise than dragging. Use it when you need to copy a whole expression without counting brackets.
9. Matching Brace Navigation
Windows: Ctrl + Shift + M Mac: Ctrl + M
Jumps your cursor between the opening and closing brace of a block. Useful in deeply nested code when you want to quickly check where a block ends without scrolling.
10. Navigate Between Methods
Windows: Alt + Up / Alt + Down Mac: Ctrl + Up / Ctrl + Down
Jumps to the previous or next method in the file. Saves a lot of scrolling in long classes.
11. Toggle Field Watchpoint (hidden gem)
Right-click on a field in the editor, then select Toggle Field Watchpoint.
This one is underused. A watchpoint pauses execution whenever the value of that field changes, showing you exactly where and when it was modified. Invaluable when tracking down unexpected state mutations in a running application. You don’t need to scatter debug print statements everywhere — just set a watchpoint and let the debugger do the work.
12. Evaluate Expression During Debug (hidden gem)
Windows: Alt + F8 Mac: Alt + F8
While paused at a breakpoint, open this and run any expression against the current state of your program. Call methods, inspect objects, test logic — without restarting. One of the most powerful debugger features and one of the least used.
13. Extract Method / Variable
Windows: Ctrl + Alt + M (method) Ctrl + Alt + V (variable)
Mac: Cmd + Alt + M (method) Cmd + Alt + V (variable)
Select any expression and extract it into a named variable or a separate method. IntelliJ handles the refactor cleanly. Use this constantly when cleaning up bloated methods.
14. Inline Variable (hidden gem)
Windows: Ctrl + Alt + N Mac: Cmd + Alt + N
The opposite of Extract Variable. If you have a variable that is only used once and adds no clarity, this replaces it inline. Useful during cleanup when you realize a variable name isn’t earning its keep.
15. Live Templates
Windows / Mac: Ctrl + J
Type a short abbreviation and expand it into a full code block. sout becomes System.out.println(), fori becomes a for loop. You can also create your own. Go to Settings, search “Live Templates”, and build whatever boilerplate you type repeatedly.
16. Structural Search and Replace (hidden gem)
Edit menu, then Find, then Search Structurally.
This is find and replace but it understands code structure, not just text. You can write patterns that match code semantically — for example, find all method calls with a specific signature and replace them. Almost nobody uses this. It is genuinely powerful for large refactors.
17. Increase IntelliJ Memory Allocation
Help menu, then Change Memory Settings.
By default IntelliJ runs with a fairly conservative heap size. On large codebases this shows up as sluggishness, freezes during indexing, or outright out of memory errors. The fix is straightforward — go to Help, Change Memory Settings, and bump the heap size up. 2048 MB is a reasonable starting point. 4096 MB if your machine can spare it and you are working on a large monorepo or multiple projects simultaneously.
After changing it, restart IntelliJ. You will notice the difference during indexing and when running multiple run configurations at the same time. If you are on a machine with 16 GB of RAM or more and you have not done this yet, do it now.
18. HotSwap — Reload Changed Classes Without Restarting (hidden gem)
While attached to the debugger, press Windows: Ctrl + Shift + F9 Mac: Cmd + Shift + F9 to recompile the current file. Then go to Run, then Debugging Actions, then Reload Changed Classes.
This pushes the recompiled class directly into the running JVM without stopping and restarting the application. No full redeploy, no waiting for the server to come back up. You make a change, reload, and keep debugging from where you were.
There are limitations — you cannot hot swap structural changes like adding new methods or changing method signatures. But for logic changes inside existing methods, it works reliably and saves a significant amount of time when you are iterating on a fix. In a large Spring Boot application where a full restart takes two or three minutes, this compounds quickly over a debugging session.
If you want to go further, look into DCEVM or JRebel — both extend HotSwap to support structural changes as well. But the built-in version handles most day-to-day cases just fine.
19. The Problems Tab
View menu, then Tool Windows, then Problems. Or look for the Problems tab at the bottom of the IDE.
The Problems tab gives you a consolidated view of every issue IntelliJ has detected across your entire project — compilation errors, warnings, code quality issues, typos in string literals, missing dependencies. All in one place, grouped by file.
Most developers only find out about problems when the compiler yells at them or when something breaks at runtime. The Problems tab surfaces issues passively in the background as you work. You do not have to go hunting — if something is wrong anywhere in the project, it shows up here.
The more useful habit is to check it before raising a pull request. It will catch things like unused imports, unreachable code, or a null safety warning that your eyes skipped over during review. Takes ten seconds and occasionally saves you a comment from a reviewer pointing out something embarrassing.
That covers most of what I reach for daily. If there are specific workflows you want covered — debugging, Git, Spring-specific tooling — let me know in the comments.
Steve