For example, if you have added java.util.Arrays.* to this list, then all static methods of this type matching the completion prefix will be added to the proposals list:

If you use a name prefix or suffix for fields, local variables or method parameters, be sure to specify this in the Java > Code Style preference page.

Pressing ; in the following scenario:

results in:

Eclipse will add the required cast for you when you select such a proposal.

This also works if you place the caret after the opening parentheses of a class instance creation:

You can also assign separate key shortcuts to your favorite proposal categories.

After applying a template, use the Tab key to navigate among the values to enter (return type, name and arguments).

To add, for example, an SWT button, type Button and press Ctrl+Space, select the Button SWT template, and press Enter.

To see all available templates go to the Java > Editor > Templates preference page or open the Templates view through Window > Show View > Other....

• Click on the light bulb or press Ctrl+1 to surround the call with a try catch block. If you want to include more statements in the try block, select the statements and use Source > Surround With > Try/catch Block. You can also select individual statements by using Edit > Expand Selection To and selecting Enclosing, Next or Previous.
• If the call is already surrounded with a try block, Quick Fix will suggest adding the catch block to the existing block.
• If you don't want to handle the exception, let Quick Fix add a new thrown exception to the enclosing method declaration

For example on assignments:

Or for method arguments:

Or for method call targets:

The entries in the menu are derived from the normal editor templates: All templates that contain the variable ${line_selection} will show up in the menu.

Type "Quick Assist" or "Quick Fix" in the filter field:

content assist will automatically insert argument names:

You can then use the Tab key to navigate between the inserted names.

If you choose Insert best guessed arguments, the best guess will be filled in by default. The alternative proposals are still available.

You can make the dictionary also available to the content assist. A Quick Fix allows you to add new words to the user dictionary on the fly.

Highlight some text and press Alt+Shift+Arrow Up or select Edit > Expand Selection To > Enclosing Element from the menu bar - the selection will be expanded to the smallest Java-syntax element that contains the selection. You can then further expand the selection by invoking the action again (or other actions from the Expand Selection To menu).

This is for example helpful to select the enclosing identifier for renames, or the select adjacent statements for a subsequent Extract Method refactoring.

Select an element (e.g. in the Outline view) and use Replace With > Local History to revert back to a previous edition of the element.

Select a container (e.g. in the Outline view) and use Restore from Local History to restore any removed members.

String message= "This is a very long message.";

position your caret after the word "very" and press Enter. The code will be automatically changed to:

String message= "This is a very" + 
           " long message.";

This behavior can be customized in the Java > Editor > Typing preference page.

When you enable Automatically insert Semicolons at correct position, typing a semicolon automatically positions the cursor at the end of the statement before inserting the semicolon. This safes you some additional cursor navigation.
You can undo this automatic positioning by pressing backspace right afterwards.

If nothing is selected, the action indents the current line.

• Null pointer access (in 'Potential programming problems')
  When this option is enabled, the compiler will issue an error or warning whenever a variable that is statically known to hold a null value is used to access a field or method, as shown in the example below:

  

  
  
• Potential null pointer access (in 'Potential programming problems')
  When this option is enabled, the compiler will issue an error or a warning whenever a variable is statically known to potentially hold a null value, as shown in the example below:

  

  
  
• Redundant null check (in 'Unnecessary code')
  When enabled, the compiler will issue an error or a warning whenever a variable that is statically known to hold a null or a non-null value is tested against null, as shown in the examples below:

  

  
  

  

Click on the button in the toolbar to go to the Java > Compiler > Errors/Warnings preference page.

• convert all for loops to enhanced for loops where possible.
• mark all overriding methods in a whole project with an @Override annotation.
• organize imports
• format your code
• remove unnecessary code

Clean Ups are organized in Clean Up profiles. A profile can be attached to the workspace or to individual projects. Project settings can be shared in a team through a version control system. It is also possible to export and import each profile.

Clean Ups can be executed as save actions on save. Go to the Java > Editor > Save Actions preference page to configure which clean ups to invoke on save.

Alternatively, use the Mark Occurrences feature to dynamically highlight occurrences. You can search over several files by using the general search features (Search > References).

• Open the search dialog and click on the Java Search tab.
• Type '*' and the return type, separated by a space, in the Search string.
• Select the Case sensitive checkbox.
• Select Method and Declarations and then click Search.

Methods from anonymous classes or special types like Runnable are by default expanded with constructors, since it is often more interesting to see where the object is created than where the method is invoked. Expand with Constructors from the context menu toggles this behavior. The defaults can be configured in the view menu.

• Select the reference in the code and press F3 (Navigate > Open Declaration)
• Hold Ctrl, move the mouse pointer over the reference, and click the hyperlink

Holding Ctrl on an overridable method shows a popup with an Open Implementation entry, which directly opens the implementation in case there's only one, or shows all the concrete implementations for that method in the hierarchy of its declaring type, using the quick type hierarchy.

Press Enter to open the corresponding method in an editor. Press Ctrl+T again to switch to the Supertype hierarchy.

Each element in the breadcrumb can be selected and actions can be invoked through a context menu or keyboard short cuts. Furthermore the breadcrumb lets you navigate to other elements via drop-downs.

Different colors are used to mark read and write accesses.

Selecting a return type shows you the method's exit points. Select an exception to see where it is thrown. Select a super class or interface to see the methods override or implement a method from the selected super type.

Fine tune 'mark occurrences' on the Java > Editor > Mark Occurrences preference page.
Change the color for to marker on the General > Editors > Text Editors > Annotations preference page.

To show occurrences in the Search view, use the Search > Occurrences feature.

• To find types quickly, only type the capital letters of the type name:
  IOOBE finds IndexOutOfBoundsException.
  Or type the first few characters of each name part:
  NuPoiE finds NullPointerException.
• To see all types ending with a given suffix, e.g. all Tests, use *Test< to not see all types containing Test somewhere else in the type name.
• To open multiple types at once, select them in the list and click OK.

You can configure how to enrich the hover on the General > Editors > Text Editors preference page.

Use Configure Working Sets... from the Package Explorer's view menu to configure which working sets get shown. The dialog lets you create new Java working sets, define which working sets are shown and in what order. If Sort Working Sets is not enabled, working sets can also be rearranged directly in the Package Explorer using drag and drop.

1. Select the method to look at and press F4 (Navigate > Open Type Hierarchy). This opens the type Hierarchy view on the method's declaring type.
2. With the method selected in the Hierarchy view, press the 'Lock View and Show Members in Hierarchy' tool bar button.

• Focus the type hierarchy on a new type by pressing F4 (Navigate > Open Type Hierarchy) on an element or a selected name.
• You can open the Hierarchy view not only on types but also on packages, source folders, JAR archives and Java projects.
• You can Drag & Drop an element onto the Hierarchy view to focus on that element.
• You can change the orientation (from the default vertical to horizontal) of the Hierarchy view from the view's toolbar menu.

• Select two Java compilation units and choose Compare With > Each Other from the view's context menu. If the files have differences, they are opened into a Compare Editor. The top pane shows the differing Java elements; double clicking on one of them shows the source of the element in the bottom pane.
• In any context where a file comparison is involved (e.g. a CVS Synchronization) a double click on a Java file not only shows the content of the file in a text compare viewer, but it also performs a structural compare and opens a new pane showing the results.

• Select two files in the Package Explorer or Navigator and choose Compare With > Each Other from the view's context menu.
• In any context where a file comparison is involved (e.g. a CVS Synchronization) a double click on a property file not only shows the content of the file in a text compare viewer, but it also performs a structural compare and opens a new pane showing the results.

package pack;
public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello World");
    }
}

You can also paste a method or a set of statements; Eclipse will create the required enclosing elements for you.

If you paste while nothing is selected in the Package Explorer, Eclipse even creates a new Java Project and create the *.java file there. Furthermore, the clipboard can also contain multiple package and type declarations, in which case Eclipse will create all the necessary packages and *.java files on paste.

• Accessible
• Discouraged
• Forbidden

Besides organizing imports, save actions can also format code and perform other clean ups.

In the Java Editor, Source > Format (Ctrl+Shift+F) formats just the selected region. If nothing is selected, the whole file gets formatted.

Execution environments are symbolic representations of JREs with standardized entries like 'J2SE-1.4', 'J2SE-1.5'. That means no file system path will go into the shared build path.

JREs can be assigned to the environments on the Java > Installed JREs > Execution Environments preference page.

To set a project specific JRE of an existing project, open the project's Java Build path property page (Project > Properties > Java Build Path), then the Libraries page, select 'JRE System Library' and press Edit. In the 'Edit Library' dialog you can select either an Execution Environment, a project specific JRE, or the workspace default JRE.

Important to know:

• If you move Java compilation units between packages by Drag & Drop, this will behave like a refactoring move - all missing imports will be added and references updated
• If you drag and drop source elements like types or methods, this will only copy or move the corresponding source code - no references will be updated

• missing results in a Java Search or Open Type
• invalid items in Package Explorer

1. Close all projects using navigator Close Project menu action
2. Exit and restart Eclipse
3. Open all projects using navigator Open Project menu action
4. Manually trigger a clean build of entire workspace (Project > Clean...)

Launching from the context menu

You can run and debug Java applications from the context menu. You can launch a source file, package, method, type, etc. by choosing Run As (or Debug As) > Java Application from the context menu in a view or editor. Alternatively, you can use the Java application launch shortcut key binding (Alt+Shift+D, J). The top level Run As (or Debug As) actions are also sensitive to the current selection or active editor.

Snippet evaluation is available from a number of places in the debugger. Choosing Display or Inspect from the context menu of the editor or Variables view will show the result in a pop-up whose result can be sent to the Display or Expressions views.

View management in non-Debug perspectives

The Debug view automatically manages debug related views based on the view selection (displaying Java views for Java stack frames and C views for C stack frames, for example). By default, this automatic view management only occurs in the Debug perspective, but you can enable it for other perspectives via the View Management preference page available from the Debug view toolbar pull down.

Environment variables

You can specify the environment used to launch Java applications via the Environment tab.

String substitutions

Variables are supported for many parameters of Java Application launch configurations. Most fields that support variables have a Variables... button next to them, such as the program and VM arguments fields. The Main Type field supports variables as well; the ${java_type_name} variable allows you to create a configuration that will run the selected type.

Logical structures

The Logical Structures toggle on the Variables view toolbar presents alternate structures for common types. JDT provides logical views for Maps, Collections, and SWT Composites. You can define logical structures for other types from the Logical Structures preference page.

Default VM arguments

If you specify the same arguments to a certain VM frequently, you can configure Default VM Arguments in the Installed JREs preference page. This is more convenient than specifying them for each launch configuration.

You can also temporarily disable all breakpoints using the Skip All Breakpoints action in the Breakpoints view toolbar. This will tell the debugger to skip all breakpoints while maintaining their current enabled state.

Note that Drop to frame is only available when debugging with a 1.4 or higher VM, or the J9 VM. There are some situations where a JVM may be unable to pop the desired frames from the stack. For example, it is generally impossible to drop to the bottom frame of the stack or to any frame below a native method.

This feature works in places other than the currently executing line. Try debugging to a breakpoint and step into a method a few lines below the current instruction pointer.

You can also step into a method by using hyperlink navigation. Simply place the cursor over the method you wish to step into and use Ctrl+Alt+Click to step into the method (rather than Ctrl+Click which will navigate to the source code).

• Execute the selected code and place the returned result in an inspect popup
• Execute the selected code and place the String result right in the scrapbook page

  

• Execute the selected code (and ignore any returned result)

These actions are in the workbench toolbar and also in the scrapbook page's context menu.

• If the 'Suspend execution on compilation errors' preference on the Java > Debug preference page is set and you are debugging, the debug session will suspend as if a breakpoint had been hit. Note that if your VM supports Hot Code Replace, you could then fix the compilation error and resume debugging
• Otherwise, execution will terminate with a 'unresolved compilation' error

It is important to emphasize that as long as your execution path avoids lines of code with compile errors, you can run and debug just as you normally do.

• When entering a breakpoint condition
• In the Details pane of the Variables & Expressions view
• When entering a Detail Formatter code snippet
• When entering a Logical Structure code snippet
• When entering code in a Scrapbook page
• In the Display view

Ensure the preference to activate the debug view when a breakpoint is hit is turned on (via the top level Run/Debug preference page).

You can disable the perspective switching prompt on the Run/Debug > Perspectives preference page. With these settings the Debug view will automatically open in the Java perspective when a breakpoint is hit.

By placing the Debug view at the top of the perspective and resizing it's height to the size of one element, the view will switch to a bread crumb presentation. This minimizes the amount of screen space the view consumes.