Migrate from Eclipse to IntelliJ IDEA

No workspace

The first thing you will notice when launching IntelliJ IDEA is that it has no workspace concept. This means that you can work with only one project at a time. While in Eclipse you normally have a set of projects that may depend on each other, in IntelliJ IDEA you have a single project that consists of a set of modules.

If you have several unrelated projects, you can open them in separate windows.

If you still want to have several unrelated projects opened in one window, as a workaround you can configure them as modules.

IntelliJ IDEA vs Eclipse terminology

The table below compares the terms in Eclipse and IntelliJ IDEA:

No perspectives

The second big surprise when you switch to IntelliJ IDEA is that it has no perspectives.

It means that you don't need to switch between different workspace layouts manually to perform different tasks. The IDE follows your context and brings up the relevant tools automatically.

Tool windows

Just like in Eclipse, in IntelliJ IDEA you also have tool windows. You can find a full list of all available tool windows at View | Tool Windows. Selecting a tool window will open it. Tool windows are also accessible from the tool window buttons on the tool window bars.

If you do not want to use the mouse, you can always switch to any toolbar by pressing the shortcut assigned to it. The most important shortcuts to remember are:

• Project: Alt+1

• Commit: Alt+0

• Terminal: Alt+F12

Another thing about tool windows is that you can drag, pin, unpin, attach and detach them:

For more information, refer to Arrange tool windows and Tool window view modes.

To help store/restore the tool windows layout, there are several useful commands:

• Window | Layouts | Save Current Layout as New: save the arrangement as a new layout.

• Window | Layouts | Restore Current Layout: reset changes in your current layout. (also available via Shift+F12)

For more information, refer to Layouts.

Multiple windows

Windows management in IntelliJ IDEA is slightly different from Eclipse. You cannot open several windows with one project, but you can detach any number of editor tabs into separate windows. To move the tab to a separate window, right-click the tab and select Move Tab to New Window (or press Shift+F4).

Always select opened files

By default, IntelliJ IDEA does not navigate to the file in Project tool window when you switch between editor tabs. However, you can enable it in the Project tool window settings:

No 'save' button

IntelliJ IDEA has no Save button. Since in IntelliJ IDEA you can undo refactorings and revert changes from Local History, it makes no sense to ask you to save your changes every time.

Still, it is worth knowing that physical saving to disk is triggered by certain events, including compilation, closing a file, switching focus out of the IDE, and so on. To change the autosave behavior, open settings by pressing Ctrl+Alt+S and navigate to Appearance & Behavior | System Settings. On the System Settings page, find the Autosave section.

Save actions

If you are an experienced Eclipse user, you are familiar with save actions: the actions triggered automatically on save, such as reformatting code, organizing imports, and so on.

IntelliJ IDEA also features save actions that you can find and enable in Settings | Tools | Actions on Save.

Actions on commit

When you commit your changes, you can run various actions automatically. For example, you can automatically run tests, reformat your code, optimize imports, and so on.

Compilation

The way IntelliJ IDEA compiles projects is different from Eclipse in a number of ways.

Eclipse compiler

While Eclipse uses its own compiler, IntelliJ IDEA uses the javac compiler bundled with the project JDK. If you must use the Eclipse compiler, navigate to Settings | Build, Execution, Deployment | Compiler | Java Compiler and select it as shown below:

The biggest difference between the Eclipse and javac compilers is that the Eclipse compiler is more tolerant to errors, and sometimes lets you run code that doesn't compile.

In situations when you need to run code with compilation errors in IntelliJ IDEA, replace the Build option in your run configuration with Build, no error check by editing the run configuration and selecting Modify Options | Add before launch task | Build, no error check:

Eclipse keymap

In Settings | Keymap, you can choose to use the Eclipse keymap which closely mimics Eclipse shortcuts, in case you don't want to learn new shortcuts:

Find action

When you don't know the shortcut for some action, try using the Find action feature available via Ctrl+Shift+A. Start typing to find an action by its name, see its shortcut, or call it:

Quick-fixes

To apply a quick-fix in IntelliJ IDEA, press Alt+Enter:

All quick-fixes are based on inspections configured in Settings/ | Editor | Inspections:

Apart from outright problems, IntelliJ IDEA also recognizes code constructs that can be improved or optimized via the so-called intentions (also available with Alt+Enter):

Code completion

IntelliJ IDEA provides different types of code completion, which include:

• Basic completion

• Second basic completion

• Type-matching completion

• Second type-matching completion

• Statement completion

For more information about the differences between these completion types, refer to the Code Completion blog post.

Templates

You may be used to typing main in the editor and then calling code completion to have it transformed into a main method definition. However, IntelliJ IDEA templates are a little different:

The list of available templates can be found in Settings | Editor | Live Templates. There you can also add your own templates or modify any existing ones.

Postfix templates

In addition to 'regular' templates, IntelliJ IDEA offers the so-called postfix templates. They are useful when you want to apply a template to an expression you've already typed. For instance, type a variable name, add .ifn and press Tab. IntelliJ IDEA will turn your expression into a if (...==null){...} statement.

To see a complete list of available postfix templates, go to Settings | Editor | General | Postfix Completion.

Surround with live template

The surround with templates is another addition that works similarly to live templates but can be applied to the selected code with Ctrl+Alt+J.

To define your own surround with template, go to Settings | Editor | Live Templates and use $SELECTION$ within the template text:

Refactorings

The following table maps the shortcuts for the most common refactorings in Eclipse with those in IntelliJ IDEA:

For more information about many additional refactorings that IntelliJ IDEA offers, refer to Top 20 Refactoring Features in IntelliJ IDEA

Undo

Sometimes, refactorings may affect a lot of files in a project. IntelliJ IDEA not only takes care of applying changes safely, but also lets you revert them. To undo the last refactoring, switch the focus to the Project tool window and press Ctrl+Z.

Search

Below is a map of the most common search actions and shortcuts:

Call hierarchy

Both IntelliJ IDEA and Eclipse provide features that allow you to examine the hierarchy and explore the structure of source files. For example, the Call Hierarchy feature shows you all the callers and callees of the selected method.

In Eclipse, you access it by pressing Ctrl+Alt+H. In IntelliJ IDEA, use the Ctrl+Alt+H shortcut.

Apart from call hierarchies, IntelliJ IDEA can also build method hierarchies (Ctrl+Shift+H) and type hierarchies (Ctrl+H). You can find more information in Source code hierarchy.

Run goals/tasks

Use the Maven or Gradle tool window to run any project goal or task. When you do, IntelliJ IDEA creates the corresponding run configuration, which you can reuse later to run the goal or task quickly.

It's worth mentioning that any goal or task can be attached to a run configuration. This may be useful when your goal or task generates specific files needed by the application.

Both the Maven and Gradle tool windows provide the Run Task action. It runs a Maven or Gradle command similarly to how you'd run it using the console.

Configure artifacts

If you have a WAR artifacts configured in your pom.xml or build.gradle file, IntelliJ IDEA automatically configures the corresponding artifacts in Project Structure | Artifacts.

Note that when you compile your project or build an artifact, IntelliJ IDEA uses its own build process which may be faster but is not guaranteed to be 100% accurate. If you notice inconsistent results when compiling your project with Build in IntelliJ IDEA, try using a Maven goal or a Gradle task instead.

Edit VCS settings

Every VCS may require specific settings, for example, Path to Git executable, GitHub/Perforce credentials, and so on:

Once you've configured the VCS settings, you'll see the Version Control tool window Alt+9.

Checking projects out

To check out a project from a VCS, click Get from Version Control on the Welcome Screen, or in the main VCS menu.

Working with local changes

The Changes view shows your local changes: both staged and unstaged. To simplify managing changes, all changes are organized into changelists. Any changes made to source files are automatically included in the active changelist. You can create new changelists, delete the existing ones (except for the Changes one), and move files between changelists.

Right-click the unversioned file or folder you want to ignore in the Local Changes tab of the Version Control tool window Alt+9 or in Project tool window and select Git | Add to .gitignore or Git | Add to .git/info/exclude.

If you want ignored files to be also displayed in the Local Changes view, click on the toolbar and select Ignored Files.

Working with history

The Log tab of the Git tool window lets you see and search through the history of commits. You can sort and filter commits by the repository, branch, user, date, folder, or even a phrase in the description. You can find a particular commit, or just browse through the history and the branch tree:

Working with branches

IntelliJ IDEA lets you create, switch, merge, compare and delete branches. To access these operations, you can click the Git widget with the name of the branch that is currently checked out:

All VCS operations are available from the VCS main menu: