# Pro tips

This guide targets IntelliJ IDEA users who are already familiar with its basic features and would like to learn more. If you are relatively new to IntelliJ IDEA, we recommend that you read the [IntelliJ IDEA overview](discover-intellij-idea.html)     before delving into this one.

## Coding assistance

### Full Line code completion

The [Full Line code completion](full-line-code-completion.html) feature uses a locally run deep learning model to suggest entire lines of code.

[Video](https://resources.jetbrains.com.cn/help/img/idea/2026.2/ij_full_line_completion.mp4)

* To accept an entire suggestion, press `Tab` (Windows), `Tab` (macOS), `Tab` (IntelliJ IDEA Classic (macOS)), `Tab` (macOS System Shortcuts), `Tab` (XWin), `Tab` (GNOME), `Tab` (KDE), `Tab` (Emacs), `Tab` (Sublime Text), `Tab` (Sublime Text (macOS)), `Tab` (NetBeans), `Tab` (Visual Studio), `Tab` (Visual Studio (macOS)), `Tab` (Eclipse), `Tab` (Eclipse (macOS)). Alternatively, go to `Code | Code Completion | Insert Inline Proposal` in the main menu or [configure a different shortcut]().

* To accept a suggestion word by word, press `Ctrl+Right` (Windows), `⌥ →` (macOS), `⌥ →` (IntelliJ IDEA Classic (macOS)), `⌥ →` (macOS System Shortcuts), `Ctrl+Right` (XWin), `Ctrl+Right` (GNOME), `Ctrl+Right` (KDE), `Ctrl+Right` (Emacs), `Ctrl+Right` (Sublime Text), `⌥ →` (Sublime Text (macOS)), `Ctrl+Right` (NetBeans), `Ctrl+Right` (Visual Studio), `⌥ →` (Visual Studio (macOS)), `Ctrl+Right` (Eclipse), `⌥ →` (Eclipse (macOS)) or go to `Code | Code Completion | Insert Inline Proposal's Word` in the main menu.

* To accept a suggestion line by line, press `End` (Windows), `⌘ →` (macOS), `⌘ →` (IntelliJ IDEA Classic (macOS)), `⌘ →` (macOS System Shortcuts), `End` (XWin), `End` (GNOME), `End` (KDE), `End` (Emacs), `End` (Sublime Text), `⌘ →` (Sublime Text (macOS)), `End` (NetBeans), `End` (Visual Studio), `⌘ →` (Visual Studio (macOS)), `End` (Eclipse), `⌘ →` (Eclipse (macOS)) or go to `Code | Code Completion | Insert Inline Proposal's Line` in the main menu.

### Type Info and Quick Documentation

If you want more information about a symbol at caret, for example, where it comes from or what its type is, the  [Quick Documentation](viewing-reference-information.html#inline-quick-documentation) is your friend. Press `Ctrl+Q` (Windows), `F1` (macOS), `⌃ J` (IntelliJ IDEA Classic (macOS)), `⌘ I` (macOS System Shortcuts), `Ctrl+Q` (XWin), `Ctrl+Q` (GNOME), `Ctrl+Q` (KDE), `Ctrl+Q` (Emacs), `Ctrl+Q` (Sublime Text), `Ctrl+Q` (Sublime Text (macOS)), `Ctrl+Q` (NetBeans), `Ctrl+K, I` (Visual Studio), `⌘ K, I` (Visual Studio (macOS)), `Alt+Middle-Click` (Eclipse), `⌥ Middle-Click` (Eclipse (macOS)) to invoke it, and you will see a popup with these details.

[Video](https://resources.jetbrains.com.cn/help/img/idea/2026.2/quick-doc-popup.mp4)

If you do not need the full info, then use the Type Info action instead: place the caret at a code element and press `Ctrl+Shift+P` (Windows), `⌃ ⇧ P` (macOS), `⌃ ⇧ P` (IntelliJ IDEA Classic (macOS)), `⌃ ⇧ P` (macOS System Shortcuts), `Ctrl+Shift+P` (XWin), `Ctrl+Shift+P` (GNOME), `Ctrl+Shift+P` (KDE), `Ctrl+Shift+P` (Emacs), `Ctrl+Shift+P` (Sublime Text), `⌃ ⇧ P` (Sublime Text (macOS)), `Ctrl+Shift+P` (NetBeans), `Ctrl+Shift+P` (Visual Studio), `Ctrl+Shift+P` (Visual Studio (macOS)), `Ctrl+Shift+P` (Eclipse), `Ctrl+Shift+P` (Eclipse (macOS)) or go to `View | Type Info` in the main menu. It only shows the type of the selected expression but does not take up that much of screen space.

![Showing the expression type info](https://resources.jetbrains.com.cn/help/img/idea/2026.2/type-info.png)

### Code completion case sensitivity

By default, IntelliJ IDEA code completion case sensitivity only affects the first letter you type. This strategy can be changed   in the Settings dialog (`Ctrl+Alt+S` (Windows), `⌘ Comma` (macOS), `⌘ Comma` (IntelliJ IDEA Classic (macOS)), `⌘ Comma` (macOS System Shortcuts), `Ctrl+Alt+S` (XWin), `Ctrl+Alt+S` (GNOME), `Ctrl+Alt+S` (KDE), `Ctrl+Alt+S` (Emacs), `Ctrl+Alt+S` (Sublime Text), `⌘ Comma` (Sublime Text (macOS)), `Ctrl+Alt+S` (NetBeans), `Ctrl+Alt+S` (Visual Studio), `⌘ Comma` (Visual Studio (macOS)), `Ctrl+Alt+S` (Eclipse), `⌘ Comma` (Eclipse (macOS))) on the `Editor | General | Code Completion | Popup` page, where you can make the IDE sensitive to all letters.

![Code Completion settings](https://resources.jetbrains.com.cn/help/img/idea/2026.2/code_completion.png)

Here, you can also turn off the Show suggestions as you type option. This makes sense if you want the code completion popup to show up only when you explicitly call it.

### CamelHumps

By default, when you select anything in the editor, IntelliJ IDEA is not sensitive to the case of the words. If you prefer to select words according to CamelCase, for example, instead of selecting the whole word, select a part of it. You can enable this in `Editor | General | Smart Keys` of the Settings dialog.

[Video](https://resources.jetbrains.com.cn/help/img/idea/2026.2/camelHumpsOption.mp4)

## Refactorings

### Extract string fragments

IntelliJ IDEA is capable of refactoring not only executable code, but also string literals. Select any fragment of a string, call Extract variable/constant/field/parameter to extract it as a constant and replace its usages throughout the code.

### Type migration

When you refactor, you usually rename symbols or extract and move statements in the code. However, there is more to refactoring than that. For example, [Type migration](type-migration.html) (available via `Ctrl+Shift+F6` (Windows), `⌘ ⇧ F6` (macOS), `⌘ ⇧ F6` (IntelliJ IDEA Classic (macOS)), `⌘ ⇧ F6` (macOS System Shortcuts), `Ctrl+Shift+F6` (XWin), `Ctrl+Shift+F6` (GNOME), `Ctrl+Shift+F6` (KDE), `Ctrl+Shift+F6` (Emacs), `Ctrl+Shift+F6` (Sublime Text), `Ctrl+Shift+F6` (Sublime Text (macOS)), `Ctrl+Shift+F6` (NetBeans), `Ctrl+Shift+F6` (Visual Studio), `⌘ ⇧ F6` (Visual Studio (macOS)), `Ctrl+Shift+F6` (Eclipse), `Ctrl+Shift+F6` (Eclipse (macOS))) lets you change the type for a variable, field, parameter or a method's return value (`int → String`, `int → Long`, and so on, update the dependent code, and resolve possible conflicts.

### Invert boolean

If IntelliJ IDEA can automate type migration, why not do the same with semantics? To invert all usages of a boolean symbol, use the [Invert Boolean refactoring](invert-boolean-refactoring.html).

### Undo refactorings

With IntelliJ IDEA you do not need to worry about consequences when refactoring code, because you can always undo anything by invoking  [Undo](working-with-source-code.html#editor_code_selection) via the convenient `Ctrl+Z` (Windows), `⌘ Z` (macOS), `⌘ Z` (IntelliJ IDEA Classic (macOS)), `⌘ Z` (macOS System Shortcuts), `Ctrl+Z` (XWin), `Ctrl+Z` (GNOME), `Ctrl+Z` (KDE), `Ctrl+Shift+Minus` (Emacs), `Ctrl+Z` (Sublime Text), `⌘ Z` (Sublime Text (macOS)), `Ctrl+Z` (NetBeans), `Ctrl+Z` (Visual Studio), `⌘ Z` (Visual Studio (macOS)), `Ctrl+Z` (Eclipse), `⌘ Z` (Eclipse (macOS)) shortcut.

## Code analysis

### Structural search and replace

[Structural Search and Replace, or SSR](structural-search-and-replace.html), is a powerful tool. You can use it for static code analysis and refactoring automation. In a nutshell, it lets you search for specific patterns in your code and replace them with parametrized templates. For that, it is equipped with its own language for defining code patterns described in more detail in this [article](https://www.jetbrains.com.cn/en-us/idea/docs/ssr.pdf).

To access this feature, go to `Edit | Find | Search/Replace Structurally` in the main menu.

![The Structural search and replace dialog](https://resources.jetbrains.com.cn/help/img/idea/2026.2/structural_search_dialog.png)

## User interface

### Disable breadcrumbs and tag tree highlighting

If you work with lots of HTML and XML and would like to avoid unnecessary distraction, you may want to disable breadcrumbs and tag tree highlighting in `Editor | General | Breadcrumbs`.

### Disable unnecessary gutter icons

Gutter, the leftmost editor column, typically displays useful information related to the code you are editing. If you feel that sometimes it is too much, you can configure what you want to see   in the Settings dialog (`Ctrl+Alt+S` (Windows), `⌘ Comma` (macOS), `⌘ Comma` (IntelliJ IDEA Classic (macOS)), `⌘ Comma` (macOS System Shortcuts), `Ctrl+Alt+S` (XWin), `Ctrl+Alt+S` (GNOME), `Ctrl+Alt+S` (KDE), `Ctrl+Alt+S` (Emacs), `Ctrl+Alt+S` (Sublime Text), `⌘ Comma` (Sublime Text (macOS)), `Ctrl+Alt+S` (NetBeans), `Ctrl+Alt+S` (Visual Studio), `⌘ Comma` (Visual Studio (macOS)), `Ctrl+Alt+S` (Eclipse), `⌘ Comma` (Eclipse (macOS))): [Editor | General | Gutter
Icons](settings-gutter-icons.html).

### Search everywhere

With [Search Everywhere](searching-everywhere.html) you can find arbitrary text fragments literally everywhere: in your code, libraries, parts of the UI, settings (by prepending the settings name with `/`), or even action names. If you are using this feature a lot, it is worth knowing that you can access IntelliJ IDEA settings by pressing `Enter` (Windows), `⏎` (macOS), `⏎` (IntelliJ IDEA Classic (macOS)), `⏎` (macOS System Shortcuts), `Enter` (XWin), `Enter` (GNOME), `Enter` (KDE), `Enter` (Emacs), `Enter` (Sublime Text), `⏎` (Sublime Text (macOS)), `Enter` (NetBeans), `Enter` (Visual Studio), `⏎` (Visual Studio (macOS)), `Enter` (Eclipse), `⏎` (Eclipse (macOS)) right in its popup. For example, here we are accessing the editor settings:

![Search for Settings](https://resources.jetbrains.com.cn/help/img/idea/2026.2/search_for_settings.png)

If you start your search query with `/plugins`, you'll be able to turn them on and off:

![Search Everywhere: /plugins ](https://resources.jetbrains.com.cn/help/img/idea/2026.2/plugins_search_everywhere.png)

Other tags include `/appearance`, `/system`, `/inspections`, `/registry`, `/intentions`, `/templates`, and `/vcs`.

Another interesting fact is that Search Everywhere supports abbreviations. You can use [Keymap page](settings-keymap.html) of the Settings dialog to assign a short text to any action,

![Example of using abbreviations in Search Everywhere](https://resources.jetbrains.com.cn/help/img/idea/2026.2/keymap_color_picker.png)

and then have this action called from Search Everywhere by entering this text:

![Search Results](https://resources.jetbrains.com.cn/help/img/idea/2026.2/search_everywhere_abbreviation_results.png)

### Hide editor tabs

When you need to close all editor tabs except the current one, click the close icon ![the Close button](https://resources.jetbrains.com.cn/help/img/idea/2026.2/app.expui.general.closeSmall.svg) on the current tab holding `Alt` (Windows), `Alt` (macOS), `Alt` (IntelliJ IDEA Classic (macOS)), `Alt` (macOS System Shortcuts), `Alt` (XWin), `Alt` (GNOME), `Alt` (KDE), `Alt` (Emacs), `Alt` (Sublime Text), `Alt` (Sublime Text (macOS)), `Alt` (NetBeans), `Alt` (Visual Studio), `Alt` (Visual Studio (macOS)), `Alt` (Eclipse), `Alt` (Eclipse (macOS)).

![The example of using the Close Others option](https://resources.jetbrains.com.cn/help/img/idea/2026.2/close_others_1.png)

If you do not want to see the editor tabs at all, go to the [Editor Tabs](settings-editor-tabs.html) page in settings and from the Tab placement drop-down list, select None.

### Open a file in a new window

This feature is not that easy to find, yet comes in handy. You can open a file in a new window by selecting it in the [Project tool window](project-tool-window.html) and pressing `Shift+Enter` (Windows), `⇧ ⏎` (macOS), `⇧ ⏎` (IntelliJ IDEA Classic (macOS)), `⇧ ⏎` (macOS System Shortcuts), `Shift+Enter` (XWin), `Shift+Enter` (GNOME), `Shift+Enter` (KDE), `Shift+Enter` (Emacs), `Ctrl+Enter` (Sublime Text), `⌘ ⏎` (Sublime Text (macOS)), `Shift+Enter` (NetBeans), `Shift+Enter` (Visual Studio), `⇧ ⏎` (Visual Studio (macOS)), `Shift+Enter` (Eclipse), `⇧ ⏎` (Eclipse (macOS)).

## Editor

### Compare with clipboard

IntelliJ IDEA has a built-in diff viewer for code, jar files, revisions, and even images. To invoke it, select any pair of files and press `Ctrl+D` (Windows), `⌘ D` (macOS), `⌘ D` (IntelliJ IDEA Classic (macOS)), `⌘ D` (macOS System Shortcuts), `Ctrl+D` (XWin), `Ctrl+D` (GNOME), `Ctrl+D` (KDE), `Ctrl+D` (Emacs), `Ctrl+D` (Sublime Text), `⌘ D` (Sublime Text (macOS)), `Ctrl+D` (NetBeans), `Ctrl+D` (Visual Studio), `⌘ D` (Visual Studio (macOS)), `Ctrl+D` (Eclipse), `⌘ D` (Eclipse (macOS)).

If you have selected a single file, the IDE will prompt you to select the one to compare to. To quickly compare the active editor with the Clipboard, choose `View | Compare with Clipboard`.

![The compare with clipboard feature with a diff of one method](https://resources.jetbrains.com.cn/help/img/idea/2026.2/CompareWithClipboard.png)

### Paste from history

IntelliJ IDEA keeps track of everything you copy onto your Clipboard. Anytime you want to paste one of the previously copied items from your Clipboard history, press `Ctrl+Shift+V` (Windows), `⌘ ⇧ V` (macOS), `⌘ ⇧ V` (IntelliJ IDEA Classic (macOS)), `⌘ ⇧ V` (macOS System Shortcuts), `Ctrl+Shift+V` (XWin), `Ctrl+Shift+V` (GNOME), `Ctrl+Shift+V` (KDE), `Alt+Y` (Emacs), `Ctrl+K, Ctrl+V` (Sublime Text), `⌘ K, ⌘ V` (Sublime Text (macOS)), `Ctrl+Shift+V` (NetBeans), `Ctrl+Shift+V` (Visual Studio), `⌘ ⇧ V` (Visual Studio (macOS)), `Ctrl+Shift+V` (Eclipse), `⌘ ⇧ V` (Eclipse (macOS)).

![Dialog to paste from clipboard history](https://resources.jetbrains.com.cn/help/img/idea/2026.2/PasteFromHistory.png)

### Multiple selections

[Multiple selection](multicursor.html#multiple_words) lets you quickly select and edit multiple pieces of text at once.

First, select the text range you want to edit.

Then, press `Alt+J` (Windows), `⌃ G` (macOS), `⌃ G` (IntelliJ IDEA Classic (macOS)), `⌃ G` (macOS System Shortcuts), `Alt+J` (XWin), `Alt+J` (GNOME), `Alt+J` (KDE), `Alt+J` (Emacs), `Ctrl+D` (Sublime Text), `⌘ D` (Sublime Text (macOS)), `Alt+J` (NetBeans), `Alt+Shift+.` (Visual Studio), `⌥ ⇧ .` (Visual Studio (macOS)), `Alt+Y` (Eclipse), `⌃ G` (Eclipse (macOS)) and IntelliJ IDEA will search the current file forward until it finds a case-sensitively matching piece of text, which it adds to the selection. You can press `Alt+J` (Windows), `⌃ G` (macOS), `⌃ G` (IntelliJ IDEA Classic (macOS)), `⌃ G` (macOS System Shortcuts), `Alt+J` (XWin), `Alt+J` (GNOME), `Alt+J` (KDE), `Alt+J` (Emacs), `Ctrl+D` (Sublime Text), `⌘ D` (Sublime Text (macOS)), `Alt+J` (NetBeans), `Alt+Shift+.` (Visual Studio), `⌥ ⇧ .` (Visual Studio (macOS)), `Alt+Y` (Eclipse), `⌃ G` (Eclipse (macOS)) again to go forward, or `Alt+Shift+J` (Windows), `⌃ ⇧ G` (macOS), `⌃ ⇧ G` (IntelliJ IDEA Classic (macOS)), `⌃ ⇧ G` (macOS System Shortcuts), `Alt+Shift+J` (XWin), `Alt+Shift+J` (GNOME), `Alt+Shift+J` (KDE), `Alt+Shift+J` (Emacs), `Alt+Shift+J` (Sublime Text), `⌃ ⇧ G` (Sublime Text (macOS)), `Alt+Shift+J` (NetBeans), `Alt+Shift+Comma` (Visual Studio), `⌥ ⇧ Comma` (Visual Studio (macOS)), `Alt+Shift+Y` (Eclipse), `⌃ ⇧ G` (Eclipse (macOS)) to go back, but note that when the search reaches the end of file, it will start over from the beginning of the file.

After the selection is complete, you can start editing all the fragments as if they were one.

![the Multiple Selection feature used in the editor](https://resources.jetbrains.com.cn/help/img/idea/2026.2/MultipleSelections.png)

### Regex

Regular expressions (often called regex or regexp) are patterns used to validate, search, or replace text. IntelliJ IDEA offers various features that help you work with regular expressions.

The [Find
and replace](tutorial-finding-and-replacing-text-using-regular-expressions.html) feature lets you search for text that matches a regex as well as replace it using backreferences or case-switching symbols.

![Replace with regex result](https://resources.jetbrains.com.cn/help/img/idea/2026.2/replace_with_regex.png)

To search in a single file, press `Ctrl+R` (Windows), `⌘ R` (macOS), `⌘ R` (IntelliJ IDEA Classic (macOS)), `⌘ R` (macOS System Shortcuts), `Ctrl+R` (XWin), `Ctrl+R` (GNOME), `Ctrl+R` (KDE), `Alt+Shift+5` (Emacs), `Ctrl+H` (Sublime Text), `⌘ ⌥ F` (Sublime Text (macOS)), `Ctrl+H` (NetBeans), `Ctrl+H` (Visual Studio), `⌃ H` (Visual Studio (macOS)), `Ctrl+F` (Eclipse), `Ctrl+R` (Eclipse (macOS)). To search in multiple files, press `Ctrl+Shift+R` (Windows), `⌘ ⇧ R` (macOS), `⌃ ⇧ R` (IntelliJ IDEA Classic (macOS)), `⌘ ⇧ R` (macOS System Shortcuts), `Ctrl+Shift+R` (XWin), `Ctrl+Shift+R` (GNOME), `Ctrl+Shift+R` (KDE), `Ctrl+Shift+R` (Emacs), `Ctrl+Shift+R` (Sublime Text), `Ctrl+Shift+R` (Sublime Text (macOS)), `Ctrl+Shift+H` (NetBeans), `Ctrl+Shift+H` (Visual Studio), `⌘ ⇧ H` (Visual Studio (macOS)), `Ctrl+Shift+R` (Eclipse), `Ctrl+Shift+R` (Eclipse (macOS)).

The [Check RegExp](regular-expressions.html#check_regexp) intention action lets you test a regex against an entered value and check if it works as expected.

![Using regular expressions](https://resources.jetbrains.com.cn/help/img/idea/2026.2/CheckRegex.png)

The [Explain regular expression](regular-expressions.html#explain-regular-expression) intention action lets you check what criteria a text must meet to match the regex.

![Tooltip explaining elements of a regular expression](https://resources.jetbrains.com.cn/help/img/idea/2026.2/explain_regex.png)

To invoke an intention action, place the caret at a regex, press `Alt+Enter` (Windows), `⌥ ⏎` (macOS), `⌥ ⏎` (IntelliJ IDEA Classic (macOS)), `⌥ ⏎` (macOS System Shortcuts), `Alt+Enter` (XWin), `Alt+Enter` (GNOME), `Alt+Enter` (KDE), `Alt+Enter` (Emacs), `Alt+Enter` (Sublime Text), `⌥ ⏎` (Sublime Text (macOS)), `Alt+Enter` (NetBeans), `Alt+Enter` (Visual Studio), `⌥ ⏎` (Visual Studio (macOS)), `Ctrl+1` (Eclipse), `⌘ 1` (Eclipse (macOS)), and select an action from the list.

## Version control

### Amend changes

In the [Commit Changes dialog](commit-and-push-changes.html#commit) IntelliJ IDEA offers to perform a variety of operations. One of them is Amend commit, which is useful when you want to change your last commit and join your current change to it.

### Shelves and patches

Shelves is an IDE feature similar to [Git Stash](https://git-scm.com/book/en/v2/Git-Tools-Stashing-and-Cleaning), but that works for all VCS: it helps when you need to pause your current work and pull something from the repository to fix it asap, and then resume working on whatever it was you were working on. This feature takes care of locally changed files without committing them, so no more lost changes or hastily made merge commits.

For more information, refer to the page [Git-Stash](http://git-scm.com/docs/git-stash) and to the section [Stashing and Unstashing](shelving-and-unshelving-changes.html#stash).

Patches allow you to save a set of changes to a text file that can be transferred via email (or any other ancient medium), and then applied to the code. It is helpful when you really need to commit something after your plane landed on a desert island, or you somehow else got yourself in a situation without reliable broadband connection.

For more information, refer to [Using Patches](using-patches.html).

## Debugging

### Non-suspending breakpoints

Sometimes you may want to evaluate something at a particular line of code without suspending the program. You can do that by using a non-suspending breakpoint. To create one, click the gutter holding `Shift` (Windows), `Shift` (macOS), `Shift` (IntelliJ IDEA Classic (macOS)), `Shift` (macOS System Shortcuts), `Shift` (XWin), `Shift` (GNOME), `Shift` (KDE), `Shift` (Emacs), `Shift` (Sublime Text), `Shift` (Sublime Text (macOS)), `Shift` (NetBeans), `Shift` (Visual Studio), `Shift` (Visual Studio (macOS)), `Shift` (Eclipse), `Shift` (Eclipse (macOS)) and enter the expression in the Evaluate and log field.

![Using method breakpoints](https://resources.jetbrains.com.cn/help/img/idea/2026.2/ij_breakpoint_action.png)

This way you can change or log the application state without inserting additional statements in the project code. This is especially useful when you debug compiled classes, which you cannot change.

### Field breakpoints or field watchpoints

In addition to the action breakpoints mentioned above, you can also use [Field watchpoints](using-breakpoints.html#field_watchpoint). This breakpoint will stop execution when a field associated with it is accessed. To create field watchpoints, click the gutter holding `Alt` (`Ctrl+Cmd` for macOS).

![Using field watchpoints](https://resources.jetbrains.com.cn/help/img/idea/2026.2/ij_breakpoint_field.png)

### Object markers

When you are debugging an application, IntelliJ IDEA lets you mark particular instances of arbitrary objects with colored labels for easier identification via the  [Mark Object](examining-suspended-program.html#use-labels) action (available in the [Evaluate Expression](null), , [Variables](examining-suspended-program.html#variables) or  [Watches](examining-suspended-program.html#watches) views. )

And if you have any instance marked with a label, you can use it in the condition expression as well:

![Using object markers](https://resources.jetbrains.com.cn/help/img/idea/2026.2/ij_breakpoint_debug_label.png)

### Custom data renderers

[Evaluate Expression](examining-suspended-program.html#evaluating-expressions) ,  [Variables](examining-suspended-program.html#variables) ,  [Watches](examining-suspended-program.html#watches) and  [inline debugger](examining-suspended-program.html#inline-view) all use a standard way to render variable values, mostly based on `toString` implementation of classes. Not everyone knows that you can define your own custom renderers for any class. For that, select `Customize Data Views` from the context menu in the [Debug tool window](debug-tool-window.html) tool window.

![Using custom data renderers](https://resources.jetbrains.com.cn/help/img/idea/2026.2/ij_type_renderer.png)

This is especially useful when some of the classes in the libraries you're using do not provide a meaningful a `toString` implementation–so you can define it yourself outside of the library.

### Drop frame

In case you want to “go back in time” while debugging, you can do it via the Drop Frame action. This is a great help if you mistakenly stepped too far. This will not revert the global state of your application but at least will get you back by stack of frames.

### Force return

If you want to jump to the future and force the return from the current method without executing any more instructions from it, use the Force Return action (to invoke it, press `Ctrl+Shift+A` (Windows), `⌘ ⇧ A` (macOS), `⌘ ⇧ A` (IntelliJ IDEA Classic (macOS)), `⌘ ⇧ P` (macOS System Shortcuts), `Ctrl+Shift+A` (XWin), `Ctrl+Shift+A` (GNOME), `Ctrl+Shift+A` (KDE), `Escape, X` (Emacs), `Ctrl+Shift+P` (Sublime Text), `⌘ ⇧ P` (Sublime Text (macOS)), `Ctrl+I` (NetBeans), `Ctrl+Shift+A` (Visual Studio), `⌘ ⇧ A` (Visual Studio (macOS)), `Ctrl+Shift+A` (Eclipse), `⌘ 3` (Eclipse (macOS)) and type the action name). If the method returns a value, you will have to specify it.

## Language Injection

Language injections allow the IDE to recognize pieces of code embedded into string literals. When you inject a language into a string literal, you get comprehensive code assistance for editing that literal, such as syntax highlighting and code completion.

For example, in Java code, you can inject JSON into a string literal. IntelliJ IDEA recognizes the injected JSON code and provides JSON-specific features such as syntax highlighting and code formatting within the injected fragment, making it easier to work with both languages in the same file.

Learn more from [Language Injection](using-language-injections.html).

![An example of language injection with JSON](https://resources.jetbrains.com.cn/help/img/idea/2026.2/LanguageInjection.png)

## Update application

If you are running your application on an application server (Tomcat, JBoss, and so on), can you reload changed classes and resources using the Update application action via `Ctrl+F10` (Windows), `⌘ F10` (macOS), `⌘ F10` (IntelliJ IDEA Classic (macOS)), `⌘ F10` (macOS System Shortcuts), `Ctrl+F10` (XWin), `Ctrl+F10` (GNOME), `Ctrl+F10` (KDE), `Ctrl+F10` (Emacs), `Ctrl+F10` (Sublime Text), `⌘ F10` (Sublime Text (macOS)), `Ctrl+F10` (NetBeans), `Ctrl+F10` (Visual Studio), `⌘ F10` (Visual Studio (macOS)), `Ctrl+F10` (Eclipse), `⌘ F10` (Eclipse (macOS)).

For more information, refer to [Updating applications on application servers](updating-applications-on-application-servers.html).

## Tools

### External tools

IntelliJ IDEA has many developer tools integrated and working out of the box. If a tool you need is not integrated, but you'd like to use it via a shortcut, go to `Settings | Tools |` [External Tools](settings-tools-external-tools.html), and configure how to run this tool. Then you'll be able to run this tool via the `Tools | External Tools` main menu.

For more information, refer to [External tools](configuring-third-party-tools.html).