Things possible in IntelliJ that aren't possible in Eclipse?

Answer 1

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?

Answer 2

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

Answer 3

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.

Answer 4

Don't forget "compare with clipboard".

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

Answer 5

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)

Answer 6

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.