Tips and Tricks (JDT)

The following tips and tricks give some helpful ideas for increasing your productivity. See also Eclipse
Platform Tips and Tricks for general Eclipse tips.

Editing   |   Refactoring   |   Navigation   |   Searching   |   Views   |   Miscellaneous   |   Debugging

Editing source

Content Content assist provides you with a list of suggested completions for partially
assist entered strings. In the Java editor press Ctrl+Space or use Edit > Content
Assist.

Content Content assist is also available in Javadoc comments.

assist in
Javadoc
comments

Content To get content assist proposals for static members configure your list of favorite
assist for static members on the Java > Editor > Content Assist > Favorites preference
static imports page.
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:

Suppress To exclude certain types from appearing in content assist, use the type filter
types in feature configured on the Java > Appearance > Type Filters preference page.
content assist Types matching one of these filter patterns will not appear in the Open Type
dialog and will not be available to content assist, quick fix and organize imports.
These filter patterns do not affect the Package Explorer and Type Hierarchy
views.

Content You can use content assist to speed up the creation of fields, method
assist for parameters and local variables. With the cursor positioned after the type name
variable, of the declaration, press Ctrl+Space or use Edit > Content Assist.
method
parameter
and field
name
completions
 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.

Content Code assist also works on accesses to types that are not imported yet.
assist for Depending on the Java > Editor > Content Assist > Add import instead of
variable with qualified name preference the editor will either automatically add imports or
unresolved fully qualify the types for such proposals.
type
Pressing ; in the following scenario:

results in:

Content Content Assist can propose members available on types used in instanceof
assist after conditions.
instanceof
condition
 Eclipse will add the required cast for you when you select such a proposal.

Parameter With the cursor in a method argument, you can see a list of parameter hints. In
hints the Java Editor press Ctrl+Shift+Space or invoke Edit > Content Assist >
Parameter Hints.

Content Content assist also provides help when creating an anonymous class. With the
assist on cursor positioned after the opening bracket of a class instance creation, press
anonymous Ctrl+Space or invoke Edit > Content Assist > Default.
classes

This will create the body of the anonymous inner class including all methods
that need to be implemented.

Toggle When content assist is invoked on an existing identifier, it can either replace the
between identifier with the chosen completion or do an insert. The default behavior
inserting and (overwrite or insert) is defined in the Java > Editor > Content Assist
replacing preference page.
content assist You can temporarily toggle the behavior while inside the content assist
selection dialog by pressing and holding the Ctrl key while selecting the
completion.

Incremental Content assist can also Insert common prefixes automatically, similar to
content assist Unix shell expansion. To enable that behavior, select the check box on the
Java > Editor > Content Assist preference page.

Camel case Code completion supports camel case patterns. For example, completing on
support in NPE or NuPoiE will propose NullPointerException. This support can be
code disabled using the Show camel case matches preference on the Java >
completion Editor > Content Assist preference page.

Customize Repeatedly invoking content assist (Ctrl+Space) cycles through different

content assist proposal categories.

To configure which categories to show use the Java > Editor > Content Assist
> Advanced preference page.
You can also assign separate key shortcuts to your favorite proposal
categories.
Create getters To create getter and setter methods for a field, select the field's declaration and
and setters invoke Source > Generate Getter and Setter.

If you use a name prefix or suffix be sure to specify this in the Java > Code
Style preference page.

Create getters A quick assist (Ctrl+1) is available on fields to create getters and setters.
and setters
quick assist

Use content Another way to create getters and setters is using content assist. Set the cursor
assist to in the type body between members and press Ctrl+Space to get the proposals
create getter that create a getter or setter method stub.
and setters

Delete getters When you delete a field from within a view, Eclipse can propose deleting its
and setters Getter and Setter methods. If you use a name prefix or suffix for fields, be sure
together with to specify this in the Java > Code Style preference page.
a field

Create To create a delegate method for a field select the field's declaration and invoke
delegate Source > Generate Delegate Methods. This adds the selected methods to the
methods type that contains a forward call to delegated methods. This is an example of a
delegate method:
Create To create the methods hashCode() and equals() invoke Source > Generate
hashCode() hashCode() and equals().
and equals()

Use Templates are shown together with the Content Assist (Ctrl+Space)
Templates to proposals.
create a There are existing templates, such as 'private_method', 'public_method',
method 'protected_method' and more, but you can also define new templates for
method stubs.
After applying a template, use the Tab key to navigate among the values to
enter (return type, name and arguments).

Use On projects which have the SWT library on the classpath, you can create SWT
Templates to widgets with Content Assist (Ctrl+Space)
create SWT
To add, for example, an SWT button, type Button and press Ctrl+Space, select
widgets
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....

Create your To create your own templates, go to the Java > Editor > Templates
own preference page and press the New button to create a template. For example,
templates a template to iterate backwards in an array would look like this:

Use Quick Fix Start with the method invocation and use Quick Fix (Ctrl+1) to create the
to create a method.
new method

Use Quick Fix Add an argument to a method invocation at a call site. Then use Quick Fix
to change a (Ctrl+1) to add the required parameter in the method declaration.
method
signature

Use Content At the location where you want to add the new constructor, use content assist
Assist to after typing the first letters of the constructor name.
create a
constructor
stub
Create new Do you need to create new fields to store the arguments passed in the
fields from constructor? Use Quick Assist (Ctrl+1) on a parameter to create the
parameters assignment and the field declaration and let Eclipse propose a name according
to your Code Style preferences.

Use Content Invoke Content Assist (Ctrl+Space) in the type body at the location where the
Assist to method should be added. Content assist will offer all methods that can be
override a overridden. A method body for the chosen method will be created.
method

Use Quick Fix To implement a new interface, add the 'implements' declaration first to the type.
to add Even without saving or building, the Java editor will underline the type to signal
unimplement that methods are missing and will show the Quick Fix light bulb. Click on the
ed methods light bulb or press Ctrl+1 (Edit > Quick Fix) to choose between adding the
unimplemented methods or making your class abstract.

Use Clean Up When you add a new method to an interface or an abstract method to an
to add abstract class, Eclipse can generate method stubs in all concrete subclasses at
unimplement once. Invoke Source > Clean Up... on a set of Java elements, use a custom
ed methods profile, and select on the Configure... dialog to Add unimplemented methods
on the Missing Code tab.

Override a To create a method that overrides a method from a base class:

method from Select the type where the methods should be added and invoke Source >
a base class Override/Implement Methods. This opens a dialog that lets you choose which
methods to override.
Create a type You can paste a snippet of code containing a Java type directly into a package
from an or source folder to create a new compilation unit. For example, select and copy
example this source code:
snippet package pack;
public class HelloWorld {
public static void main(String[] args) {
System.out.println("Hello World");
}
}
Then select a source folder in the Package Explorer and use Ctrl+V (Edit >
Paste). This automatically creates a new package 'pack' and file
'HelloWorld.java' with the copied content.
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.

Rename in To quickly do a rename that doesn't require full analysis of dependencies in

file other files, use the 'Rename in file' Quick Assist. In the Java Editor, position the
cursor in an identifier of a variable, method or type and press Ctrl+1 (Edit >
Quick Fix)
The editor is switched to the linked edit mode (like templates) and changing the
identifier simultaneously changes all other references to that variable, method
or type.

You can also use the direct shortcut Ctrl+2 R. Use the General > Keys
 preference page to configure shortcuts (in the 'Source' category).

Use Quick Fix Dealing with thrown exceptions is easy. Unhandled exceptions are detected
to handle while typing and marked with a red line in the editor.
exceptions  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

At any time, you can convert a catch block to a thrown exception. Use Ctrl+1
(Edit > Quick Fix) on a catch block.

Less typing Instead of typing an assignment, start with the expression that will be assigned.
for
assignments

Now use Ctrl+1 (Edit > Quick Fix) and choose 'Assign statement to new
local variable' and Quick Assist will guess a variable name for you.
Less work Don't spend too much time with typing casts. Ignore them first and use quick
with cast assist to add them after finishing the statement.
expressions
For example on assignments:

Or for method arguments:

Or for method call targets:

Assign a After an 'instanceof' check, it is very common to cast the expression and assign
casted it to a new local variable. Invoke Quick Assist (Ctrl+1) on the 'instanceof'
expression keyword to save yourself some typing:

More quick Check out the quick assist page for a complete list of available code
assists transformations. Amongst them are
 Invert if statements
 Convert 'switch' into 'if-else'
 Replace 'if-else' with conditional
...and many more
A list of quick fixes can be found here.

Shortcuts for Some of the popular quick assists like Rename in file and Assign to local
Quick Fixes variable can be invoked directly with Ctrl+2 R and Ctrl+2 L. Check the
and Assists General > Keys preference page for more quick fixes and quick assists that
support direct invocation.
Type "Quick Assist" or "Quick Fix" in the filter field:
Surround To surround statements with an if / while / for statement or a block, select the
lines lines to surround and invoke Source > Surround With or press Alt+Shift+Z.

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.
Templates can be configured on the Java > Editor > Templates preference
page. Edit the corresponding templates to customize the resulting code or
define your own surround-with templates.

Content You can have content assist insert argument names automatically on method
assist can completion. This behavior can be customized on the Java > Editor > Content
insert Assist preference page (see the Fill method arguments and show guessed
argument arguments checkbox.) For example, when you select the second entry here,
names
automatically
 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.

Automatically Enabling Fill method arguments and show guessed arguments on the
insert type Java > Editor > Content Assist preference page is also useful when working with
arguments parameterized types in J2SE 5.0.

results in:

Remove To remove a surrounding statement or block, position the cursor at the opening
surrounding or closing bracket and press Ctrl+1 (Edit > Quick Fix).
statement

How was that You can enable spell-checking support in the Java editor on the General >
word spelled Editors > Text Editors > Spelling preference page. Spelling errors are displayed
again? in the Java editor and corresponding Quick Fixes are 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.

Structured The Structured Selection actions can be used to enlarge the current selection
selections to the next enclosing element:
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.

Find the To find a matching bracket select an opening or closing bracket and press
matching Ctrl+Shift+P or select Navigate > Go To > Matching Bracket. You can also
bracket double click before an opening or after a closing bracket - this selects the text
between the two brackets.

Smart Type '/**' and press Enter. This automatically adds a Javadoc comment stub
Javadoc containing the standard @param, @return and @exception tags.

The templates for the new comment can be configured in the Java > Code
Style > Code Templates preference page.

Use the local Whenever you edit a file, its previous contents are kept in the local history. Java
history to tooling makes the local history available for Java elements, so you can revert
revert back to back to a previous edition of a single method instead of the full file.
a previous
Select an element (e.g. in the Outline view) and use Replace With > Local
edition of a
History to revert back to a previous edition of the element.
method
Use the local Whenever you edit a file, its previous contents are kept in the local history. Java
history to tooling makes the local history available for Java elements, so you can restore
restore deleted methods selectively.
removed
Select a container (e.g. in the Outline view) and use Restore from Local
methods
History to restore any removed members.

Customizable The Java > Code Style > Code Templates preference page allows you to
code customize generated code and comments in a similar way to normal templates.
generation These code templates are used whenever code is generated.
 Since 3.1, it is possible to use project specific Code templates, that will also be
shared in the team if your project is shared. Open the Properties on a project
to enable project specific settings.

Create Comments can be added explicitly with Source > Generate Element
comments in Comment (Alt+Shift+J) or automatically by various wizards, refactorings or
your code quick fixes.
Configure the comment templates on the Java > Code Style > Code Templates
preference page.
Enable or disable the automatic generation of comments either directly on the
wizard (e.g. using 'Generate Comment' checkbox on the new Java type
wizards) or by the 'Automatically add new comments for new methods and
types' checkbox of the Java > Code Style > Code Templates preference page.
All these settings can also be configured on a per project basis. Open the
Properties on a project to enable project specific settings.

Sort members You can Sort Members of a Java compilation unit or a set of compilation units
according to a category order defined in the Java > Appearance > Members
Sort Order preference page.
You'll find the action under Source > Sort Members.

Wrap strings You can have String literals wrapped when you edit them. For example, if you
have code like this:
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.
Smart Typing The Java editor's Smart Typing features ease your daily work. You can
and how to configure them on the Java > Editor > Typing preference page.
control it

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.

Fix your code A useful feature is Source > Correct Indentation or Ctrl+I.
indentation Select the code where the indents are incorrect and invoke the action.
with one key
If nothing is selected, the action indents the current line.
stroke

Fix your code Eclipse can correct the indentation of your code when you save the editor. Go
indentation to the Java > Editor > Save Actions preference page and Configure...
on save Additional actions, and select to Correct indentation on the Code
Organizing tab.

Quick menus The refactoring and source actions can be accessed via a quick menu. Select
for source the element to be manipulated in the Java editor or in a Java view and press
and Alt+Shift+S for the quick source menu, Alt+Shift+T for the quick refactoring
refactoring menu and Alt+Shift+Z for the surround with menu.
actions

Find unused The Java compiler detects unreachable code, unused variables, parameters,
code imports and unused private types, methods and fields. Change the settings for
the detection on the Java > Compiler > Error/Warnings preference page.
These settings can also be specified per project, use: Project > Properties >
Java Compiler > Error/Warnings.
 These problems are detected as you type, and a quick fix is offered to remove
the unneeded code. You can also use Source > Clean Up... to remove unused
code.

Find The compiler can help you find problems with null in your code. The Java >
problems Compiler > Errors/Warnings preference page has three options to detect
with null problems:
 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:
Change When a problem hover has been enriched (by pressing F2 or moving the
problem mouse into the hover), an action to change the severity of the current problem
severity in is available.
problem
hover

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

Javadoc The Eclipse Java compiler can process Javadoc comments. Search reports
comment references in doc comments, and refactoring updates these references as well.
handling This feature is controlled from the Java > Compiler > Javadoc preference
page (or set for an individual project using Project > Properties > Java
Compiler > Javadoc).

When turned on, malformed Javadoc comments are marked in the Java editor
and can be fixed using Edit > Quick Fix (Ctrl+1):
Suppress In J2SE 5.0 and later, you can suppress all optional compiler warnings using
warnings the SuppressWarnings annotation.
In this example, addAll() is marked as an unused method. Quick Fix (Ctrl+1)
is used to add a SuppressWarnings annotation so that the warning will not be
shown for this method.

Clean Ups Source > Clean Up... helps fixing multiple problems at once and helps to
establish a consistent code style. For instance, you can:
 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.

Refactoring

Scripting of Most of the refactorings offered by JDT can not only be executed
refactorings interactively, but also by a refactoring script.

Create a refactoring script from the refactoring history using Refactor >
Create Script....
 A refactoring script can then be applied later on an arbitrary workspace using
Refactor > Apply Script....

Such refactoring scripts can be used in different scenarios such as automatic

fixing of breaking API changes between software layers or providing patches
with rich semantics.

Safe JAR file When exporting a JAR file from the workspace, the JAR Export Wizard offers
migration the option to include refactoring information into the JAR file.

Use File > Export... and select JAR file. On the first page of the JAR Export
Wizard, select Export refactorings for checked projects. Click on the link
to select the refactorings to include.

Clients are then able to migrate an old version of the JAR file to a new one
using the Refactor > Migrate JAR File... refactoring. This refactoring
automatically updates all code which is dependent on the old version of the
JAR file to use the new version of the JAR file.

Searching

Locate You can locate variables and see their read/write status by selecting an
variables and identifier (variable, method or type reference or declaration) and invoking
their read/write Search > Occurrences in File > Identifier. This marks all references of this
access identifier in the same file. The results are also shown in the search view with
different colors for read or write access, along with icons showing the
variable's read or write access.

Alternatively, use the Mark Occurrences feature to dynamically highlight

occurrences. You can search over several files by using the general search
features (Search > References).

Search for To search for methods with a specific return type, use "* <return type>" as
methods with a follows:
specific return  Open the search dialog and click on the Java Search tab.
type
 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.

Filter search By default, Java Search finds references inside Java code and Javadoc. If
matches in you don't want to see the references inside Javadoc, you can filter these
Javadoc matches by enabling 'Filter Javadoc' in the view menu (triangle symbol) of the
search view.

Filter potential Potential matches occur when a compile-time problem prevents the search
search engine from completely resolving the match. Filter these matches with Filter
matches Potential in the search view menu (triangle symbol).

Trace method Use the Call Hierarchy to follow long or complex call chains without losing the
call chains with original context: Just select a method and invoke Navigate > Open Call
the Call Hierarchy (Ctrl+Alt+H).
Hierarchy

Code navigation and reading

Open on a There are two ways that you can open an element from a reference in the Java
selection in editor.
the Java  Select the reference in the code and press F3 (Navigate > Open
editor Declaration)
 Hold Ctrl, move the mouse pointer over the reference, and click the
hyperlink
 The hyperlink style navigation can be configured with the Support hyperlink
style navigation checkbox in the General > Editors > Text Editors
preference page.

In-place Press Ctrl+F3 in the Java editor to pop up an in-place outline of the element at
outlines the current cursor position. Or press Ctrl+O (Navigate > Quick Outline) to pop
up an in-place outline of the current source file.

In-place Press Ctrl+O or Ctrl+F3 again to add inherited members to an open In-place
outlines outline. Inherited members have a gray label. Filter and sort the outline with the
show menu in the upper right corner.
inherited
members

In-place Find out which are the possible receivers of a virtual call using the Quick Type
hierarchy Hierarchy. Place the cursor inside the method call and press Ctrl+T
(Navigate > Quick Type Hierarchy). The view shows all types that implement
the method with a full icon.
 Press Enter to open the corresponding method in an editor. Press Ctrl+T again
to switch to the Supertype hierarchy.

Java Editor The Java Editor contains a breadcrumb navigation bar which shows the path to
Breadcrumb the element at the cursor position. The breadcrumb can be enabled via the
Toggle Breadcrumb tool bar button or by pressing Alt+Shift+B.

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.

Advanced The Java editor can highlight source code according to its semantics (for
highlighting example: static fields, local variables, static method invocations). Have a look at
the various options on the Java > Editor > Syntax Coloring preference page.
Initially You can specify which regions are folded by default when an editor is opened.
folded Have a look at the Java > Editor > Folding preference page to customize this.
regions

Mark When working in the editor, turn on Mark Occurrences in the toolbar ( ) or
occurrences press Alt+Shift+O. You'll see within a file, where a variable, method or type is
referenced.

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.

Go to next / To quickly navigate to the next or previous method or field, use

previous Ctrl+Shift+Arrow Up (Navigate > Go To > Previous Member) or
method Ctrl+Shift+Arrow Down (Navigate > Go To > Next Member)

Control your Use the Next / Previous Annotation toolbar buttons or Navigate > Next
navigation Annotation (Ctrl+.) and Navigate > Previous Annotation (Ctrl+,) to navigate
between between annotations in a Java source file. With the button drop-down menus,
annotations you can configure on which annotations you want to stop:

Reminders in When you tag a comment in Java source code with "TODO" the Java compiler
your Java automatically creates a corresponding task as a reminder. Opening the task
code navigates you back to the "TODO" in the code. Use the Java > Compiler >
Task Tags preference page to configure any other special tags (like "FIXME")
that you'd like to track in the task list.
Tricks in the The Open Type dialog (Navigate > Open Type or toolbar button) helps you
Open Type navigate to a type by its name.
dialog  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.

Make hovers You can open the text from a hover in a scrollable window by pressing F2 (Edit
sticky > Show Tooltip Description) or by moving your mouse pointer into the hover.
You can select and copy content from this window, invoke actions, or follow
links.
 You can configure how to enrich the hover on the General > Editors > Text
Editors preference page.

Hovers in the You can see different hovers in the Java editor by using the modifier keys (Shift,
Java editor Ctrl, Alt).
When you move the mouse over an identifier in the Java editor, by default a
hover with the Javadoc extracted from the corresponding source of this element
is shown. Holding down the Ctrl key shows you the source code.

You can change this behavior and define the hovers for other modifier keys in
the Java > Editor > Hovers preference page.

Generic You can use hover to show the inferred signature of a generic method.
method
inferred
signature

Open and If you want to open the Javadoc documentation for a type, method or field with
configure Shift+F2 (Navigate > Open External Javadoc), you first have to specify the
 external documentation locations to the elements parent library (JAR, class folder) or
Javadoc project (source folder).
documentatio For libraries, open the build path page (Project > Properties > Java Build
n Path), go to the Libraries, and expand the node of the library where you can
edit the 'Javadoc location' node. The documentation can be local on your file
system in a folder or archive, or on a web server.

For types, methods or fields in source folders, go to the (Project > Properties >
Javadoc Location).

Java views

Organizing Use Top Level Elements > Working Sets in the Package Explorer's view
workspace with menu to enable a new mode that shows working sets as top level elements.
many projects This mode makes it much easier to manage workspaces containing lots of
projects.
 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.
Working sets can also be rearranged directly in the Package Explorer using
drag and drop and copy/paste.

Assign working To assign an element to a different working set, select the element in the
sets Package Explorer and choose Assign Working Sets... from the context
menu.
Declaration view The Declaration view ( Window > Show View > Other... > Java >
Declaration) shows the source of the element selected in the Java editor or
in a Java view.

Javadoc view The Javadoc view ( Window > Show View > Other... > Java > Javadoc)
shows the Javadoc of the element selected in the Java editor or in a Java
view.
Type hierarchy To find out which types in a hierarchy override a method, use the 'Show
view and method Members in Hierarchy' feature.
implementations   Select the method to look at and press F4 (Navigate > Open Type
/ definitions Hierarchy). This opens the type hierarchy view on the method's
declaring type.
 With the method selected in the Hierarchy view, press the 'Lock
View and Show Members in Hierarchy' tool bar button.
 The hierarchy view now shows only types that implement or define
the 'locked' method. You can for example see that isEmpty() is
defined in List and implemented in ArrayList and Vector but
not in AbstractList.

Type hierarchy The type hierarchy method view lets you sort the selected type's methods
view supports by its defining types. For example, for AbstractList you can see that it
grouping by contains methods that were defined in Object, Collection and List:
defining type
Tricks in the type  Focus the type hierarchy on a new type by pressing F4 (Navigate >
hierarchy 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.

Structural A structural comparison of Java source ignores the textual order of Java
compare of Java elements like methods and fields and shows more clearly which elements
source were changed, added, or removed.
For initiating a structural comparison of Java files you have two options:
 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.
 You can even ignore formatting changes when performing the structural
compare: turn on the Ignore Whitespace option via the Compare Editor's
toolbar button, or a compare viewer's context menu.

Structural A structural comparison of Java property files (extension: .properties)

compare of ignores the textual order of properties and shows which properties were
property files changed, added, or removed.
For initiating a structural comparison of property files you have two options:
 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.
Hierarchical vs. An option on the Java Packages (and Package Explorer) view menu allows
flat presentation you to change the way packages are displayed. Package Presentation >
of packages Hierarchical displays packages in a tree, with sub-packages below
packages; Package Presentation > Flat displays them in the standard
arrangement, as a flat list with all packages and sub-packages as siblings.

Logical The Java Packages view (Java Browsing perspective) coalesces packages
packages of the same name across source folders within a project. The screenshot
shows the Packages view containing a logical package.
Compress If your package names are very long, you can configure a compressed
package names name that appears in the viewers. Configuration of the compression pattern
is done in the Java > Appearance preference page.

Using this example, packages are rendered the following way:

Manipulating the Instead of manipulating the Java Build path on Project > Properties > Java
Java build path Build Path, use the actions in the Package Explorer's context menu.
directly in the You can for example add new source folders, archives and libraries to the
Package build path or in- and exclude file and folders from a source folder.
Explorer

Grouping Java Configure the Problems view to group Java problems into categories with
problems Group by > Java Problem Type in the view menu.
 You can control if a configurable error is intended to be fatal or not at the
bottom of the Java > Compiler > Errors/Warnings preference page.

Java type Enable the Java Type Indicator on the General > Appearance > Label
indicator Decoration preference page to find out what the first type in a compilation
unit or class file is. An adornment is shown for interfaces, annotations, and
enums, while an ordinary class stays undecorated.

Miscellaneous

Project All code style and compiler options can be defined per project.
specific Open the project property pages with Project > Properties on a project or use
preferences the link on the workspace preferences (e.g. the Java > Code Style preference
page) to open a project property page and enable project specific settings.
 The project specific settings are stored in a configuration file inside the project
(in the '.settings' folder). When you share a project in a team, team members will
also get these project specific settings.

Access rules Access rules give you the possibility to enforce API rules for types from
referenced libraries. On the Java build path page (Project > Properties > Java
Build Path) edit the 'Access Rules' node available on referenced projects,
archives, class folders and libraries.
Packages or types in these references can be classified as:
 Accessible
 Discouraged
 Forbidden
According to the settings on the Java > Compiler > Errors/Warnings
preference page, the compiler will mark discouraged and forbidden references
with warning or errors.
JUnit Select a JUnit test method in a view and choose Run > JUnit Test from the
context menu or Run > Run As > JUnit Test from the main menu. This creates
a launch configuration to run the selected test.

Hide JUnit You can configure the JUnit view to only open when there are errors or failures.
view until To do so enable Activate on Errors/Failures only in the JUnit view menu. That
errors or way, you can have the view set as a fast view and never look at it when there
failures are no failing tests. While there are no problems in your tests you will see this
occur icon (the number of small green squares will grow, indicating progress) while
running them and this icon after they are finished. If, however, errors or
failures occur, the icon will change to (or if tests are finished) and the JUnit
view will appear.

Content Content Assist (Ctrl+Space) is also available in input fields of various Java
assist in dialogs. Look for a small light bulb icon beside the field when it has focus.
dialog fields

Smart caret Text fields for editing Java names support smart caret positioning. Use Ctrl+Left
positioning and Ctrl+Right to stop at camel case boundaries inside a name. Use
in dialogs Ctrl+Shift+Left and Ctrl+Shift+Right to extend the selection in small steps.
showing Use Ctrl+Delete to delete the next and Ctrl+Backspace to delete the previous
Java names part of a name.

Ctrl+Right:

Ctrl+Shift+Right
:

write "Equal":

Ctrl+Delete:

write "To":
Define You can configure the prefix or suffix for fields, static fields, parameters, and
prefixes or local variables. These settings on the Java > Code Style preference page are
suffixes for used in content assist, quick fix, and refactoring whenever a variable name is
fields, computed.
parameters
and local
variables

Organize You can invoke Source > Organize Imports on sets of compilation units,
Imports packages, source folders or Java projects.
works on
more than
single files

Organize Eclipse can automatically organize imports whenever you save an editor. This
imports on feature can be enabled globally on the Java > Editor > Save Actions
save preference page. The save actions can also be configured per project, which
makes it easy to enforce a project-wide standard by sharing the settings across
a team:
 Besides organizing imports, save actions can also format code and perform
other clean ups.

Format Select multiple Java files to format and choose Source > Format to format them
selection all. The format action is also available on packages, source folders or Java
projects.
In the Java Editor, Source > Format (Ctrl+Shift+F) formats just the selected
region. If nothing is selected, the whole file gets formatted.

Use a When creating new projects, the JRE that is added by default is the one selected
specific JRE in the Java > Installed JREs preference page. To set a project specific JRE,
for a 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 the default JRE, a project
specific JRE or an Execution Environment to add to new projects.
Select When you create a Java project that you want to share with a team, it is a good
execution idea to use an execution environment instead of a specific JRE.
environment
Execution environments are symbolic representations of JREs with standardized
when
entries like 'J2SE-1.4', 'J2SE-1.5'. That means no file system path will go into the
creating
shared build path.
Java project
JREs can be assigned to the environments on the Java > Installed JREs >
Execution Environments preference page.

Use drag Drag and Drop is a handy replacement of Edit > Cut and Edit > Paste
and drop respective Edit > Copy and Edit > Paste. Hold down the Ctrl key down while
dragging to change from move to copy.
 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

Propagating The Java compiler can be configured to diagnose deprecation using options on
deprecation the Java > Compiler > Errors/Warnings preference page.
tag

Using this configuration, the result is:

If you're unable to fix a usage of a deprecated construct, we recommend that

you tag the enclosing method, field or type as deprecated. This way, you
acknowledge that you did override a deprecated construct, and the deprecation
flag is propagated to further dependents.

Recovering In the rare event of a dysfunction, JDT could reveal some inconsistencies such
from as:
abnormal  missing results in a Java Search or Open Type
inconsistenc
ies  invalid items in package explorer
 To bring JDT into a consistent state again, the following actions need to be
performed in this exact order:
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...)

Debugging

What's new For more debugging tips and tricks see what's new in the platform and What's
New in 3.4 (JDT Debug)

Launching You can run and debug Java applications from the context menu. You can launch
from the a source file, package, method, type, etc. by choosing Run As (or Debug As) >
Context Java Application from the context menu in a view or editor. Alternatively, you
Menu 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.

Evaluations
Snippet evaluation is available from a number of places in the debugger.
in the
Choosing Display or Inspect from the context menu of the editor or Variables
debugger
view will show the result in a pop-up whose result can be sent to the Display or
Expressions views.
View The Debug view automatically manages debug related views based on the view
Managemen selection (displaying Java views for Java stack frames and C views for C stack
t in Non- frames, for example). By default, this automatic view management only occurs in
Debug the Debug perspective, but you can enable it for other perspectives via the View
perspective Management preference page available from the Debug view toolbar pull down.
s

Environmen You can specify the environment used to launch Java applications via the
t Variables Environment tab.
String Variables are supported for many parameters of Java Application launch
Substitution configurations. Most fields that support variables have a Variables... button next
s 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 The Logical Structures toggle on the Variables view toolbar presents alternate
Structures 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 If you specify the same arguments to a certain VM frequently, you can configure
Arguments Default VM Arguments in the Installed JREs preference page. This is more
convenient than specifying them for each launch configuration.

Stop in Main You can use Stop in main in a Java Application launch configuration to cause
your program to stop at the first executable line of the main method when you run
it under debug mode.

Conditional You can use conditional breakpoints in Breakpoint Properties... to control when
breakpoints a breakpoint actually halts execution. You can specify whether you want the
breakpoint to suspend execution only when the condition is true, or when the
condition value changes.
Disabling If you find yourself frequently adding and removing a breakpoint in the same
breakpoints place, consider disabling the breakpoint when you don't need it and enabling it
when needed again. This can be done using Disable Breakpoint in the
breakpoint context menu or by unchecking the breakpoint in the Breakpoints
view.
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.

Changing When a thread is suspended in the debugger, you can change the values of Java
variable primitives and Strings in the Variables view. From the variable's context menu,
values choose Change Variable Value. You can also change the value by typing a new
value into the Details pane and using the Assign Value action in the context
menu (CTRL+S key binding).
Variable When a thread is suspended and the cursor is placed over a variable in the Java
values in editor, the value of that variable is displayed as hover help.
hover help

Drop to When stepping through your code, you might occasionally step too far, or step
Frame over a line you meant to step into. Rather than restarting your debug session,
you can use the Drop to Frame action to quickly go back to the beginning of a
method. Select the stack frame corresponding to the Java method you wish to
restart, and select Drop to Frame from Debug view toolbar or the stack frame's
context menu. The current instruction pointer will be reset to the first executable
statement in the method. This works for non-top stack frames as well.
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.

Hot code The debugger supports Hot Code Replace when debugging with a 1.4 or higher
replace VM, or the J9 VM. This lets you make changes to code you are currently
debugging. Note that some changes such as new or deleted methods, class
variables or inner classes cannot be hot swapped, depending on the support
provided by a particular VM.
Stepping The Java debugger allows you to step into a single method within a series of
into chained or nested method calls. Simply highlight the method you wish to step into
selections and select Step into Selection from the Java editor context menu.
and
This feature works in places other than the currently executing line. Try
hyperlink
debugging to a breakpoint and step into a method a few lines below the current
debugging
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).

Console pin Output displayed in the console can be locked to a specific process via the Pin
and lock Console action in the Console view toolbar. There's also a Scroll Lock action
that stops the console from scrolling as new output is appended.

Creating A watch item is an expression in the Expressions view whose value is updated
watch items as you debug. You can create watch items from the Java editor by selecting an
expression or variable and choosing Watch from its context menu or the top-level
Run menu.

Watch A watch point is a breakpoint that suspends execution whenever a specified field
points is accessed or modified. To set a watchpoint, select a field in the Outline view
and choose Toggle Watchpoint from its context menu. To configure a
watchpoint, select the watchpoint in the Breakpoints view and choose
Properties... from its context menu. The most important properties for this type
of breakpoint are the Access and Modification checkboxes which control when
the breakpoint can suspend execution.
Threads and The Java debugger optionally displays monitor information in the Debug view.
Monitors Use the Show Monitors action in the Debug view drop down menu to show
which threads are holding locks and which are waiting to acquire locks. Threads
involved in a deadlock are rendered in red.

Step filters Step filters prevent the debugger from suspending in specified classes and
packages when stepping into code. Step filters are established with the Java >
Debug > Step Filtering preference page. When the Use Step Filters toggle (on
the debug toolbar and menu) is on, step filters are applied to all step actions. In
the Debug view, the selected stack frame's package or declaring type can be
quickly added to the list of filters by selecting Filter Type or Filter Package from
the stack frame's context menu.
Using the If you want to experiment with API or test out a new algorithm, it's frequently
scrapbook easier to use a Java scrapbook page than create a new class. A scrapbook page
is a container for random snippets of code that you can execute at any time
without a context. To create a scrapbook page, create a new file with a .jpage
extension (or use the New Scrapbook Page wizard). Enter whatever code you
wish to execute and then select it. There are three ways to execute your 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.

Editing Holding down the Ctrl key and making a selection from the Run or Debug drop-
launch down menu opens the associated launch configuration for editing. The launch
configuratio configuration can also be opened from the context menu associated with any
ns item in the Debug view.

Favorite Launch configurations appear in the Run/Debug drop-down menus in most

launch recently launched order. However it is possible to force a launch configuration to
configuratio always appear at the top of the drop-downs by making the configuration a
ns 'favorite'. Use the Organize Favorites... action from the appropriate drop down
menu to configure your favorite launch configurations.

Detail In the Variables & Expressions views, the detail pane shows an expanded
formatters representation of the currently selected variable. By default, this expanded
representation is the result of calling toString() on the selected object, but you
can create a custom detail formatter that will be used instead by choosing New
Detail Formatter from the variable's context menu. This detail formatter will be
used for all objects of the same type. You can view and edit all detail formatters
in the Java > Debug > Detail Formatters preference page.
Running You can run and debug code that did not compile cleanly. The only difference
code with between running code with and without compile errors is that if a line of code with
compile a compile error is executed, one of two things will happen:
errors  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.

Word wrap The details area of the debugger's Variables and Expressions views supports
in Variables word wrap, available from the view drop-down menu.
view
Code assist Code assist is available in many contexts beyond writing code in the Java editor:
in the  When entering a breakpoint condition
debugger
 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

Command You can always see the exact command line used to launch a program in run or
line details debug mode by selecting Properties from the context menu of a process or
debug target, even if the launch has terminated.
Stack trace Java stack traces in the console appear with hyperlinks. When you place the
hyperlinks mouse over a line in a stack trace the pointer changes to the hand. Pressing the
mouse button opens the associated Java source file and positions the cursor at
the corresponding line. Pressing the mouse button on the exception name at the
top of the stack trace will create an exception breakpoint.