Migrating From Eclipse to IntelliJ IDEA（eclipse转IDEA全英文必读官方文档）

Overview

　　Switching from Eclipse to IntelliJ IDEA, especially if you've been using Eclipse for a long time, requires understanding some fundamental differences between the two IDEs, including their , , , project configuration and other aspects.

　　User Interface

　　No workspace

　　The first thing you'll 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 all in IntelliJ IDEA as modules.

　　IntelliJ IDEA vs Eclipse terminology

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

　　EclipseIntelliJ IDEA

　　WorkspaceProject

　　ProjectModule

　　FacetFacet

　　LibraryLibrary

　　JRESDK

　　Classpath variablePath variable

　　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. To open a tool window, simply click it in the tool window bar:

　　If the tool window bar is hidden, you can open any tool window by hovering over the corresponding icon in the bottom left corner:

　　If you want to make the tool window bar visible for a moment, you can press Alt (Cmd for macOS) twice and hold it.

　　If you don't 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

　　Version Control: Alt 9

　　Terminal: Alt F12

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

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

　　Window | Store Current Layout as Default

　　Window | Restore Default Layout (also available via Ctrl F12)

　　Multiple windows

　　Windows management in IntelliJ IDEA is slightly different from Eclipse. You can't open several windows with one project, but you can detach any number of editor tabs into separate windows.

　　Auto-scrolling to/from sources

　　By default, IntelliJ IDEA doesn't change the selection in theProject Tool Window when you switch between editor tabs. However, you can enable it in the tool window settings:

Enabling line numbers

　　Line numbers are not shown in the editor by default. To enable them, go to Settings/Preferences | Editor | General | Appearance | Show line numbers. There you will also find other useful settings.

　　General workflows

　　No 'save' button

　　Time for some really shocking news: IntelliJ IDEA has no Save button. Since in IntelliJ IDEA you can undo refactorings and revert changes fromLocal History, it makes no sense to ask you to save your changes every time.

　　Still, it's worth knowing that physical saving to disk is triggered by certain events, including compilation, closing a file, switching focus out of the IDE, etc. You can change this behavior via Settings | Appearance & Behavior | System Settings:

No save actions

　　One of the features you may miss in IntelliJ IDEA as an Eclipse user is save actions, i.e. the actions triggered automatically on save, such as reformatting code, organizing imports, adding missing annotations and the final modifier, etc. Instead, IntelliJ IDEA offers you to run the corresponding actions automatically on commit:

　　Or manually:

　　Code | Reformat Code (Ctrl Alt L)

　　Code | Optimize Imports (Ctrl Alt O)

　　Analyze | Code Cleanup

　　If, for some reason, you can't live without an Eclipse save action, you can install aplugin that imitates Eclipse save actions.

　　Compilation

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

　　Auto-compilation

　　By default, IntelliJ IDEA doesn't automatically compile projects on saving because normally we don't invoke the save action explicitly in IntelliJ IDEA.

　　If you want to mimic the Eclipse behavior, you can invoke the Make Project action (Ctrl F9) - it will save the changed files and compile them. For your convenience, you can even reassign the Ctrl S shortcut to the Make Project action.

　　To enable automatic compilation, navigate to Settings/Preferences | Build, Execution, Deployment | Compiler and select the Make project automatically option:

　　Note that automatic compilation in IntelliJ IDEA differs from that in Eclipse. In Eclipse it's not fully automatic, as it is triggered by the save action invoked by the user explicitly, whereas in IntelliJ IDEA it is invoked implicitly when you type in the editor.

　　This is why, even if the Make project automatically option is enabled, IntelliJ IDEA doesn't perform automatic compilation if at least one application is running: it will reload classes in the application implicitly. In this case you can call Build | Make Project (Ctrl F9).

　　Problems tool window

　　TheProblems tool window appears if the Make project automatically option is enabled in theCompiler settings. It shows a list of problems that were detected on project compilation:

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/Preferences | 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 Make option in yourrun configuration with Make, no error check:

Shortcuts

　　IntelliJ IDEA shortcuts are completely different from those in Eclipse.

　　If you choose a keymap specific to your operating system (Default for Windows/Linux or macOS 10.5 for macOS), there may be conflicts between shortcuts used in IntelliJ IDEA and your OS. To avoid such conflicts, we recommend tweaking your OS shortcut settings (refer toKeymap for more details).

　　The table below shows how the top Eclipse actions (and their shortcuts) are mapped to IntelliJ IDEA (you may want to print it out to always have it handy).

　　EclipseIntelliJ IDEA

　　Action Shortcut Action Shortcut

　　Code completion Ctrl Space Basic completion Ctrl Space

　　-- Smart completion Ctrl Shift Space

　　-- Statement completion Ctrl Shift Enter

　　Quick access Ctrl 3 Search everywhere Shift x 2

　　Maximize active view or editor Ctrl M Hide all tool windows Ctrl Shift F12

　　Open type Ctrl Shift T Navigate to class Ctrl N

　　Open resource Ctrl Shift R Navigate to file Ctrl Shift N

　　-- Navigate to symbol Ctrl Shift Alt N

　　Next view Ctrl F7 --

　　-- Recent files Ctrl E

　　-- Switcher Ctrl Tab

　　Quick outline Ctrl O File structure Ctrl F12

　　Move lines Alt Up/Down Move lines Shift Alt Up/Shift Alt Down

　　Delete lines Ctrl D Delete lines Ctrl Y

　　Quick fix Ctrl 1 Show intention action Alt Enter

　　Quick switch editor Ctrl E Switcher Ctrl Tab

　　-- Recent files Ctrl E

　　Quick hierarchy Ctrl T Navigate to type hierarchy Ctrl H

　　-- Navigate to method hierarchy Ctrl Shift H

　　-- Show UML popup Ctrl Alt U

　　Last edit location Ctrl Q Last edit location Ctrl Shift Backspace

　　Next editor Ctrl F6 Select next tab Alt Right

　　Run Ctrl Shift F11 Run Shift F10

　　Debug Ctrl F11 Debug Shift F9

　　Correct indentation Ctrl I Auto-indent lines Ctrl Alt I

　　Format Ctrl Shift F Reformat code Ctrl Alt L

　　Surround with Ctrl Alt Z Surround with Ctrl Alt T

　　-- Surround with live template Ctrl Alt J

　　Open declaration F3 Navigate to declaration Ctrl B

　　-- Quick definition Ctrl Shift I

　　Open type hierarchy F4 Navigate to type hierarchy Ctrl H

　　-- Show UML popup Ctrl Alt U

　　References in workspace Ctrl Shift G Find usages Alt F7

　　-- Show usages Ctrl Alt F7

　　-- Find usages settings Ctrl Shift Alt F7

　　Open search dialog Ctrl H Find in path Ctrl Shift F

　　Occurrences in file Ctrl Alt U Highlight usages in file Ctrl Shift F7

　　Copy lines Ctrl Alt Down Duplicate lines Ctrl D

　　Extract local variable Ctrl Alt L Extract variable Ctrl Alt V

　　Assign to field Ctrl 2/Ctrl F Extract field Ctrl Alt F

　　Show refactor quick menu Ctrl Alt T Refactor this Ctrl Shift Alt T

　　Rename Ctrl Alt R Rename Shift F6

　　Go to line Ctrl L Navigate to line Ctrl G

　　Structured selection Shift Alt Up/Shift Alt Down Select word at caret Ctrl W/Ctrl Shift W

　　Find next Ctrl J Find next F3

　　Show in Ctrl Alt W Select in Alt F1

　　Back Ctrl [ Back Ctrl Alt Left

　　Forward Ctrl ] Forward Ctrl Alt Right

　　Eclipse keymap

　　For Eclipse users who prefer not to learn new shortcuts, IntelliJ IDEA provides the Eclipse keymap which closely mimics its 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:

Coding assistance

　　Both Eclipse and IntelliJ IDEA provide coding assistance features, such as code completion, code generation, quick-fixes, live templates, etc.

　　Quick-fixes

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

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

　　If you want to apply a quick-fix to several places at once (i.e. to a whole folder, module or even a project), you can do it by running the corresponding inspection via Analyze | Run Inspection By Name or by running the whole batch of inspections via Analyze | Inspect Code:

　　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):

EclipseIntelliJ IDEA

　　ActionShortcutActionShortcut

　　Quick fixCtrl 1Show intention actionAlt Enter

　　Generating code

　　The key action for generating code is Code | Generate, available via Alt Insert:

　　This action is context-sensitive and is available not only within the editor, but also in theProject Tool Window and theNavigation bar:

Code completion

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

　　Basic completion

　　Second basic completion

　　Smart completion

　　Second smart completion

　　Statement completion

　　To learn more about the differences between these completion types, refer toTop 20 Features of Code Completion in IntelliJ IDEA.

　　By default, IntelliJ IDEA doesn't show the Documentation popup for the selected item, but you can enable it in Settings/Preferences | Editor | Code Completion | Autopopup documentatoin in (ms):

　　If you don't want to enable this option, you can manually invoke this popup by pressing Ctrl Q when you need it:

　　When the caret is within the brackets of a method or a constructor, you can get the info about the parameters by calling Parameter Info with Ctrl P:

EclipseIntelliJ IDEA

　　ActionShortcutActionShortcut

　　Code completionCtrl SpaceBasic completionCtrl Space

　　--Smart completionCtrl Shift Space

　　--Statement completionCtrl Shift Enter

　　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:

　　TemplateEclipseIntelliJ IDEA

　　Define a main methodmainpsvm

　　Iterate over an arrayforitar

　　Iterate over a collectionforitco

　　Iterate over a listforitli

　　Iterate over an iterable using foreach syntaxforeachiter

　　Print to System.outsysoutsout

　　Print to System.errsyserrserr

　　Define a static fieldstatic_finalpsf

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

　　While IntelliJ IDEA suggests templates in code completion results, you can quckly expand any template without using code completion simply by pressing Tab.

　　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/Preferences | 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/Preferences | Editor | General | Live Templates and use $SELECTION$ within the template text:

　　$LOCK$.readLock().lock();try { $SELECTION$ } finally { $LOCK$.readLock().unlock();}

　　Navigation

　　The table below roughly maps the navigation actions available in Eclipse with those in IntelliJ IDEA:

　　EclipseIntelliJ IDEA

　　ActionShortcutActionShortcut

　　Quick accessCtrl 3Search everywhereShift x 2

　　Open typeCtrl Shift TNavigate to classCtrl N

　　Open resourceCtrl Shift RNavigate to fileCtrl Shift N

　　--Navigate to symbolCtrl Shift Alt N

　　Quick switch editorCtrl ESwitcherCtrl Tab

　　--Recent filesCtrl E

　　Open declarationF3Navigate to declarationCtrl B

　　Open type hierarchyF4Navigate to type hierarchyCtrl H

　　--Show UML popupCtrl Alt U

　　Quick outlineCtrl OFile structureCtrl F12

　　BackCtrl [BackCtrl Alt Left

　　ForwardCtrl ]ForwardCtrl Alt Right

　　Later, when you get used to these navigation options and need more, refer toTop 20 Navigation Features in IntelliJ IDEA.

　　Refactorings

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

　　EclipseIntelliJ IDEA

　　ActionShortcutActionShortcut

　　Extract local variableCtrl Alt LExtract variableCtrl Alt V

　　Assign to fieldCtrl 2Extract fieldCtrl Alt F

　　Show refactor quick menuCtrl Alt TRafactor thisCtrl Shift Alt T

　　RenameCtrl Alt RRenameShift F6

　　To learn more about many additional refactorings that IntelliJ IDEA offers, refer toTop 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 theProject Tool Window and press Ctrl Z.

　　Search

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

　　EclipseIntelliJ IDEA

　　ActionShortcutActionShortcut

　　Open search dialogCtrl HFind in pathCtrl Shift F

　　References in workspaceCtrl Shift GFind usagesAlt F7

　　--Show usagesCtrl Alt F7

　　--Find usages settingsCtrl Shift Alt F7

　　Occurrences in fileCtrl Alt UHighlight usages in fileCtrl F7

　　Code formatting

　　IntelliJ IDEA code formatting rules (available via Settings/Preferences | Editor | Code Style) are similar to those in Eclipse, with some minor differences. You may want to take note of the fact that the Using the Tab char option is disabled by default, the Indent size may be different, etc.

　　Note that if the Eclipse formatter settings cannot be imported, the following error message shows up:

　　The input file is not a valid Eclipse XML profile.

　　

　　If you would like to import your Eclipse formatter settings, go to Settings/Preferences | Editor | Code Style | Java, click Manage, click Import and select the exported Eclipse formatter settings (an XML file).

　　Note that there may be some discrepancies between the code style settings in IntelliJ IDEA and Eclipse. For example, you cannot tell IntelliJ IDEA to put space after (but not before). If you want IntelliJ IDEA to use the Eclipse formatter, consider installing theEclipse code formatter plugin.

　　EclipseIntelliJ IDEA

　　ActionShortcutActionShortcut

　　FormatCtrl Shift FReformat codeCtrl Alt L

　　Running and reloading changes

　　Similarly to Eclipse, IntelliJ IDEA also hasRun/Debug Configurations that you can access either form the main toolbar, or the main menu. Compare the related shorcuts:

　　EclipseIntelliJ IDEA

　　ActionShortcutActionShortcut

　　RunCtrl Shift F11RunShift F10

　　DebugCtrl F11DebugShift F9

　　--MakeCtrl F9

　　--Update applicationCtrl F10

　　As mentioned before, by default IntelliJ IDEA doesn't compile changed files automatically (unless you configure it to do so). That means the IDE doesn't reload changes automatically. To reload changed classes, call the Make action explicitly via Ctrl F9. If your application is running on a server, in addition to reloading you can use the Update application action via Ctrl F10:

Debugging

　　The debuggers in Eclipse and IntelliJ IDEA are similar but use different shortcuts:

　　EclipseIntelliJ IDEA

　　ActionShortcutActionShortcut

　　Step intoF5Step intoF7

　　--Smart step intoShift F7

　　Step overF6Step overF8

　　Step outF7Step outShift F8

　　ResumeF8ResumeF9

　　Toggle breakpointCtrl Shift BToggle breakpointCtrl F8

　　--Evaluate expressionAlt F8

　　Working with Application Servers (Tomcat/TomEE, JBoss EAP, Glassfish, WebLogic, WebSphere)

　　This feature is supported in the Ultimate edition only.

　　Deploying to application servers in IntelliJ IDEA is more or less similar to what you are probably used to in Eclipse. To deploy your application to a server:

　　Configure yourartifacts via Project Structure | Artifacts (done automatically for Maven and Gradle projects).

　　Configure an application server via Settings | Application Servers.

　　Create arun configuration, and then specify the artifacts to deploy and the server to deploy to.

　　You can always tell the IDE to build/rebuild your artifacts once the have been configured via Build | Build Artifacts.

　　Working with Build Tools (Maven/Gradle)

　　IntelliJ IDEA doesn't provide visual forms for editing Maven/Gradle configuration files. Once you've imported/created your Maven/Gradle project, you are free to edit its pom.xml/build.gradle files directly in the editor. Later, you can tell IntelliJ IDEA tosynchronize the project model with the changed files on demand, orautomatically import changes to the new build files. Any changes to the underlying build configuration will eventually need to be synced with the project model in IntelliJ IDEA.

　　For operations specific to Maven/Gradle, IntelliJ IDEA provides theMaven Project tool window and theGradle tool window. Apart from your project structure, these tool windows provide a list of goals/tasks plus a toolbar with the relevant actions.

　　If you want the IDE to synchronize your changes immediately:

　　For pom.xml, enable the corresponding options in Settings | Build, Execution, Deployment | Build Tools | Maven | Importing | Import Maven projects automatically

　　For build.gradle, enable the corresponding option in Settings | Build, Execution, Deployment | Build Tools | Gradle | Use auto-import.

　　For manual synchronization, use the corresponding action on the Maven/Gradle tool window toolbar:

.

　　Running goals/tasks

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

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

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

　　Configuring artifacts

　　If you have WAR artifacts configured in your pom.xml/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 Make in IntelliJ IDEA, try using a Maven goal or a Gradle task instead.

　　Working with VCS (Git, Mercurial, Subversion, Perforce)

　　Configuring VCS roots

　　When you open a project located under a VCS root, IntelliJ IDEA automatically detects it and suggests adding this root to the project settings. To change version control-related project settings (or manually add a VCS root), go to Settings | Version Control:

　　IntelliJ IDEA works perfectly with multi-repository projects. Just map your project directories to VCS, and the IDE will take care of the rest. ForGit andMercurial, the IDE will even offer you synchronized branch control, so that you can perform branch operations on multiple repositories simultaneously (for more details, seeGit Branches in Multirooted Projects).

　　Editing VCS settings

　　Every VCS may require specific settings, for example, Path to Git executable, GitHub/Perforce credentials, etc.:

　　Once you've configured the VCS settings, you'll see theVersion Control tool window. You can invoke it any time by pressing Alt 9.

　　Checking projects out

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

　　Working with local changes

　　TheLocal Changes tab of theVersion Control tool window 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 into the active changelist. You can create new changelists, delete the existing ones (except for the Default changelist), and move files between changelists.

　　To configure ignored files, go to Settings | Version Control, or use the corresponding button in the Version Control tool window.

Working with history

　　TheLog tab of theVersion Control 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. For these operations, either use Branches from the main or context VCS menu, or the VCS operations popup (you can invoke it by pressing Alt Back Quote, or the widget on the right of the status bar:

　　All VCS operations are available from the VCS main menu:

　　ActionShortcut

　　Version Control tool window Alt 9

　　VCS operations popup Alt Back Quote

　　Commit changes Ctrl K

　　Update project Ctrl T

　　Push commits Ctrl Shift K

　　Importing an Eclipse project to IntelliJ IDEA

　　Despite these differences in terms and the UI, you can import either an Eclipse workspace or a single Eclipse project. To do this, click Import Project on the Welcome Screen, or select File | New | Project from Existing Sources in the main menu.

　　If your project uses a build tool such asMaven orGradle, we recommend choosing the corresponding option when prompted in theImport Project wizard, and selecting the associated build file (pom.xml or build.gradle):

　　If you'd like to import your existing run configurations from Eclipse, consider using thisthird-party plugin.

　　Last modified: 30 August 2017

　　Exporting an IntelliJ IDEA Project to Eclipse

　　See Also

　　How tos:

　　Exporting an IntelliJ IDEA Project to Eclipse

　　Discover IntelliJ IDEA