Review: The big 4 Java IDEs compared

How Eclipse, NetBeans, JDeveloper, and IntelliJ IDEA stack up in capabilities and ease of use


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 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.

Eclipse Luna

In the Eclipse Java perspective, you can view not only the logical structure of Java packages and classes, you can also use the “call hierarchy” view all the locations in your project that call a specific method.

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.


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.

1 2 3 Page 1
Page 1 of 3
Bing’s AI chatbot came to work for me. I had to fire it.
Shop Tech Products at Amazon