Review: The big 4 Java IDEs compared

When you think of a Java IDE, you undoubtedly imagine a graphical application in which you write Java source code, then compile, debug, and run it. Of course that’s a small part of the picture — if you’re building a Java application, odds are good you’re working with more than Java.

There might be a relational database involved. Or if you’re building a Web-based application, you might have to deal with AJAX, and that means JavaScript. And HTML. And that application will be running from an application server like Tomcat, so you’ll need management tools for the application server. You’re not alone; you’re working with a team of developers, so it would be helpful if that IDE worked with Git or Subversion.

The list goes on, but you get the idea. Rarely is it the case that, when you build a Java application, all you do is build a Java application. And an IDE needs to provide tools that help you wrestle into submission all of the related technologies in which your project will entangle you.

In this review, I’ll look at the current state of four of the best-known Java IDEs currently available:

• The venerable Eclipse. Though versions of Eclipse exist for developing in many languages besides Java (C++, Python, Fortran, Ruby, even Cobol, to name a few), Eclipse is Java-based, and it’s best known as a Java IDE. The fact that it can be used to develop in so many other languages is a testament to its extensibility, which is … extensive.
• NetBeans. NetBeans can support development in languages other than Java, though not as many as Eclipse. NetBeans began life as a commercial product in the late 1990s, but was later open-sourced by Sun and has remained so since Oracle’s purchase of Sun (and consequent acquisition of NetBeans).
• JDeveloper. JDeveloper is also an Oracle property. However, while NetBeans supports development in multiple languages and in a variety of Java environments, JDeveloper is solidly Java, and it’s intended primarily for J2EE development.
• IntelliJ IDEA. Like Eclipse and NetBeans, JetBrains’ IntelliJ IDEA supports a variety of languages and Java technologies. IDEA is most noteworthy in its incorporation of productivity enhancements in the IDE’s editors and tools. Unlike the other IDEs, IDEA is available in a paid-for Ultimate Edition and in a more limited — but free — Community Edition.

Eclipse

Eclipse is available in more variations than you can count. Not only does it provide the fundamental capabilities of an IDE — project management, source editing, compiling, debugging, version control — but the Eclipse platform has been modified for use as a database browser (DBeaver), a business process modeler (BPMN2 Modeler), a data visualization and report generation toolkit (BIRT, Business Intelligence and Reporting Tools), and more. Versions of Eclipse have been created for specific application domains: testing, automotive development, parallel systems development, and on and on. The number of available plug-ins is equally endless, as is the array of programming languages supported.

Eclipse is also the font of many notable projects. For example, Eclipse RAP (Remote Application Platform) is a framework for building a business application that can be presented on devices ranging from Web browsers to desktop application clients to mobile devices. Eclipse RAP’s reusable, SWT-based API lets you deploy to a variety of targets from a single code base.

In short, Eclipse is not so much an IDE as an IDE platform.

Yet Eclipse is certainly best known as a top-notch Java IDE. It is written in Java and can therefore run on all of the primary operating systems. As you might expect with so many variations of Eclipse, there are many variations of what might be called “Eclipse for Java.” Head over to the Eclipse website, and you’ll find the following:

• Basic Eclipse for Java Developers, for building Java SE applications
• Eclipse for Java EE developers, for building Web- and server-based applications
• Eclipse for Java and Report Developers, an amalgam of Java EE tools and the BIRT reporting tool, which facilitates report design and creation, includes a charting engine, and can be applied to both Java desktop and Web applications
• Eclipse for Java and DSL Developers, including the open source Xtext framework that lets you create DSLs (domain-specific languages)
• Eclipse for Testers, which includes the Jubula tool for creating and managing automated GUI tests of applications employing Swing, SWT, HTML, and other user interface technologies

Those editions are more or less specific collections of Eclipse plug-ins. The flexibility of Eclipse’s plug-in architecture means you can outfit your particular installation of Eclipse with a virtually limitless combination of capabilities. For this review, however, I installed the Java EE version of Eclipse, an IDE equipped to create Web, server, and desktop Java applications, as well as Enterprise JavaBeans, Connectors, and more. Because I use Groovy to write test scripts, I added the Groovy plug-in from Codehaus.

The latest release (as of this writing) is Eclipse Luna, which fully supports Java 8, including the ability for the Eclipse memory analyzer to accept Java 8 heap dumps. Luna also supports Paho, an M2M (machine to machine) messaging system that employs MQTT (Message Queuing Telemetry Transport), a lightweight publish-and-subscribe messaging protocol.

Working with Eclipse

When you open Eclipse, your workspace is composed of numerous tabbed windows, aka views. A view provides management of a given resource. An editor is one sort of view; the package explorer, which shows the arrangement of packages, classes, and libraries in a Java application, is another sort of view; the debugger window is a view; and so on.

A “perspective” — a central concept in the Eclipse user interface — is a combination of views geared toward a specific task. During the actual writing of Java code, you’ll use the Java perspective, with its outline and editor views. When it’s time to debug your application, you’ll switch to the Debugging perspective with its debugging and active threads views. For database work, open the Database Development perspective, with its Data Source Explorer view and SQL execution view. The number of perspectives available in any given Eclipse session generally depends on which plug-ins you’ve installed.

As complex as this sounds — it will certainly seem complex to anyone new to Eclipse — the topology of Eclipse’s working area will be familiar to anyone who has used an IDE. Navigation views are on the left, content editing in the center, component hierarchy views on the right, and output and status across the bottom. Of course, the arrangement of these visual elements is completely customizable, and you can add views to a perspective or remove them at will.

Eclipse is filled to the brim with every sort of editor you can imagine: editors for Java resources, CSS, HTML, SQL, JavaScript, Maven POM (Project Object Model) files, and — oh, yes — Java source files. Indeed, think of a user-modifiable file type that a Java application might conceivably employ, and Eclipse has an editor for it. Even if you discover a file for which Eclipse provides no editor, the IDE can be configured to open an external editor. Of course, Eclipse’s editors are content-aware. Open a Java file, and you get the Java source editor. Open an XML file, and you get the XML editor.

While you’re coding, Eclipse is ready with a variety of assists: auto-completion, dependency resolution (use a class that you haven’t imported yet, and Eclipse will offer to add the import statement for you), plenty of boilerplate code templates — constructors, getters and setters, the toString() method — and more. Its refactoring repertoire includes renaming, moving (transferring a method from one class to another and automatically updating references throughout the code), extracting an interface from a class, and extra handy tricks. Eclipse also helps you navigate through a method’s or variable’s references and declarations.

Even with all this assistance, if you foul up, Eclipse will track your changes, and its local history feature lets you step back in time and view your alterations. You can view previous versions of the file, and Eclipse provides a graphical Diff view so that you can examine the deltas between versions.

For building a project, Eclipse’s support for Ant is integrated. Maven support is provided via the M2Eclipse project’s plug-in. If you prefer Gradle, there is a plug-in, though its capabilities vary depending on what language support you’ve added to Eclipse. The plug-in can handle Java, Groovy, and Scala, and it can manage the production of WARs (Web archives) and EARs (enterprise archives). Speaking of Scala, if you want to use that JVM language in Eclipse, there’s a plug-in for the build tool, SBT, as well as a full-blown Scala IDE project built on Eclipse.

For version control, Eclipse ships with support for CVS (it includes a built-in client). The Java EE edition of Eclipse also covers EGit, which provides Git integration. Plug-ins are available for Subversion, Visual SourceSafe, Perforce, and Mercurial. In fact, it would be surprising to find a version control software product for which a free Eclipse plug-in does not exist.

Eclipse help and documentation

There is more material in Eclipse’s online documentation than you can imagine, and because Eclipse has been around for so long, some can go back quite a ways. For example, you’ll find a pointer on the Eclipse Wiki to a two-part “Eclipse Platform Technical Overview” article. The original version of part one was written in 2001; its most recent revision was 2006. The online workbench user’s guide for the Luna version is online here as well. It goes on for miles, as it includes documentation for all Luna components: C/C++, Fortran, BIRT, EGit, JavaScript, parallel processing development, and so on.

Eclipse’s runtime help includes the Dynamic Help feature. This opens a sidebar: a floating window that can be anchored wherever you wish in the GUI. Click on any view in your Eclipse session, and the content of the sidebar changes to reflect your choice. For example, if you are editing a Java class and click on the editor window, the content of the help sidebar might be entries like “Java editor concepts,” “Using code templates,” and “Java editor reference.” 

Eclipse can handle nearly any task that might arise in the Java development process. It can also be equipped with all the tools you’ll need for ancillary chores: dealing with Web services, managing databases, debugging a remote application server. Its great strength is the seemingly limitless number and variety of plug-ins. In fact, it’s not unreasonable to say that, when you launch Eclipse, you’re activating a colony of plug-ins. The only real chore you’ll face while managing your development project with Eclipse is managing Eclipse itself, as it’s easy to create an IDE anarchy.

NetBeans

A well-established Java IDE, the NetBeans project is currently managed by Oracle. The IDE was open-sourced by Sun Microsystems in the late 1990s. You can use NetBeans to develop applications not only in Java, but also in Groovy, JavaScript, PHP, and C/C++. Community supported plug-ins are available for Python, Ruby, and Scala.

The current release of NetBeans is version 8.0.2, and here, 8 is the magic number. Because this release adds support for Java 8 — including support for debugging code in the JDK 8’s Nashorn JavaScript engine. This release also supports the PrimeFaces framework, as well as improved workings for Maven. (PrimeFaces is a user interface framework that combines Java Server Faces and AJAX components. It can be used for both desktop and mobile applications.) Version 8 of NetBeans beefed up support for JavaScript libraries such as AngularJS and JQuery, and added support for RequireJS, a library that manages JavaScript dependencies and module loading.

This latest version of NetBeans handles the Tomcat 8 and the Java EE hot-rodded TomEE application servers, as well as WildFly (formerly JBoss) and GlassFish. Tomcat and GlassFish are bundled with the IDE.

NetBeans is available in several editions. For basic Java development, go with the Java SE edition. Choose the EE edition for enterprise development. It adds Java EE support, as well as support for the application servers mentioned above. If you work with the WebLogic application server, NetBeans can handle that, but you must download the WebLogic server separately and register it with the IDE.

NetBeans editions exist for C/C++ development, along with PHP plus HTML5 development. If you want it all, there’s an edition for that too.

Working with NetBeans

NetBeans’ layout is uncluttered and easy for even new users to navigate. On the left of the work area is the navigation pane. It consists of three tabs: Projects, Files, and Services. The Project tab holds a hierarchical view of your application’s components. Choose a project, and it opens a tree with branches that include source, resources, and libraries. The Files tab shows a file system perspective via which you can browse your project’s actual folders and files. The Services tab is more elaborate; I will examine its capabilities below.

When you’re working in the editor, you’ll find NetBeans provides the expected coding assists. Its refactoring skills include the standard rename, move, and safe delete. NetBeans can also automate the chore of moving a method up into a superclass or down into a child class, and it can extract either an interface or a subclass from a class definition. The IDE’s templates can quickly generate source code for constructors, getters and setters, standard methods like toString() and hashCode(), and even create delegation members that provide access to class variables without exposing that field directly. If you have Web services defined in the IDE (found on the Services tab), NetBeans can generate code for calling a Web service operation.

The final tab in the left-hand window — the Services tab — includes management functions for all the external services that your project might interact with. These include:

• Web Services. This tab is prepopulated with well-known services like Amazon, Delicious, Flickr, Google, WeatherBug, and others. You use it when you want to add access to a Web service operation to your application. Open the source file that you want to access the Web service from, and drag the Web service function call in the Services tab to the location in your source where you want the Web service call to be made. NetBeans “pours” the proper code in, defines the necessary arguments, and even places the required import statements into your source file.
• Maven Repositories. Give NetBeans an ID, name, and URL of a Maven repository, and the IDE will download the index and let you browse its contents.
• Hudson Builders. Hudson is a continuous integration tool that runs in an application server. You can connect to one or more Hudson servers and monitor the status of the jobs each server manages. Some management functions are also available; for example, you can set some jobs as “watched,” in which case a notification pop-up appears when build or test failures occur on those jobs.
• Task Repositories. This entry provides access to issue tracking systems such as Bugzilla and JIRA.
• JS Test Driver. Finally, this entry lets you configure usage of JS Test Driver, a Java-based server designed for testing JavaScript code. You can configure not only the location of the JS Test Driver server (actually, a JAR file), as well as the browsers you’ll use to test your JavaScript code. NetBeans will even generate a configuration file you can modify further to control the testing process.

NetBeans can work with version control systems such as Subversion, Mercurial, and Git. Plug-ins are available for CVS and ClearCase. Like Eclipse, NetBeans benefits from a healthy plug-in ecosystem. If you don’t find a capability in the NetBeans IDE, odds are good that a plug-in exists for that capability. You can either check for available plug-ins directly from within the IDE or explore the NetBeans plug-ins portal.

NetBeans has excellent testing facilities, which include templates and wizards for both JUnit and TestNG. It will support both JUnit 3 and JUnit 4, as well as autogenerate JUnit initializer and finalizer stubs. NetBeans will generate initializer and finalizers for TestNG too.

The NetBeans debugger easily deals with multithreaded applications. You can switch among threads, and NetBeans will detect thread deadlocks among suspended threads. The debugger’s code snippet evaluator lets you define methods for formatting the output of complex objects while debugging, so you can display the objects in a more readable form, instead of having to drill down into a tangle of containment references.

For debugging GUI components, NetBeans’ visual debugger can take a “snapshot” of the GUI display at runtime, and from that lets you locate the code behind selected components (buttons, scroll bars, panels). You can also select the component, open a properties window, and examine the properties associated with the component at the time the snapshot was taken.

NetBeans help and documentation

NetBeans’ built-in help and documentation for Java is little more than pointers to online help. The results of documentation search queries are scored in the same fashion made popular by Consumer Reports’ product grading system: A small circle is displayed next to each search result; the circle is filled in by an amount corresponding to the search tool’s judgment of how close the result is likely to fulfill the query. Online documentation is extensive. The “getting started” information on the main page moves smoothly from “here’s what you can do” material to “here’s how to do it.” There are plenty of tutorials online, too. Many are arranged in “learning trails” — such as GUI, Java EE, Mobile, and Embedded — and include pointers to articles and screencasts.

NetBeans enjoys nearly as many plug-ins as Eclipse, though it is not the IDE-builder’s IDE that Eclipse has become. On the other hand, the NetBeans interface is cleaner than the Eclipse UI; you don’t have to transition among perspectives in NetBeans when the nature of your work changes. New developers will pick up NetBeans more quickly than Eclipse. This in no way diminishes its usefulness for seasoned Java developers. NetBeans will carry you through the chores of building the most demanding enterprise Java applications.

JDeveloper

JDeveloper, also available from Oracle, is the primary development platform for Oracle Fusion Middleware products. JDeveloper’s current version is 12c, which is available in two editions: Studio and Java. The Studio edition is meant for developing enterprise applications. The Java edition includes only components for Java SE applications and XML tools; it lacks J2EE tools, database features, ADF (Application Developer Framework), and UML tools … all of which are in the Studio version.

ADF is Oracle’s Java EE development framework. ADF implements the MVC paradigm and covers virtually all aspects of EE development: ORM, persistence, UI controls and Web user interface, application flow control, and so on. Its goal is to minimize the infrastructure code you have to write to construct a Java EE application.

Bundled with the Studio edition installation is an instance of Oracle’s WebLogic Server, along with the WebLogic client JAR files. Although WebLogic is the preferred J2EE deployment platform, JDeveloper will let you deploy to GlassFish, Tomcat, and WebSphere application servers.

Working with JDeveloper

When you start JDeveloper, you’re asked what role you’ll be acting in while using the IDE. This role determines the features — menu items, dialogs, preferences — that JDeveloper enables or disables for your development session. The available roles are as follows:

• Studio Developer. This enables all features.
• Customization Developer. Select this role if you’ll be customizing an ADF application’s components. (Applications built using ADF can be “personalized” by customizing the attributes of the application’s components. The Customization Developer role provides tools for such operations.)
• Database Developer. Choose this role if your application will require heavy interaction with a database. JDeveloper’s database tools are particularly powerful.
• Java Developer. Choose this for core Java application development (absent Java EE features).
• Java EE Developer. Choose this for Java EE application development.

New in this release of JDeveloper (version 12.1.3) is support for Java SE 8 (though the JDeveloper IDE itself must run in Java SE 7 JDK) and improved support for Maven. It also brings incremental enhancements to the IDE’s Java EE tools and adds the ability to create JAX-RS 1.1 and JAX-RS 2.0 REST services and clients via Jersey. (JAX-RS is the Java API for RESTful Web services, and Jersey is Oracle’s reference implementation.) The database tools have also been improved. For example, Code Insight — JDeveloper’s name for code completion capabilities — is now available in the database modeler. Finally, there are tons of enhancements to JDeveloper’s support for ADF.

The highest-level organizational element in JDeveloper is an application (which, as you’ll see, can be a bit confusing). During a given work session with JDeveloper, you will have a single application open. Within an application you define one or more projects, where a project is a container of the elements that (typically) are used to create a single Java program. Within projects are “compilation units,” which more or less correspond to the Java classes that your project builds.

Once you’ve defined your application, you begin populating it with projects. JDeveloper has plenty of project types to choose from: Java desktop application, ADF application, Coherence application (Coherence being Oracle’s in-memory data-grid technology), REST and SOAP Web services, JSF (JavaServer Faces) project, and many more. Once you’ve selected the project type, you proceed to adding the needed source and resource files. For build tools, JDeveloper has its own build system, or you can choose Ant or Maven to manage your project.

JDeveloper’s editing system’s term of code completion is Completion Insight, and although the name is peculiar, it has all the features you’d expect. Type in an object’s name and a pop-up shows all of its available methods. It has templates for common constructs as well. Type Ctrl-Enter, and a pop-up gives you a list to choose from: empty for() loops, if then, try catch, iterate through a map’s keys or values, and many more. Of course, you can add your own.

JDeveloper’s editor also provides a history tab. Select it, and you’re given three “views” into the history of the files changes. One is a sort of mini timeline, the second a hierarchical tree view of the Java components that have been modified at each point in the timeline, and the third a familiar diff view of the source.

If you’re creating a GUI, then JDeveloper’s Swing builder is there to help. The JDeveloper website indicates that the NetBeans and JDeveloper teams have been working to share GUI development tools. It shows: JDeveloper’s Swing builder is virtually identical to the GUI builder in NetBeans. Choose a base form — JPanel, JFrame, JDialog, and so on — and you’re given a canvas onto which you can drop Swing controls. You can switch between the design view and the source view, and there’s a preview mode so that you can examine your GUI as it will appear when live. JDeveloper even has the GUI debugging snapshot feature described above in the NetBeans section.

Not surprising, JDeveloper’s database development tools are particularly strong. The database navigator provides a graphical management interface, and it supports plenty of databases out of the box: Oracle, DB2, Derby, MySQL, SQL Server, SQLite, and of course any database for which a JDBC driver exists.

If you prefer, you can construct databases graphically using JDeveloper’s Database Diagram tool. It’s not unlike building a GUI by dragging and dropping buttons, scrollbars, and such onto a canvas. The idea is the same, only you’re dragging database objects — tables, foreign keys, sequences, and relationships — onto a database canvas.

JDeveloper also supports Oracle’s “offline database” feature. This represents databases (and database objects) with XML-based definitions that let you work with database elements — to create tables, modify table structure, drop tables, and so on — without having to set up a live connection. You can do all of your management work without interfering with the ongoing operations of a live database. Once you have the setup you want, you reconcile the changes to the live database.

JDeveloper’s debugger has a Smart Data window. While the debugger’s data window shows all of the variables, static fields, and arguments in the current stack frame, the Smart Data window displays variables and fields pertinent to the code being executed. This saves you the chore of searching through what might be a long list of variables and objects to find the one you’re likely to be interested in at a specific point in the debugging process.

For debugging Web-based applications, JDeveloper’s HTTP analyzer understands how to peel apart HTTP and SOAP headers. Documentation provides guidelines for using the analyzer to debug RESTful Web services. You can even configure the Firefox Web browser to use the HTTP analyzer. This lets the Analyzer intercept traffic passing between your Web application client and the browser.

JDeveloper help and documentation

Much of the documentation for JDeveloper is online, and it is extensive to a fault. The section for all of the shortcut keys and their corresponding controls could keep you occupied for days. Meanwhile, when you’re getting started with the IDE, stop by the “Working with Oracle JDeveloper” section, which is filled with how-to entries. The Oracle Technology Network site at has links to tutorials, getting-started guides, and more.

JDeveloper lists heavily toward Java desktop and enterprise application development. Beyond using Groovy in the context of Oracle ADF (where Groovy is used for creating dynamic business logic code), JDeveloper has no support for Groovy … nor Scala nor Jython, for that matter. JDeveloper is a single-language IDE in that respect.

In addition, JDeveloper currently supports only Java EE 6 (the version currently supported by Oracle’s WebLogic application server). By comparison, NetBeans supports Java EE 7.

Nevertheless, JDeveloper is a solid Java development environment with good debugging and profiling. In particular, if your application is going to make heavy use of an RDBMS, JDeveloper’s database tools may fit your needs nicely.

IntelliJ IDEA

JetBrains’ IntelliJ IDEA, which first appeared in 2001, has distinguished itself as being on the forefront of innovative ideas for streamlining the development process. Version 14 was released in early November, and it fortifies an already powerful IDE with a number of new features. These include:

• A built-in Java decompiler. This is extremely useful when you’re working with a third-party library and you don’t have the source. (NetBeans and Eclipse have third-party decompiler plug-ins.)
• Improved support for Java 8. For example, the expression evaluator in the debugger can now handle lambda expressions.
• The “scratch files” feature. This lets you open what amounts to a temporary file — one that doesn’t become part of your project, but goes away when you close it. You can select what sort of code you’re writing in the scratch file — Java, JavaScript, HTML, and so on — and IDEA will provide all the coding assistance it provides in “normal” files. With a “scratch file,” you prototype on the fly, with all of IDEA’s coding capabilities available, and not “pollute” workspace.
• A JavaFX scene builder that runs in the IDE. In previous versions, you had to configure the IDE to start the scene builder as a separate process.

This latest version of IDEA also improves support for the Gradle and Maven build tools, as well as the Mercurial and Git version control systems. (IDEA already had support for Mercurial and CVS.) In addition, it supports current versions of the WildFly (formerly JBoss), TomEE, GlassFish, and tc Server application servers.

IDEA is available in two editions: the free Community edition and the paid-for Ultimate edition. Personal and academic licenses are available for the Ultimate edition. JetBrains also provides discounts for software startup companies. You can see a matrix of the differences between the two editions on the JetBrains website.

The Community edition supports Java, Groovy, Scala, and Clojure. With the help of a plug-in, IDEA supports Dart, a language with a C-like syntax that compiles to JavaScript and is meant to, ultimately, become JavaScript’s replacement in the Web browser. The Community edition also supports XML editing, as well as XSD (XML Schema Definition) and DTD (Document Type Definition).

Purchase the Ultimate edition, and you add support for HTML, CSS, and JavaScript, as well as SQL, Ruby, Python, and PHP. Again, a free plug-in is required to enable some languages. Unhappily, if you intend on doing Java EE development in IDEA, you’ll need the Ultimate edition, as only it provides support for servlets, JSP (JavaServer Pages), JSF, JPA and Hibernate, and frameworks like Grails and Rails.

As with the other IDEs, IDEA’s capabilities can be extended via numerous plug-ins. The entries in the JetBrains plug-in repository are scored (like an Amazon product). Examples include database navigators, plug-ins for Haskell language support, numerous Android extensions, extensions for Groovy, and even a plug-in that displays the current “Dilbert” cartoon. Some plug-ins are available only for the Ultimate edition, but even the Community edition has plenty of extensions to choose from.

Working with IntelliJ IDEA

Like the other IDEs, IntelliJ IDEA can build a wide variety of projects, including plain old Java SE applications, Java EE components, Spring applications, and Java FX applications. (The range available depends on the version you’re using; some project types are not available in the Community edition.) If you want to create mobile applications, IDEA supports J2ME and Android projects. (You need to download and install the Android SDK to build an Android project.) You can use IDEA’s build system, create a Gradle project, or request the IDE to generate an Ant build.

When entering source code with IDEA, you’ll find all the expected code completion tools. In fact, this is an area where IDEA really shines: The JetBrains engineers have added unique innovations that reduce the number of keys you have to type to produce a line of code. For example, IDEA’s “postfix completion” is a feature you’ll find nowhere else.

It works like this: While in the editor, you type, say, a variable name, then append to that name a postfix identifier preceded by a period (.). The editor will automatically rewrite that variable, wrapped in a Java expression. For example, if you type a reference to an object, then append the postfix expression with .null, the editor will rewrite the line to be an if statement of the form if (object == null), complete with curly braces and ready for the body of the if clause.

Database tools are an important adjunct to Java desktop and server application development, and IDEA provides a good collection of such tools. There’s a database browser, an SQL query editor (that supports code completion), and a table editor. Of course, IDEA supports all the primary RDBMSes, plus any database for which a JDBC driver is available. As in the source editor, IDEA provides plenty of handy shortcuts in the database tools. For example, rather than crafting a query to see what a foreign key in a particular database table references, you can simply select the key in the database browser and press Ctrl-Q, which opens a pop-up that displays the referenced data.

When you’re working with SQL code in the Java editor, IDEA is intelligent enough to provide code completion for the SQL (which is surprising, considering that as far as Java is concerned the SQL statements are merely strings). You can also select the dialect of SQL that you will use, which is helpful in catching differences between, say, DB2 and HSQLDB. Even better, if you’ve set up a connection to your database, you can test a query directly, and the IDE will prompt for those parameters that require values.

The one downside to all of this is the fact that the database tools are available in the Ultimate edition only.

IDEA has an apparently limitless array of tool windows, all designed to simplify otherwise tedious development chores. For example, the Code Inspection Tool window will examine code and identify problematic constructs, even misspellings. This is one of the many analysis tools available, which include module dependencies analysis and data flow analysis, where you can discover the source of data for a particular variable, possible values for a variable, and potential NullPointerException sources.

JetBrains has outfitted the IDEA debugger with useful innovations, too. Even if debug information is not available for a particular class or method, the debugger can deduce which local variable is allocated to which “slot” in the stack. This helps with tracking down issues when the execution flow might otherwise disappear into a library for which you don’t have the source. Even in cases where IDEA cannot know which variable is associated with a slot (such cases occur when a single slot is reused within the body of the method) it’s smart enough to tell you that the slot’s contents “might be this variable or that variable.”

Also, sometimes when you’re debugging, you’ll step into a single line that has multiple method calls, and you want to step into the second method that will be called, not the first. Press Shift-F7. You’re given a list of methods on the line, and you can choose which one to step into. This is called Smart Step-in, and it works with anonymous classes and Java 8’s lambda expressions.

IntelliJ IDEA help and documentation

While IDEA’s online documentation is quite good, once again the IDE’s inventiveness is apparent. For example, Find Action helps you quickly locate an operation in the IDE. Enter “open,” and IDEA will display all the actions that pertain to opening (or importing) in a list dialog. You can activate your chosen activity from the results list.

Then there’s IDEA’s Productivity Guide. On the one hand, this is a quick-reference card to productivity-enhancing features in the IDE. Click on a feature, and you’re shown a brief example of what that feature entails. But the guide also shows usage statistics — how many times you’ve used a particular feature in the IDE. Why is this good? Because it also shows you similar features. If you use a certain feature a lot, you can check related features you perhaps didn’t know about, examine them via the examples, and determine if the related features are better than the one you’ve been using so much.

IntelliJ’s IDEA Community edition is an excellent all-around Java IDE. If you do scripting work with Groovy, its Groovy support is particularly good. You also get support for Scala. In terms of usability, Community edition falls somewhere between NetBeans and Eclipse.

Opt for the Ultimate edition, and you have yourself a powerful development platform that includes the database tools, the support for J2EE and application servers, JPA and Hibernate support, editors for JavaScript, HTML, and CSS, and more.

IDEA’s true power is in its ever-expanding set of useful productivity enhancements. I’ve watched developers skilled in the use of IDEA fly through programming tasks in a fraction of the time those tasks would otherwise take. We can only hope that the other IDE engineering teams are studying IntelliJ’s features and incorporating their ideas — or, better yet, improving on them. In that way, all Java developers will benefit.

Choose your workbench

For reasons of space and time, much was not covered in this review. With the exception of JDeveloper, the other IDEs can serve as development platforms for multiple languages. Closer to home, all of the IDEs support — to one degree or another — Android and mobile device development. While Android does not support the Java SE or Java EE APIs, the language of Android is Java. Some of the IDEs provide profiling tools that let you home in on the performance bottlenecks of your application.

Beyond those issues, all of the IDEs in this review can be extended via plug-ins. New plug-ins mean new capabilities. As already stated, the number of plug-ins available for Eclipse alone would require several hundred Web pages of material simply to describe briefly.

It would be foolhardy to recommend one IDE above all of the others, partly because they all have common capabilities and partly because IDEs arouse the same sort of zealotry you’ll find when you argue about editors. For each of the IDEs in this review, I have encountered at least one engineer who has told me that they swear by it, and that engineer has presented a list of reasons why they do … and those reasons were all good ones.

Nevertheless, broad suggestions are possible. If you’re new to Java, then start with NetBeans or IntelliJ IDEA. NetBeans will take you further if you move into J2EE development. To develop J2EE applications with IDEA will require purchasing the Ultimate edition. However, you might decide that IDEA’s productivity enhancements are worth the cost.

If you need to work across technologies — database, JavaScript, XML, HTML, report generation — then Eclipse and its unending supply of add-ons might be your best bet. You’ll need to invest the time to learn “the Eclipse way,” but the range of capabilities you can commandeer from within a single IDE will be formidable. But beware the potential for chaos.

If you’re a J2EE developer who battles databases daily, JDeveloper might be the best choice to see you through the hard times. On a past project, I used JDeveloper to reverse-engineer a database that consisted of hundreds of tables and an unfathomable number of relationships. The database tools in JDeveloper allowed me to tame what would otherwise have been an insanity-inducing mess.

Finally, there is the liberating fact that these are all free tools (not counting IDEA’s Ultimate edition). That means the only obstacle standing between your project and the IDE that will bring it under control is a download and an installation.