IntelliJ IDEA overview

Use IntelliJ IDEA to develop applications in the following languages that can be compiled into the JVM bytecode, namely:

• Java

• Kotlin

• Scala

• Groovy

Plugins add support for some of the most popular languages, namely:

• Python (full PyCharm functionality)

• Ruby (full RubyMine functionality)

• PHP (full PhpStorm functionality)

• SQL (full DataGrip functionality)

• Go (full GoLand functionality)

• JavaScript (full WebStorm functionality)

• TypeScript (full WebStorm functionality)

• Thymeleaf

• JSON

• Markdown

• HTML

• XML and XSL

• XPath and XSLT

• Velocity and FreeMarker

• Stylesheets (CSS, Less, Sass)

• Dart

note

C/C++ are not officially supported in IntelliJ IDEA, but you can use CLion.

You can browse JetBrains Marketplace to find an official plugin that adds support for almost any language, framework or technology used today, or for third-party plugins. For more information about managing plugins, refer to Install plugins.

IntelliJ IDEA Ultimate is a superset of most IntelliJ platform-based IDEs. If the bundled language plugins are enabled, it includes support for all technologies that are available within our more specific IDEs, such as PyCharm, WebStorm, PhpStorm, and so on.

So, for example, if your application's codebase is mainly in Java but it also uses Python scripts, we recommend using IntelliJ IDEA in combination with the bundled Python plugin. If your codebase is mainly in Python, PyCharm is the right IDE for you.

IntelliJ IDEA Ultimate is available for free within the Early Access Program (EAP). EAP builds are published before the release of a stable product version, and you can download them to try out the new features before they are publicly available in return for your feedback. EAP builds are configured to collect feature usage statistics and are a valuable source of information for our developers. You can also report an issue if you encounter any problems.

note

Release Candidate (RC) builds published before a release are also available for download but require a paid license.

Preview builds published after the release of a stable version that are followed by an official update, also require a paid license and cannot be evaluated for free.

One of the best things about IntelliJ IDEA is its tunability. You can configure virtually anything: the IDE appearance, the layout of tool windows and toolbars, code highlighting, and more. There are also numerous ways you can fine-tune the editor and customize its behavior to speed up navigation and get rid of any extras that distract you from code.

• Configure the colors and fonts for your source code, console output, debugger information, search results, and more. You can choose from a number of predefined color schemes or customize a scheme to create a unique working environment.

• Learn how to configure the editor settings, including appearance, font, code formatting, and more.

• Customize menus and toolbars to spare the annoyance of looking for an action among a dozen buttons you never use.

In IntelliJ IDEA, you have shortcuts for nearly every action, including selection and switching between the editor and various tool windows.

Use the most useful shortcuts to invoke frequent actions without switching your focus from the editor and tune your keymap to assign custom shortcuts for your favorite commands.

Watch this video to learn about some of the most useful shortcuts:

Normally, you work with a small subset of files at a time and need to switch between them quickly. The Recent Files action is a real time-saver here. Press Ctrl0E to see a list of last accessed files. Note that you can also use this action to open any tool window:

Apart from jumping to a recent file, you can also get quick access to Recent Locations - that is code snippets you last viewed or edited. Press CtrlShift0E and you'll be able to jump to a particular line you modified lately:

Press CtrlF12 to open the file structure popup that gives you an overview of all elements used in the current file and lets you jump to any of them:

Alternatively, use the Structure tool window Alt07.

If you do not remember the shortcut or the menu path for an action you want to use, press CtrlShift0A and start typing the action name:

IntelliJ IDEA helps you speed up the coding process by providing context-aware code completion.

• Full Line completion suggests entire lines of code using ML models that are downloaded to your computer. Learn more from Full Line code completion.

• Basic completion helps you complete the names of classes, methods, fields, and keywords within the visibility scope:

  

• Type-Matching completion suggests the most relevant symbols applicable in the current context when IntelliJ IDEA can determine the appropriate type:

  

For more information about the different types of code completion available in IntelliJ IDEA with examples and productivity tips, refer to Code completion.

IntelliJ IDEA offers a comprehensive set of automated code refactorings that lead to significant productivity gains. For example, when you rename a class, the IDE will update all references to this class throughout your project.

You do not even need to bother to select anything before you apply a refactoring. IntelliJ IDEA is smart enough to figure out the statement you are going to refactor. It only asks for confirmation if several choices are possible. Press CtrlAltShift0T to open a list of refactorings available in the current context:

For a full list of available refactorings with usage scenarios and the before and after examples, refer to the Refactoring code section.

Learn some of the most useful refactoring shortcuts:

IntelliJ IDEA provides a set of inspections that are built-in static code analysis tools. They help you find potential bugs, locate dead code, detect performance issues, and improve the overall code structure.

Inspections not only tell you where a problem is but also provide quick fixes that help you deal with it right away. Click the red bulb next to the highlighted code or press AltEnter to choose a fix:

Apart from quick-fixes, IntelliJ IDEA also provides intention actions that help you apply automatic changes to code that is correct. For example, you can inject a language, add Java annotations, add Javadoc, convert HTML or XML tags, and much more. To view a full list of intention actions, in the Settings dialog (CtrlAlt0S) , go to Editor | Intentions.

IntelliJ IDEA provides multiple ways to generate common code constructs and recurring elements, which helps you increase productivity by delegating routine tasks to the IDE. This includes generating code from predefined or custom code templates, generating wrappers, getters and setters, automatic pairing of characters, and more. Press AltInsert to open a popup with the available constructs you can generate from your caret position. For more information, refer to Generate code.

IntelliJ IDEA provides a built-in JVM debugger. It lets you get and analyze runtime information, which is useful for diagnosing issues and getting a deeper understanding of how a program operates. It enables you to:

• Suspend the program execution to examine its behavior using breakpoints. Multiple types of breakpoints, together with conditions and filters, allow you to specify the exact moment when an application needs to be paused.

• Play with the program state by modifying variable values, evaluate expressions, and so on.

• Examine variable values, call stacks, thread states, and so on.

• Control the step-by-step execution of the program.

See Tutorial: Debug your first Java application to learn the basics of debugging and play with the debugger features in the IDE.

For CPU and allocation profiling, IntelliJ IDEA provides integration with the following profilers:

• Java Flight Recorder – a standard profiling tool shipped as part of the JDK.

• Async Profiler – a very accurate profiler that can also collect native call and memory allocation data.

By default, IntelliJ IDEA runs both profilers in parallel to provide the most accurate results. While it is possible to use the supported profilers separately, the combined configuration that you get out of the box is a better choice for most scenarios. This approach leverages the advantages of both profilers and abstracts you from any setup whatsoever unless you have very specific requirements.

IntelliJ IDEA includes a built-in terminal for working with a command-line shell from inside the IDE. For example, if you are used to executing Git commands from the command line, you can run them from the Terminal instead of invoking these actions from the menu.

The Terminal runs with your default system shell, but it also supports a number of other shells, such as cmd.exe, bash, sh, and so on.

IntelliJ IDEA comes with a fully functional Gradle and Maven integration that allows you to automate your building process, packaging, running tests, deployment, and other activities.

When you open an existing Gradle or Maven project or create a new one, IntelliJ IDEA detects and automatically downloads all the required repositories and plugins, so you virtually do not need to configure anything and can focus solely on the development process. You can edit build.gradle and pom.xml files directly from the editor and configure the IDE to automatically sync all changes to the build configurations.

For more information about working with Gradle and Maven projects in IntelliJ IDEA, refer to Gradle and Maven.

IntelliJ IDEA provides integration with the most popular version control tools: Git, Mercurial, Perforce, and Subversion.

You can review the history of your entire project or separate files, compare file versions, manage branches, and even process GitHub pull requests without leaving the IDE.

You can quickly access all VCS actions from the VCS operations popup Alt0`:

For more information about configuring integration with your VCS and performing the VCS-related operations, refer to Version control.

Even if no version control is enabled for your project yet, you can still keep track of modifications to your project and restore deleted files or separate changes with Local History. It acts as your personal version control system that automatically records your project's revisions triggered by various events as you edit code, run tests, deploy applications, and so on.

Gif