Currently, import statements, comments, types and method bodies can be folded. Whether folding should be enabled on new editors can be configured on the Folding tab on the Java > Editor preference page:

JDT UI provides an extension point to extend the set of available foldings.

There are also new options for highlighting operators and brackets, and Italic is a newly supported style.

Repeat CTRL+T to toggle between the normal type hierarchy and the supertype hierarchy view.

Likewise for Quick Structure (Ctrl+F3).

In Smart Insert mode, the editor provides Java-specific extras which can be configured on the Java > Editor > Typing preference tab. The Smart Semicolon and Smart Opening Brace options for example move the caret to the end of the line before inserting the semicolon or closing brace, respectively.

The Java code formatter has many improvements to offer: The Java > Code style > Code Formatter preference page lets you choose from existing profiles, define your own, and share them with others.

The new formatter is highly configurable, with over 140 options covering everything from brace positions to wrap lines up to Javadoc comment formatting.

Optionally, you can make the dictionary available to the content assist. However, there is currently no dictionary included in Eclipse. The required format is just a list of words separated by new line characters and the Quick Fixes allow you to add new words to the dictionary on-the-fly. Contributions of dictionaries would be welcome.

When the selected element changes, the marked occurrences are automatically updated. By default, marked occurrences are sticky, i.e. remain highlighted even when there is no valid Java element at the current caret position.

Placing the cursor on the return type of a method highlights all method exit points. Highlighting exit points can be enabled via the preference Java > Editor > Mark Occurrences.

• Create new method
• Create new field, parameter or local variable
• Add new argument
• Assign statement to new local or field

Example of argument guessing:

Example of exception guessing:

• variables, to split and join its variable declaration
• an 'if' statement, to convert its body into a block or to add a new 'else' block
• a method parameter, to assign it to a new field
• a method declaration. to create the method in a supertype

The Source > Add Constructors from Superclass command now pops up a dialog so that you can choose which of the superclass's constructors should be inserted into the current class. The quick assist feature can still be used to insert without prompting.

Pop-ups for inspect/display

Logical Structure

System thread filter

System threads are now filtered out from the Debug View by default. The Show System Threads command in the view's drop-down menu toggles the filter on/off.

Step Into Selection on any line

Class prepare breakpoints

Exception breakpoint hyperlinks

Breakpoints in external source

Refactorings update breakpoints and launch configurations

Restart option when hot code replace fails

Default VM arguments can be associated with a JRE

The refactoring and source commands can be accessed via a quick menu. Select the element to be manipulated in the Java editor or in a Java view and press Alt+Shift+S for the quick source menu or Alt+Shift+T for the quick refactor menu.

The Rename dialog has been simplified as a consequence:

The old option Update references in Javadoc comments has been folded into Update references. The old options Update references in regular comments and Update references in string literals have been merged into Update textual matches in comments and strings.

The wizard shows the supertype hierarchy for the variable. Selecting one of the available types updates the declaration.

A static factory method is created that calls the now-private constructor, and all calls to the given constructor are replaced with calls to the new factory method.

• renames parameters in overriding methods as well,
• updates references in javadocs
• offers Content Assist (Ctrl+Space) in the parameter type column,
• allows to change the method name,
• allows to change thrown exceptions.

Furthermore, editing in the parameters table has been streamlined such that you can use standard navigation keys (Tab, Shift+Tab, Arrow Up & Down). Editing can be started by clicking into a cell, or pressing F2 or Enter.

For Java code contained in an anonymous, local, or non-static member type, the Extract Method refactoring now allows the new method to be created in an outer type.

Extract method finds duplicate code fragments

Extract method now finds duplicate code fragments and helps extracting them into the new method as well. For example, when extracting the expression foo(a) + bar(b) from the snippet:

the resulting code is:

The set of types that show up in code assist and quick fix proposals can now be filtered using the new Java > Type Filters preference page. Types matching one of these filter patterns on the list will not show up in the Open Type dialog, and will not be available in quick fix and code assist proposals. These filters do not affect whether the types show up in the Package Explorer and Type Hierarchy views.

Use Navigate > Open External Javadoc (Shift+F2) to open Javadoc in a browser.

The Type Hierarchy view now supports filtering by a working set. Once a working set is selected in the view menu, the hierarchy view only shows Java types contained in the given working set, extended by parent types needed to complete the tree (the latter are shown with white-filled images).

• rename pre-existing keys and values
• rename multiple key prefixes simultaneously
• change already externalized strings to 'ignored' or to the original, untagged (internalized) state or vice versa
• improved inserting of new keys in the property files

Similarly to class path variable entries, the class path entry for a user library references user libraries by name (not to the JARs to the local file system).

Indirect access to static members is a compatibility issue for generated class file. For class files compatible with JDK versions prior to 1.2, the compiler resolves indirect static references to the declaring class (Y in the example); for class files compatible with JDK versions since 1.2, the compiler resolves static references to the type of the receiver (X in the example).

This option supports a coding style where all references to instance fields are qualified in order to make them visibly distinct from references to local variables.

Note that a given method can always declare to throw fewer checked exceptions than declared in the superclass (or interface).

Unnecessary declaration of thrown exception:

 Unqualified access to instance field:

Unnecessary cast:

The setUpTest method is automatically used when a test is about to be  executed individually (including re-running a failed test). The result returned by setUpTest is run instead of the given test, with the common use being to wrap the given test with special set-up or tear-down.