I've used both professionally, for years.

Eclipse has historically suffered from a couple of major problems, in my opinion:

1. It's "Eclipse is a framework, and the Java IDE is just an implementation" mentality made the user experience terrible. Everything was a perspective, with it's own configuration. I remember distinctly trying to set the editor to use four spaces instead of tabs. I had to do this once for every file type (xml, javascript, html, java, css, etc.) Commands would suddenly be disabled because you were looking at a file in a different perspective. In all fairness, the usability of Eclipse is getting better, but this, to me, is still Eclipse's major weakness.

2. Their JavaScript (and other language support) was terrible. (Note: It's first-class now. But it took a very long time to get to this point.) For those of us who did a lot of front-end work, this was a major shortcoming.

Overall, Eclipse has gotten much better, and there are some plugins that just might make it your editor of choice. IntelliJ is still my choice, though.

When I switched from Eclipse to IntelliJ about 2 years ago the thing that most impressed me was that every part of IntelliJ feels fully integrated with the IDE.

For Eclipse, you had to rely on 3rd party developers for plugins for things like Hibernate or Spring integration; and the amount of integration with the IDE itself was usually hit-or-miss. Different plugins would have different UIs or different ways of doing things.

I've found that in IntelliJ, these types of things are first-class features instead - the Spring and Hibernate support (for instance) is built into the IDE by JetBrains. Things like "find usages of bean" can be invoked with the same keystrokes as "find usage of class". The editor can jump from the Java class editor to where the class is defined in your Spring context just as easily.

I've used Eclipse for about 6 years for Java development before switching jobs and switching to IntelliJ. If there is one important difference it is this: It's fast. Eclipse can take up to a second or so to generate auto completion recommendations. In IntelliJ, you hardly even notice it it is so fast. This allows the IDE to get out of your way and leave your thinking uninterrupted which is often one of the main benefits touted by vim or emacs users.

I would say try IntelliJ for a month. That will give you time to alter some of the strange default settings (like being able to put the cursor past the end of the line) and discover some of the many other powerful features (like clever renaming of getters/setters when renaming a field). But I still believe it is the speed that sets IntelliJ apart from any other IDE out there and will be the ultimate reason for your improved productivity.

IntelliJ is more reliable and better integrated; eclipse has more features but needs more attention. I don't think IntelliJ has anything that eclipse lacks per se, but it's much more likely to "just work" and get out of your way.

(personally I use eclipse and take the time to babysit it because I can't live without proper incremental compilation)

It seems like there are lots of little things that are preferable. A few random ones off the top of my head:

In my last job where we used Eclipse, we'd get a maven project and then run mvn eclipse:eclipse to generate the eclipse project. In IntelliJ, you can just open an existing maven project by selecting the pom.

Maven auto-update is also nice (if you do a mvn clean install, your project will automatically update accordingly).

In eclipse, if you debugged into an external library, you'd have the option of attaching the source; then you'd have to go find the right jar to add. In intellij, you can just click "download sources" and it usually does the right thing.

In general, I had a fair amount of difficulty setting up projects and getting them to run correctly under eclipse -- but that may be more of a reflection of how our projects were configured. Things seem smoother under IntelliJ.

Eclipse has a proper incremental compiler, which will tell you what's wrong with your code as you type and refactor. IntelliJ has historically not had one, and the introduction of the 'compile as you go' feature in IntelliJ 12 just doesn't hold a candle to the Eclipse one in complex workspaces.

Source: 5 years with Eclipse, and 6 months using IntelliJ 11/12 now.

I'm not Eclipse user neither IntelliJ. I tried IntelliJ after looking at this post. First impression, InteliJ interface is lot better and cleaner than Eclipse. Eclipse interface (or skin) looks ugly and takes lot of space with its big toolbar buttons and rounded tabs. Also I noticed that IntelliJ shows shortcuts while hovering over things (like completion, docks etc...) nicely, which is pretty cool.

Rest I can't comment on how good they are with enhancing your productivity, as I never used them.

I think IntelliJ is definitely better than Eclipse - feature wise.

However, it is really hard to beat free. I think the numbers show that 7 of 8 Java developers use Eclipse. This also means that third party providers are more likely to build on top of Eclipse.

The fact that IntelliJ has built a large user base only goes to show how good a product they are.

Yeah, IntelliJ has recently launched an open source version... But I am a little reluctant to use it given the strong Ecosystem around Eclipse.

(Disclaimer: I build plugins for Eclipse)

To answer your Android development concern specifically, as I didn't see anyone else commenting on it yet:

Having done Android work in both Eclipse and IntelliJ, I much prefer the latter. It has nice tools out-of-the-box for every aspect of Android development; package signing (and keystore management), integrated logcat monitor (a bit simpler than Eclipse's), the on-device or emulator debugging works perfectly etc. I've never had a problem translating Eclipse tutorials to IntelliJ.

It's also a lot less buggy than Eclipse+ADT in my experience. Eclipse/ADT is terrible when it comes to larger Android projects that may reference other projects in your workspace, I frequently had to do a clean build to get it to detect changes across the projects (a known problem in the ADT bugtracker IIRC).

IntelliJ is also faster, has better code completion, and a really nice dark UI theme called Darcula out of the box (trying to make Eclipse dark is near impossible). It's paid for its price many times over in productivity gains for me.

I'd like to caution you against deciding on Eclipse solely because of online tutorials and Google recommendation. For one, Eclipse is free, so it has a very low barrier to entry. If you were going to start Java tomorrow, I'd tell you to use Eclipse or Netbeans as well, even though I own IntelliJ.

Can't give you a comparison because I use it infrequently, and I use IntelliJ for Ruby. It's a lot more polished than Aptana Studios' Ruby integration, which is basically Eclipse.

IntelliJ's @Nullable annotations are a decent workaround to my biggest complaint about Java. (Java has a static type system that intentionally doesn't catch the most common type error.)

On the NetBeans subject: does NetBeans have much traction outside of Sun/Oracle? It's been a while since I've done any Java development, but back in 2005, it seemed that pretty much only the official Java tutorials used NetBeans.

Netbeans started getting some major traction around the 2005 - 2007 timeframe, but seems to have lost ground since the Oracle takeover. Limited support for Ruby/JRuby and virtually non-existent Scala support caused me to ditch it after many years of use.

1.Intellij Idea is faster , you could try searching for the same project. 2.Intellij Idea is way more Intelligent than Eclipse. try jsp/javascript/java editing by urself, and you will be surprised 3.Built in support for a lot of popular Frameworks and Version Control Systems.

Eclipse's interface is clunky (switch between debug and code), debugger is buggy and is generally slow.