[java] Things possible in IntelliJ that aren't possible in Eclipse?

I have heard from people who have switched either way and who swear by the one or the other.

Being a huge Eclipse fan but having not had the time to try out IntelliJ, I am interested in hearing from IntelliJ users who are "ex-Eclipsians" some specific things that you can do with IntelliJ that you can not do with Eclipse.

Note: This is not a subjective question nor at all meant to turn into an IDE holy war. Please downvote any flamebait answers.

Idea 8.0 has the lovely ctrl+shift+space x 2 that does the following autocomplete:

 City city = customer.<ctrl-shift-space twice>

resolves to

 City city = customer.getAddress().getCity();

through any number of levels of getters/setters.

Don't forget "compare with clipboard".

Something that I use all the time in IntelliJ and which has no equivalent in Eclipse.

My favorite shortcut in IntelliJ that has no equivalent in Eclipse (that I've found) is called 'Go to symbol'. CTRL-ALT-SHIFT-N lets you start typing and glob up classes, method names, variable names, etc, from the entire project.

Structural search and replace.

For example, search for something like:

  System.out.println($string$ + $expr$);

Where $string$ is a literal, and $expr$ is an expression of type my.package.and.Class, and then replace with:

  $expr$.inspect($string$);

The IntelliJ debugger has a very handy feature called "Evaluate Expression", that is by far better than eclipses pendant. It has full code-completion and i concider it to be generally "more useful".

If you have the cursor on a method then CTRL+SHIFT+I will popup the method implementation. If the method is an interface method, then you can use up- and down- arrows to cycle through the implementations:

Map<String, Integer> m = ...
m.contains|Key("Wibble");

Where | is (for example) where your cursor is.

IntelliJ has some pretty advanced code inspections (comparable but different to FindBugs).

Although I seriously miss a FindBugs plugin when using IntelliJ (The Eclipse/FindBugs integration is pretty cool).

Here is an official list of CodeInspections supported by IntelliJ

EDIT: Finally, there is a findbugs-plugin for IntelliJ. It is still a bit beta but the combination of Code Inspections and FindBugs is just awesome!

Idea 8.0 has the lovely ctrl+shift+space x 2 that does the following autocomplete:

 City city = customer.<ctrl-shift-space twice>

resolves to

 City city = customer.getAddress().getCity();

through any number of levels of getters/setters.

Alt+Insert to edit text in Column Mode.

There is one thing that IntelliJ does much much better than Eclipse and that is empty your pockets!

I do however prefer using it and one big advantage it has over Eclipce is the way it synchronises with the file system, for big projects and slow computers (yes in work environments the PC's are a lot slower than our ones at home) Eclipse seems to struggle where IntelliJ seems to be quicker albeit with a slower initial indexing time.

IntelliJ Community edition obviously makes using it free but you soon want those extra refactoring and nice little goodies not included in the CC edition.

In my opinion, its generally a better user experience but whether its worth the cost is a question for each developer to answer themselves.

But lets be grateful we have up to three great IDEs for Java right now with NetBeans getting better all the time.

I tried to switch to IntelliJ because of the new Android Studio. But I'm very disappointed now. I'm using Eclipse with the Code Recommanders Plugin. Here is a simple example why Eclipse is so awesome:

I want to create a new SimpleTimeZone. SimpleTimeZone has no Constructor with zero arguments.

Ctrl + Space in Eclipse

Ctrl + Space in IntelliJ

In IntelliJ I get no informations what kind of constructors SimpleTimeZone has.

After Enter in Eclipse

I get the previously selected constructor filled with predefined variable names. And I can see the type of every argument. With Code Recommanders Eclipse guesses the right constructor by the previously defined variable types in the current scope and fills the constructor with these vars.

After Enter in IntelliJ nothing happens. I get an empty constructor. I have to press Ctrl + P to see the expected arguments.

I don't remember if word/line/method/class wrap is possible in Eclipse

In Intellij Idea you use Ctrl+W

VIM Emulator. This plugin provides nearly complete vi/vim/gvim emulation while editing files in IDEA. The following functionality is supported:

• Motion keys
• Deletion/Changing
• Insert mode commands
• Marks
• Registers
• VIM undo/redo
• Visual mode commands
• Some Ex commands
• Some :set options
• Full VIM regular expressions for search and search/replace
• Macros
• Diagraphs
• Command line history
• Search history
• Jumplists
• VIM help

some comments about this plugin from http://plugins.jetbrains.net/plugin/?id=164

My timing may be a little off in terms of this thread, but I just had to respond.

I am a huge eclipse fan -- using it since it's first appearance. A friend told me then (10+ years ago) that it would be a player. He was right.

However! I have just started using IntelliJ and if you haven't seen or used changelists -- you are missing out on programming heaven.

The ability to track my changed files (on my development branch ala clearcase) was something I was looking for in a plugin for eclipse. Intellij tracks all of your changes for a single commit, extremely easy. You can isolate changed files with custom lists. I use that for configuration files that must be unique locally, but are constantly flagged when I sync or compare against the repository -- listing them under a changelist, I can monitor them, but neatly tuck them away so I can focus on the real additions I am making.

Also, there's a Commit Log plugin that outputs a text of all changes for those SCCS that aren't integrated with your bug tracking software. Pasting the log into a ticket's work history captures the files, their version, date/time, and the branch/tags. It's cool as hell.

All of this could be supported via plugins (or future enhancements) in eclipse, I wager; yet, Intellij makes this a breeze.

Finally, I am really excited about the mainstream love for this product -- the keystrokes, so it's painful, but fun.

Well, for me it's a thousand tiny things. Some of the macros, the GUI layout in general in Eclipse I find awful. I can't open multiple projects in different windows in Eclipse. I can open multiple projects, but then it's view based system swaps a bunch of things around on me when I switch files. IntelliJ's code inspections seem better. Its popup helpers to fix common issues is nice. Lots of simple usability things like the side bar where I can hover over a hot spot and it'll tell me every implementing subclass of a method or the method I'm implementing and from where.

Whenever I've had to use, or watch someone use, Eclipse it seems like they can do most of the things I can do in IntelliJ, but it takes them longer and it's clunkier.

IntelliJ has intellisense and refactoring support from code into jspx documents.

There are many things that idea solves in a much simpler way, or there's no equivalent:

• Autocomplete actions: Doing ctrl+shift+a you can call any idea action from the keyboard without remembering its key combination... Think about gnome-do or launchy in windows, and you've got the idea! Also, this feature supports CamelCasing abbreviations ;)

• Shelf: Lets you keep easily some pieces of code apart, and then review them through the diff viewer.

• Local history: It's far better managed, and simpler.

• SVN annotations and history: simpler to inspect, and also you can easily see the history only for such a part of a whole source file.

• Autocomplete everywhere, such as the evaluate expression and breakpoint condition windows.

• Maven integration... much, much simpler, and well integrated.

• Refactors much closer to the hand, such as loops insertion, wrapping/casting, renaming, and add variables.

• Find much powerful and well organized. Even in big projects

• Much stable to work with several branches of a big project at the same time (as a former bugfixer of 1.5Gb by branch sources, and the need to working in them simultaneously, idea shown its rock-solid capabilities)

• Cleaner and simpler interface...

• And, simpler to use only with the keyboard, letting apart the need of using the mouse for lots of simple taks, saving you time and giving you more focus on the code... where it matters!

And now, being opensource... the Idea user base will grow exponentially.

There are a number of features and workflows that are different in the two, as is evident in all the answers. However, I think that in deciding what framework to use one much also consider the general productivity improvement one can make with each tool.

I am a big fan of Netbeans and Eclipse and have used both for many years. They are excellent tools and depending on what you are doing, you may want to choose one or the other.

However, about six months ago, while working on a complex java web project involving a lot of javascript front end code for a HMT5 ui, I was forced to look for alternatives to Eclipse due to a js autocomplete bug. I was so desperate that I was considering going back to a simple text editor for my js code!!!

It is only by luck that I ran across Intellij Idea (no time to research tools unfortunately).

While it takes some time to get used to the Idea way of doing things, special features aside, the productivity increase it offers from small things left and right is the biggest asset in my opinion. It simply works better for me and I am now a subscription-paying client of Idea Ultimate. Once you get used to this, its is very difficult to go back to anything else.

Nothing beats free and I am a big fan of open source, but in the end if you are doing this for a living, being able to do things faster pays out every time.

First of all I love intellij. There are at least a hundred features it has that eclipse lack. I'm talking magnitudes better in reliability and intelligence that no hyperbole can describe when it comes to refactoring, renaming, moving and others which have already been mentioned.

BUT, there is one thing that intellij does not allow which eclipse does. It does not allow running multiple projects at once under the same vm.

When you have separate projects for the front, middle, core, agents..etc, where they all have to interact with each other, you can not quickly modify and debug at the same time, afaik. The only way I current cope with this is to use ant scripts to deploy and update jars in dependent projects, or use maven.

Eclipse allows multiple projects to be debugged under one ide vm instance.

A few other things:

• propagate parameters/exceptions when changing method signature, very handy for updating methods deep inside the call stack
• SQL code validation in the strings passed as arguments to jdbc calls (and the whole newly bundled language injection stuff)
• implemented in/overwritten in icons for interfaces & classes (and their methods) and the smart implementation navigation (Ctrl+Alt+Click or Ctrl+Alt+B)
• linking between the EJB 2.1 interfaces and bean classes (including refactoring support); old one, but still immensely valuable when working on older projects

For me, it's IDEA's maven support, especially in version 9 is second to none. The on-the-fly synchronizing of the project to the maven model is just fantastic and makes development pleasant.

One very useful feature is the ability to partially build a Maven reactor project so that only the parts you need are included.

To make this a little clearer, consider the case of a collection of WAR files with a lot of common resources (e.g. JavaScript, Spring config files etc) being shared between them using the overlay technique. If you are working on some web page (running in Jetty) and want to change some of the overlay code that is held in a separate module then you'd normally expect to have to stop Jetty, run the Maven build, start Jetty again and continue. This is the case with Eclipse and just about every other IDE I've worked with. Not so in IntelliJ. Using the project settings you can define which facet of which module you would like to be included in a background build. Consequently you end up with a process that appears seamless. You make a change to pretty much any code in the project and instantly it is available after you refresh the browser.

Very neat, and very fast.

I couldn't imagine coding a front end in something like YUI backing onto DWR/SpringMVC without it.

One thing I use regularly is setting a breakpoint, but then controlling what it does. (At my last job, most everyone else used Eclipse... I remember being surprised that no one could find how to do this in Eclipse.)

For example, can have the breakpoint not actually stop, but just log a message to the console. Which means, I don't have to litter my code with "System.out.println(...)" and then recompile.

A few other things:

• propagate parameters/exceptions when changing method signature, very handy for updating methods deep inside the call stack
• SQL code validation in the strings passed as arguments to jdbc calls (and the whole newly bundled language injection stuff)
• implemented in/overwritten in icons for interfaces & classes (and their methods) and the smart implementation navigation (Ctrl+Alt+Click or Ctrl+Alt+B)
• linking between the EJB 2.1 interfaces and bean classes (including refactoring support); old one, but still immensely valuable when working on older projects

The IntelliJ debugger has a very handy feature called "Evaluate Expression", that is by far better than eclipses pendant. It has full code-completion and i concider it to be generally "more useful".

A few other things:

• propagate parameters/exceptions when changing method signature, very handy for updating methods deep inside the call stack
• SQL code validation in the strings passed as arguments to jdbc calls (and the whole newly bundled language injection stuff)
• implemented in/overwritten in icons for interfaces & classes (and their methods) and the smart implementation navigation (Ctrl+Alt+Click or Ctrl+Alt+B)
• linking between the EJB 2.1 interfaces and bean classes (including refactoring support); old one, but still immensely valuable when working on older projects

There are a number of features and workflows that are different in the two, as is evident in all the answers. However, I think that in deciding what framework to use one much also consider the general productivity improvement one can make with each tool.

I am a big fan of Netbeans and Eclipse and have used both for many years. They are excellent tools and depending on what you are doing, you may want to choose one or the other.

However, about six months ago, while working on a complex java web project involving a lot of javascript front end code for a HMT5 ui, I was forced to look for alternatives to Eclipse due to a js autocomplete bug. I was so desperate that I was considering going back to a simple text editor for my js code!!!

It is only by luck that I ran across Intellij Idea (no time to research tools unfortunately).

While it takes some time to get used to the Idea way of doing things, special features aside, the productivity increase it offers from small things left and right is the biggest asset in my opinion. It simply works better for me and I am now a subscription-paying client of Idea Ultimate. Once you get used to this, its is very difficult to go back to anything else.

Nothing beats free and I am a big fan of open source, but in the end if you are doing this for a living, being able to do things faster pays out every time.

One thing I use regularly is setting a breakpoint, but then controlling what it does. (At my last job, most everyone else used Eclipse... I remember being surprised that no one could find how to do this in Eclipse.)

For example, can have the breakpoint not actually stop, but just log a message to the console. Which means, I don't have to litter my code with "System.out.println(...)" and then recompile.

Show Navigation Bar ALT-Home.

One of the good points in my opinion is the Dependency Structure Matrix: http://www.jetbrains.com/idea/features/dependency_analysis.html#link0

There's a good introduction to DSM usage and benefits in Lattix' website (a standalone product): http://www.lattix.com/files/dl/slides/s.php?directory=4tour

IntelliJ has some pretty advanced code inspections (comparable but different to FindBugs).

Although I seriously miss a FindBugs plugin when using IntelliJ (The Eclipse/FindBugs integration is pretty cool).

Here is an official list of CodeInspections supported by IntelliJ

EDIT: Finally, there is a findbugs-plugin for IntelliJ. It is still a bit beta but the combination of Code Inspections and FindBugs is just awesome!

At current, it is the only one that can have tabs torn out into another window. Handy when you have more screens.

If you have the cursor on a method then CTRL+SHIFT+I will popup the method implementation. If the method is an interface method, then you can use up- and down- arrows to cycle through the implementations:

Map<String, Integer> m = ...
m.contains|Key("Wibble");

Where | is (for example) where your cursor is.

I don't remember if word/line/method/class wrap is possible in Eclipse

In Intellij Idea you use Ctrl+W

First of all I love intellij. There are at least a hundred features it has that eclipse lack. I'm talking magnitudes better in reliability and intelligence that no hyperbole can describe when it comes to refactoring, renaming, moving and others which have already been mentioned.

BUT, there is one thing that intellij does not allow which eclipse does. It does not allow running multiple projects at once under the same vm.

When you have separate projects for the front, middle, core, agents..etc, where they all have to interact with each other, you can not quickly modify and debug at the same time, afaik. The only way I current cope with this is to use ant scripts to deploy and update jars in dependent projects, or use maven.

Eclipse allows multiple projects to be debugged under one ide vm instance.

Structural search and replace.

For example, search for something like:

  System.out.println($string$ + $expr$);

Where $string$ is a literal, and $expr$ is an expression of type my.package.and.Class, and then replace with:

  $expr$.inspect($string$);

Probably is not a matter of what can/can't be done, but how.

For instance both have editor surrounded with dock panels for project, classpath, output, structure etc. But in Idea when I start to type all these collapse automatically let me focus on the code it self; In eclipse all these panels keep open leaving my editor area very reduced, about 1/5 of the total viewable area. So I have to grab the mouse and click to minimize in those panels. Doing this all day long is a very frustrating experience in eclipse.

The exact opposite thing happens with the view output window. In Idea running a program brings the output window/panel to see the output of the program even if it was perviously minimized. In eclipse I have to grab my mouse again and look for the output tab and click it to view my program output, because the output window/panel is just another one, like all the rest of the windows, but in Idea it is treated in a special way: "If the user want to run his program, is very likely he wants to see the output of that program!" It seems so natural when I write it, but eclipse fails in this basic user interface concept.

Probably there's a shortcut for this in eclipse ( autohide output window while editing and autoshow it when running the program ) , but as some other tens of features the shortcut must be hunted in forums, online help etc while in Idea is a little bit more "natural".

This can be repeated for almost all the features both have, autocomplete, word wrap, quick documentation view, everything. I think the user experience is far more pleasant in Idea than in eclipse. Then the motto comes true "Develop with pleasure"

Eclipse handles faster larger projects ( +300 jars and +4000 classes ) and I think IntelliJ Idea 8 is working on this.

All this of course is subjective. How can we measure user experience?

Introduce variable. (Ctrl+Alt+V on Windows, Cmd+Alt+V on OSX)

Lets say you call a method, service.listAllPersons() Hit Ctrl+Alt+V and Enter, and variable for return value from method call is inserted:

List<Person> list = service.listAllPersons();

Saves you typing, and you don't have to check the return type of the method you are calling. Especially useful when using generics, e.g.

new ArrayList<String>()

[introduce variable]

ArrayList<String> stringArrayList = new ArrayList<String>();

(of course you can easily change the name of the variable before hitting Enter)

IntelliJ has intellisense and refactoring support from code into jspx documents.

There are many things that idea solves in a much simpler way, or there's no equivalent:

• Autocomplete actions: Doing ctrl+shift+a you can call any idea action from the keyboard without remembering its key combination... Think about gnome-do or launchy in windows, and you've got the idea! Also, this feature supports CamelCasing abbreviations ;)

• Shelf: Lets you keep easily some pieces of code apart, and then review them through the diff viewer.

• Local history: It's far better managed, and simpler.

• SVN annotations and history: simpler to inspect, and also you can easily see the history only for such a part of a whole source file.

• Autocomplete everywhere, such as the evaluate expression and breakpoint condition windows.

• Maven integration... much, much simpler, and well integrated.

• Refactors much closer to the hand, such as loops insertion, wrapping/casting, renaming, and add variables.

• Find much powerful and well organized. Even in big projects

• Much stable to work with several branches of a big project at the same time (as a former bugfixer of 1.5Gb by branch sources, and the need to working in them simultaneously, idea shown its rock-solid capabilities)

• Cleaner and simpler interface...

• And, simpler to use only with the keyboard, letting apart the need of using the mouse for lots of simple taks, saving you time and giving you more focus on the code... where it matters!

And now, being opensource... the Idea user base will grow exponentially.

One thing I use regularly is setting a breakpoint, but then controlling what it does. (At my last job, most everyone else used Eclipse... I remember being surprised that no one could find how to do this in Eclipse.)

For example, can have the breakpoint not actually stop, but just log a message to the console. Which means, I don't have to litter my code with "System.out.println(...)" and then recompile.

Structural search and replace.

For example, search for something like:

  System.out.println($string$ + $expr$);

Where $string$ is a literal, and $expr$ is an expression of type my.package.and.Class, and then replace with:

  $expr$.inspect($string$);

A few other things:

• propagate parameters/exceptions when changing method signature, very handy for updating methods deep inside the call stack
• SQL code validation in the strings passed as arguments to jdbc calls (and the whole newly bundled language injection stuff)
• implemented in/overwritten in icons for interfaces & classes (and their methods) and the smart implementation navigation (Ctrl+Alt+Click or Ctrl+Alt+B)
• linking between the EJB 2.1 interfaces and bean classes (including refactoring support); old one, but still immensely valuable when working on older projects

The IntelliJ debugger has a very handy feature called "Evaluate Expression", that is by far better than eclipses pendant. It has full code-completion and i concider it to be generally "more useful".

I have discovered recently at least two advanteges of IntelliJ IDEA over Eclipse.

If one tries to use code formating in the JSP code editor the JSP scriptlets get broken. Eclipse is getting a little bit crazy, it ads random pieces of code here and there. IDEA behaves very nicely.

The other thing is speed of deployment of the application on the JBoss Server. IntelliJ is replacing the application in the JBoss's tmp folder, so the redeployment is really fast. Eclipse WTP is replacing application in the deploy folder, which, as it turns out, lasts much longer.

Something which I use in IntelliJ all the time is refactoring as I type. I have re-written classes from a printout (originally written in eclipse) using both IDEs and I used about 40% less key strokes/mouse clicks to write the same classes in IntelliJ than eclipse.

I wouldn't want to use Eclipse until they support as much refactoring with incomplete pieces of code.

Here is a longer list of features in IntelliJ 8.0/8.1 [http://www.jetbrains.com/idea/features/index.html]

Show Navigation Bar ALT-Home.

Probably is not a matter of what can/can't be done, but how.

For instance both have editor surrounded with dock panels for project, classpath, output, structure etc. But in Idea when I start to type all these collapse automatically let me focus on the code it self; In eclipse all these panels keep open leaving my editor area very reduced, about 1/5 of the total viewable area. So I have to grab the mouse and click to minimize in those panels. Doing this all day long is a very frustrating experience in eclipse.

The exact opposite thing happens with the view output window. In Idea running a program brings the output window/panel to see the output of the program even if it was perviously minimized. In eclipse I have to grab my mouse again and look for the output tab and click it to view my program output, because the output window/panel is just another one, like all the rest of the windows, but in Idea it is treated in a special way: "If the user want to run his program, is very likely he wants to see the output of that program!" It seems so natural when I write it, but eclipse fails in this basic user interface concept.

Probably there's a shortcut for this in eclipse ( autohide output window while editing and autoshow it when running the program ) , but as some other tens of features the shortcut must be hunted in forums, online help etc while in Idea is a little bit more "natural".

This can be repeated for almost all the features both have, autocomplete, word wrap, quick documentation view, everything. I think the user experience is far more pleasant in Idea than in eclipse. Then the motto comes true "Develop with pleasure"

Eclipse handles faster larger projects ( +300 jars and +4000 classes ) and I think IntelliJ Idea 8 is working on this.

All this of course is subjective. How can we measure user experience?

Don't forget "compare with clipboard".

Something that I use all the time in IntelliJ and which has no equivalent in Eclipse.

One of the good points in my opinion is the Dependency Structure Matrix: http://www.jetbrains.com/idea/features/dependency_analysis.html#link0

There's a good introduction to DSM usage and benefits in Lattix' website (a standalone product): http://www.lattix.com/files/dl/slides/s.php?directory=4tour

I think you can stick to either of these IDEs. The best sign to not to "worry about missing a giant benefit in the IDE you are not using" is the very long arguments we have seen between Eclipse fans and IntelliJ fans. This is a good sign that both sides have almost the same power which has led this long discussion to survive.

Show Navigation Bar ALT-Home.

Intellij has a far superior SVN plug-in than either Subversive or Subclipse and it works! The amount of time we've wasted merging source files using Eclipse doesn't bear thinking about. This isn't an issue with IntelliJ because the plugin helps you much more.

Also the Subclipse plugin is unreliable - we regularly have instances where the plugin doesn't think there has been any code checked in to SVN by other developers, but there has - the CI server has processed them!

I tried to switch to IntelliJ because of the new Android Studio. But I'm very disappointed now. I'm using Eclipse with the Code Recommanders Plugin. Here is a simple example why Eclipse is so awesome:

I want to create a new SimpleTimeZone. SimpleTimeZone has no Constructor with zero arguments.

Ctrl + Space in Eclipse

Ctrl + Space in IntelliJ

In IntelliJ I get no informations what kind of constructors SimpleTimeZone has.

After Enter in Eclipse

I get the previously selected constructor filled with predefined variable names. And I can see the type of every argument. With Code Recommanders Eclipse guesses the right constructor by the previously defined variable types in the current scope and fills the constructor with these vars.

After Enter in IntelliJ nothing happens. I get an empty constructor. I have to press Ctrl + P to see the expected arguments.

Structural search and replace.

For example, search for something like:

  System.out.println($string$ + $expr$);

Where $string$ is a literal, and $expr$ is an expression of type my.package.and.Class, and then replace with:

  $expr$.inspect($string$);

Open a project from a Maven POM. Just select "Open project..." navigate to your top level pom.xml and hit Enter :) NetBeans now has this feature as well.

My timing may be a little off in terms of this thread, but I just had to respond.

I am a huge eclipse fan -- using it since it's first appearance. A friend told me then (10+ years ago) that it would be a player. He was right.

However! I have just started using IntelliJ and if you haven't seen or used changelists -- you are missing out on programming heaven.

The ability to track my changed files (on my development branch ala clearcase) was something I was looking for in a plugin for eclipse. Intellij tracks all of your changes for a single commit, extremely easy. You can isolate changed files with custom lists. I use that for configuration files that must be unique locally, but are constantly flagged when I sync or compare against the repository -- listing them under a changelist, I can monitor them, but neatly tuck them away so I can focus on the real additions I am making.

Also, there's a Commit Log plugin that outputs a text of all changes for those SCCS that aren't integrated with your bug tracking software. Pasting the log into a ticket's work history captures the files, their version, date/time, and the branch/tags. It's cool as hell.

All of this could be supported via plugins (or future enhancements) in eclipse, I wager; yet, Intellij makes this a breeze.

Finally, I am really excited about the mainstream love for this product -- the keystrokes, so it's painful, but fun.

In IntelliJ, one can jump through a history of the last places edited with "Last Edit Location". Eclipse has a similar feature but Eclipse only goes back to one level of edit location.

Having the history rather than just the one level that Eclipse offers is a great productivity feature: it acts as a form of auto-bookmarking, since you often want to jump back to the places where you have been making changes. I use this ability several times a day, and feel the pain of not having it when I am asked to use Eclipse for something.

Idea 8.0 has the lovely ctrl+shift+space x 2 that does the following autocomplete:

 City city = customer.<ctrl-shift-space twice>

resolves to

 City city = customer.getAddress().getCity();

through any number of levels of getters/setters.

One thing I use regularly is setting a breakpoint, but then controlling what it does. (At my last job, most everyone else used Eclipse... I remember being surprised that no one could find how to do this in Eclipse.)

For example, can have the breakpoint not actually stop, but just log a message to the console. Which means, I don't have to litter my code with "System.out.println(...)" and then recompile.

Introduce variable. (Ctrl+Alt+V on Windows, Cmd+Alt+V on OSX)

Lets say you call a method, service.listAllPersons() Hit Ctrl+Alt+V and Enter, and variable for return value from method call is inserted:

List<Person> list = service.listAllPersons();

Saves you typing, and you don't have to check the return type of the method you are calling. Especially useful when using generics, e.g.

new ArrayList<String>()

[introduce variable]

ArrayList<String> stringArrayList = new ArrayList<String>();

(of course you can easily change the name of the variable before hitting Enter)

Two things that IntelliJ does that Eclipse doesn't that are very valuable to me:

Method separators: those faint gray lines between methods make code much more readable

Text anti-aliasing: makes code look so nice in the IDE

Alt+Insert to edit text in Column Mode.

Two things that IntelliJ does that Eclipse doesn't that are very valuable to me:

Method separators: those faint gray lines between methods make code much more readable

Text anti-aliasing: makes code look so nice in the IDE

Sorry if this is covered already, but simply having the 'changes' tab there where I can see my local changes, incoming changes, remote changes is just simply something I can't live without.. In Eclipse, I can't find such a feature!

Also just a simple thing like middle clicking which binds to the 'open declaration' is a great UI addition - something I also cannot see implemented in Eclipse.

There is only Eclipse at my work place but I'm seriously thinking of purchasing a personal Idea license....

Far, far, far more refactorings.

Sorry if this is covered already, but simply having the 'changes' tab there where I can see my local changes, incoming changes, remote changes is just simply something I can't live without.. In Eclipse, I can't find such a feature!

Also just a simple thing like middle clicking which binds to the 'open declaration' is a great UI addition - something I also cannot see implemented in Eclipse.

There is only Eclipse at my work place but I'm seriously thinking of purchasing a personal Idea license....

I don't remember if word/line/method/class wrap is possible in Eclipse

In Intellij Idea you use Ctrl+W

Intellij has a far superior SVN plug-in than either Subversive or Subclipse and it works! The amount of time we've wasted merging source files using Eclipse doesn't bear thinking about. This isn't an issue with IntelliJ because the plugin helps you much more.

Also the Subclipse plugin is unreliable - we regularly have instances where the plugin doesn't think there has been any code checked in to SVN by other developers, but there has - the CI server has processed them!

I don't remember if word/line/method/class wrap is possible in Eclipse

In Intellij Idea you use Ctrl+W

I have discovered recently at least two advanteges of IntelliJ IDEA over Eclipse.

If one tries to use code formating in the JSP code editor the JSP scriptlets get broken. Eclipse is getting a little bit crazy, it ads random pieces of code here and there. IDEA behaves very nicely.

The other thing is speed of deployment of the application on the JBoss Server. IntelliJ is replacing the application in the JBoss's tmp folder, so the redeployment is really fast. Eclipse WTP is replacing application in the deploy folder, which, as it turns out, lasts much longer.

One very useful feature is the ability to partially build a Maven reactor project so that only the parts you need are included.

To make this a little clearer, consider the case of a collection of WAR files with a lot of common resources (e.g. JavaScript, Spring config files etc) being shared between them using the overlay technique. If you are working on some web page (running in Jetty) and want to change some of the overlay code that is held in a separate module then you'd normally expect to have to stop Jetty, run the Maven build, start Jetty again and continue. This is the case with Eclipse and just about every other IDE I've worked with. Not so in IntelliJ. Using the project settings you can define which facet of which module you would like to be included in a background build. Consequently you end up with a process that appears seamless. You make a change to pretty much any code in the project and instantly it is available after you refresh the browser.

Very neat, and very fast.

I couldn't imagine coding a front end in something like YUI backing onto DWR/SpringMVC without it.

Something which I use in IntelliJ all the time is refactoring as I type. I have re-written classes from a printout (originally written in eclipse) using both IDEs and I used about 40% less key strokes/mouse clicks to write the same classes in IntelliJ than eclipse.

I wouldn't want to use Eclipse until they support as much refactoring with incomplete pieces of code.

Here is a longer list of features in IntelliJ 8.0/8.1 [http://www.jetbrains.com/idea/features/index.html]

If you have the cursor on a method then CTRL+SHIFT+I will popup the method implementation. If the method is an interface method, then you can use up- and down- arrows to cycle through the implementations:

Map<String, Integer> m = ...
m.contains|Key("Wibble");

Where | is (for example) where your cursor is.

Far, far, far more refactorings.

IntelliJ has intellisense and refactoring support from code into jspx documents.

Preamble to my answer: My use of Eclipse is limited. We needed a Java IDE to work on both Windows and Mac and the Mac port slowed down day by day. This was years ago and I'm sure it's OK now. But that is what got us to switch to IntelliJ and we've been happy with it.

Now for my answer: One big difference I haven't seen mentioned yet is that tech support is better with IntelliJ/Jet Brains. We send an e-mail to JetBrains and get a definitive answer back in less than an hour. Looking for answers to Eclipse problems results in the usual, "You stupid idiot" answers (usually a small number of the replies) along with the much larger number of insightful, helpful replies. But it takes some sorting through to get the real answer.

Data flow analysis : inter-procedural backward flow analysis and forward flow analysis, as described here. My experiences are based on Community Edition, which does data flow analysis fairly well. It has failed (refused to do anything) in few cases when code is very complex.

For me, it's IDEA's maven support, especially in version 9 is second to none. The on-the-fly synchronizing of the project to the maven model is just fantastic and makes development pleasant.

Don't forget "compare with clipboard".

Something that I use all the time in IntelliJ and which has no equivalent in Eclipse.

Open a project from a Maven POM. Just select "Open project..." navigate to your top level pom.xml and hit Enter :) NetBeans now has this feature as well.

The IntelliJ debugger has a very handy feature called "Evaluate Expression", that is by far better than eclipses pendant. It has full code-completion and i concider it to be generally "more useful".

Preamble to my answer: My use of Eclipse is limited. We needed a Java IDE to work on both Windows and Mac and the Mac port slowed down day by day. This was years ago and I'm sure it's OK now. But that is what got us to switch to IntelliJ and we've been happy with it.

Now for my answer: One big difference I haven't seen mentioned yet is that tech support is better with IntelliJ/Jet Brains. We send an e-mail to JetBrains and get a definitive answer back in less than an hour. Looking for answers to Eclipse problems results in the usual, "You stupid idiot" answers (usually a small number of the replies) along with the much larger number of insightful, helpful replies. But it takes some sorting through to get the real answer.

Two things that IntelliJ does that Eclipse doesn't that are very valuable to me:

Method separators: those faint gray lines between methods make code much more readable

Text anti-aliasing: makes code look so nice in the IDE

Well, for me it's a thousand tiny things. Some of the macros, the GUI layout in general in Eclipse I find awful. I can't open multiple projects in different windows in Eclipse. I can open multiple projects, but then it's view based system swaps a bunch of things around on me when I switch files. IntelliJ's code inspections seem better. Its popup helpers to fix common issues is nice. Lots of simple usability things like the side bar where I can hover over a hot spot and it'll tell me every implementing subclass of a method or the method I'm implementing and from where.

Whenever I've had to use, or watch someone use, Eclipse it seems like they can do most of the things I can do in IntelliJ, but it takes them longer and it's clunkier.

Data flow analysis : inter-procedural backward flow analysis and forward flow analysis, as described here. My experiences are based on Community Edition, which does data flow analysis fairly well. It has failed (refused to do anything) in few cases when code is very complex.

One very useful feature is the ability to partially build a Maven reactor project so that only the parts you need are included.

To make this a little clearer, consider the case of a collection of WAR files with a lot of common resources (e.g. JavaScript, Spring config files etc) being shared between them using the overlay technique. If you are working on some web page (running in Jetty) and want to change some of the overlay code that is held in a separate module then you'd normally expect to have to stop Jetty, run the Maven build, start Jetty again and continue. This is the case with Eclipse and just about every other IDE I've worked with. Not so in IntelliJ. Using the project settings you can define which facet of which module you would like to be included in a background build. Consequently you end up with a process that appears seamless. You make a change to pretty much any code in the project and instantly it is available after you refresh the browser.

Very neat, and very fast.

I couldn't imagine coding a front end in something like YUI backing onto DWR/SpringMVC without it.

Probably is not a matter of what can/can't be done, but how.

For instance both have editor surrounded with dock panels for project, classpath, output, structure etc. But in Idea when I start to type all these collapse automatically let me focus on the code it self; In eclipse all these panels keep open leaving my editor area very reduced, about 1/5 of the total viewable area. So I have to grab the mouse and click to minimize in those panels. Doing this all day long is a very frustrating experience in eclipse.

The exact opposite thing happens with the view output window. In Idea running a program brings the output window/panel to see the output of the program even if it was perviously minimized. In eclipse I have to grab my mouse again and look for the output tab and click it to view my program output, because the output window/panel is just another one, like all the rest of the windows, but in Idea it is treated in a special way: "If the user want to run his program, is very likely he wants to see the output of that program!" It seems so natural when I write it, but eclipse fails in this basic user interface concept.

Probably there's a shortcut for this in eclipse ( autohide output window while editing and autoshow it when running the program ) , but as some other tens of features the shortcut must be hunted in forums, online help etc while in Idea is a little bit more "natural".

This can be repeated for almost all the features both have, autocomplete, word wrap, quick documentation view, everything. I think the user experience is far more pleasant in Idea than in eclipse. Then the motto comes true "Develop with pleasure"

Eclipse handles faster larger projects ( +300 jars and +4000 classes ) and I think IntelliJ Idea 8 is working on this.

All this of course is subjective. How can we measure user experience?

There is only one reason I use intellij and not eclipse: Usability

Whether it is debugging, refactoring, auto-completion.. Intellij is much easier to use with consistent key bindings, options available where you look for them etc. Feature-wise, it will be tough for intellij to catch up with Eclipse, as the latter has much more plugins available that intellij, and is easily extensible.

IntelliJ has some pretty advanced code inspections (comparable but different to FindBugs).

Although I seriously miss a FindBugs plugin when using IntelliJ (The Eclipse/FindBugs integration is pretty cool).

Here is an official list of CodeInspections supported by IntelliJ

EDIT: Finally, there is a findbugs-plugin for IntelliJ. It is still a bit beta but the combination of Code Inspections and FindBugs is just awesome!

One very useful feature is the ability to partially build a Maven reactor project so that only the parts you need are included.

To make this a little clearer, consider the case of a collection of WAR files with a lot of common resources (e.g. JavaScript, Spring config files etc) being shared between them using the overlay technique. If you are working on some web page (running in Jetty) and want to change some of the overlay code that is held in a separate module then you'd normally expect to have to stop Jetty, run the Maven build, start Jetty again and continue. This is the case with Eclipse and just about every other IDE I've worked with. Not so in IntelliJ. Using the project settings you can define which facet of which module you would like to be included in a background build. Consequently you end up with a process that appears seamless. You make a change to pretty much any code in the project and instantly it is available after you refresh the browser.

Very neat, and very fast.

I couldn't imagine coding a front end in something like YUI backing onto DWR/SpringMVC without it.

IntelliJ has intellisense and refactoring support from code into jspx documents.

My favorite shortcut in IntelliJ that has no equivalent in Eclipse (that I've found) is called 'Go to symbol'. CTRL-ALT-SHIFT-N lets you start typing and glob up classes, method names, variable names, etc, from the entire project.

Don't forget "compare with clipboard".

Something that I use all the time in IntelliJ and which has no equivalent in Eclipse.

At current, it is the only one that can have tabs torn out into another window. Handy when you have more screens.

In IntelliJ, one can jump through a history of the last places edited with "Last Edit Location". Eclipse has a similar feature but Eclipse only goes back to one level of edit location.

Having the history rather than just the one level that Eclipse offers is a great productivity feature: it acts as a form of auto-bookmarking, since you often want to jump back to the places where you have been making changes. I use this ability several times a day, and feel the pain of not having it when I am asked to use Eclipse for something.

Well, for me it's a thousand tiny things. Some of the macros, the GUI layout in general in Eclipse I find awful. I can't open multiple projects in different windows in Eclipse. I can open multiple projects, but then it's view based system swaps a bunch of things around on me when I switch files. IntelliJ's code inspections seem better. Its popup helpers to fix common issues is nice. Lots of simple usability things like the side bar where I can hover over a hot spot and it'll tell me every implementing subclass of a method or the method I'm implementing and from where.

Whenever I've had to use, or watch someone use, Eclipse it seems like they can do most of the things I can do in IntelliJ, but it takes them longer and it's clunkier.

Show Navigation Bar ALT-Home.

I think you can stick to either of these IDEs. The best sign to not to "worry about missing a giant benefit in the IDE you are not using" is the very long arguments we have seen between Eclipse fans and IntelliJ fans. This is a good sign that both sides have almost the same power which has led this long discussion to survive.

There is only one reason I use intellij and not eclipse: Usability

Whether it is debugging, refactoring, auto-completion.. Intellij is much easier to use with consistent key bindings, options available where you look for them etc. Feature-wise, it will be tough for intellij to catch up with Eclipse, as the latter has much more plugins available that intellij, and is easily extensible.

I not have coded a lot with IntellijIdea, but in IntellijIdea you can see where a block of code between brackets (if, try/catch, cycle, etc) begins and where finish.

In Eclipse (I code in Eclipse 3.2) you can identify the block only manually.

If you have the cursor on a method then CTRL+SHIFT+I will popup the method implementation. If the method is an interface method, then you can use up- and down- arrows to cycle through the implementations:

Map<String, Integer> m = ...
m.contains|Key("Wibble");

Where | is (for example) where your cursor is.

IntelliJ has some pretty advanced code inspections (comparable but different to FindBugs).

Although I seriously miss a FindBugs plugin when using IntelliJ (The Eclipse/FindBugs integration is pretty cool).

Here is an official list of CodeInspections supported by IntelliJ

EDIT: Finally, there is a findbugs-plugin for IntelliJ. It is still a bit beta but the combination of Code Inspections and FindBugs is just awesome!

There is one thing that IntelliJ does much much better than Eclipse and that is empty your pockets!

I do however prefer using it and one big advantage it has over Eclipce is the way it synchronises with the file system, for big projects and slow computers (yes in work environments the PC's are a lot slower than our ones at home) Eclipse seems to struggle where IntelliJ seems to be quicker albeit with a slower initial indexing time.

IntelliJ Community edition obviously makes using it free but you soon want those extra refactoring and nice little goodies not included in the CC edition.

In my opinion, its generally a better user experience but whether its worth the cost is a question for each developer to answer themselves.

But lets be grateful we have up to three great IDEs for Java right now with NetBeans getting better all the time.

Well, for me it's a thousand tiny things. Some of the macros, the GUI layout in general in Eclipse I find awful. I can't open multiple projects in different windows in Eclipse. I can open multiple projects, but then it's view based system swaps a bunch of things around on me when I switch files. IntelliJ's code inspections seem better. Its popup helpers to fix common issues is nice. Lots of simple usability things like the side bar where I can hover over a hot spot and it'll tell me every implementing subclass of a method or the method I'm implementing and from where.

Whenever I've had to use, or watch someone use, Eclipse it seems like they can do most of the things I can do in IntelliJ, but it takes them longer and it's clunkier.

Idea 8.0 has the lovely ctrl+shift+space x 2 that does the following autocomplete:

 City city = customer.<ctrl-shift-space twice>

resolves to

 City city = customer.getAddress().getCity();

through any number of levels of getters/setters.

I not have coded a lot with IntellijIdea, but in IntellijIdea you can see where a block of code between brackets (if, try/catch, cycle, etc) begins and where finish.

In Eclipse (I code in Eclipse 3.2) you can identify the block only manually.

Two things that IntelliJ does that Eclipse doesn't that are very valuable to me:

Method separators: those faint gray lines between methods make code much more readable

Text anti-aliasing: makes code look so nice in the IDE

Probably is not a matter of what can/can't be done, but how.

For instance both have editor surrounded with dock panels for project, classpath, output, structure etc. But in Idea when I start to type all these collapse automatically let me focus on the code it self; In eclipse all these panels keep open leaving my editor area very reduced, about 1/5 of the total viewable area. So I have to grab the mouse and click to minimize in those panels. Doing this all day long is a very frustrating experience in eclipse.

The exact opposite thing happens with the view output window. In Idea running a program brings the output window/panel to see the output of the program even if it was perviously minimized. In eclipse I have to grab my mouse again and look for the output tab and click it to view my program output, because the output window/panel is just another one, like all the rest of the windows, but in Idea it is treated in a special way: "If the user want to run his program, is very likely he wants to see the output of that program!" It seems so natural when I write it, but eclipse fails in this basic user interface concept.

Probably there's a shortcut for this in eclipse ( autohide output window while editing and autoshow it when running the program ) , but as some other tens of features the shortcut must be hunted in forums, online help etc while in Idea is a little bit more "natural".

This can be repeated for almost all the features both have, autocomplete, word wrap, quick documentation view, everything. I think the user experience is far more pleasant in Idea than in eclipse. Then the motto comes true "Develop with pleasure"

Eclipse handles faster larger projects ( +300 jars and +4000 classes ) and I think IntelliJ Idea 8 is working on this.

All this of course is subjective. How can we measure user experience?