Eclipse Shortcuts You Cannot Afford to Ignore

Immodest to name it after myself, but here goes:

Eclipse knows everything there is to know about your project, all your code, and all the libraries that are part of the app. You never need to type those long names! See the first shortcut below to see how to avoid breaking this important rule.

When you type the first few letters of a name…​ nothing happens. But when you activate that with CTRL/Space, Eclipse springs to life with a flurry of suggestions, which are, all the possible completions, with the most likely completions first (see for example After Typing "Sys"+CTRL/Space for System.out). If the first one is right, just hit Enter with your pinky finger and it’s done! If the second or third is right, just pinky the Down Arrow a few times and press Enter. If the one you want is way down, whoa! Still don’t use the mouse. Just type one or two more letters until you get the one you want at the top (I know, I said never type more than 3 or 4 letters, but this is an exception).

Big savings in neural energy (and mouse motion), and time!

BTW, I’ve seen people working on a line like

at which point they will laboriously select the type name with the mouse, then right click and select Copy from the menu, then right-click after the '=', select Paste, and type '();'. Wow! All they needed to do was to type CTRL/SPACE after typing the 'new', and Eclipse will provide the same type name for the assignment as is present in the declaration. Eclipse knows! Use its knowledge.

When you have typed the name of a class or instance, and type the "." to separate it from a method or field, just stop! After a split second, Eclipse will pop up a list of suggestions. Proceed as you did with CTRL/Space above and you’ll have that long name filled in by Eclipse in no time flat.

CTRL/1 is your friend when you and Eclipse see red. Eclipse spots all syntax errors including undefined references; most common errors are recognized by the "Quick Fix" mechanism and and be repaired in a jiffy with CTRL/1. As with CTRL/Space, there will often be multiple choices, which you can get to with the arrow key and press Enter when you reach the correct fix. If you don’t want to use Quick Fix, hit Escape to dismiss it.

Take the pledge now! "My name is (put your name here) and I will never, ever type out…​

again." Just type sysout (or even syso) and then - guess what? - CTRL/Space. Bingo - typing completed for you. Just finish up the expression to be printed.

There are numerous other templates; look in the Preferences window, under Java→Editor→Templates for a full list. If you click on one, you’ll see what it expands to in the Preview window. Macros use ${…​} substitution syntax.

In fact, while you’re on the Templates page, why not bake your own, for something you personally (or your team) use a lot. Suppose we use a lot of Logger objects, which we get in each class with a LogFactory. Click New, then fill in Logger for the name, some text like "Get a logger for this class" for the Description, and for the Preview, put something like this, depending on which of the (too many) Java Logging APIs you are using:

The result should look something like this, before you press OK:

Then to use it, just type log<CTRL/SPACE>, choose Logger (find the name in blue with your description beside it), and watch the full statment appear! If you made a mistake, no worries, just go back into the same Preferences pane as above, select your custom template, and click Edit. When done click Apply.

To share it with your team, go back into the Preferences pane, select your new template (or more than one), click Export, and save it where others can get it. They just use Import in the same place.

Never, ever type out public void setName(String name) { this.name = name; }. Nor, I might add, the corresponding getName(). Just create the field String name; and let Eclipse do the work! Source→Generate Getters and Setters, pick the fields you want getters and/or setters for (often just Select Getters (for immutable objects, else Select All), and click OK. Presto! Job done.

Similarly for hashCode() and equals(), constructors using fields, overrides, and even toString().

Note that if you don’t want to bulk up your code with these "boilerplate" methods, Lombok (https://projectlombok.org/) will generate them dynamically.

Better yet, Java 16+ record types will also automate generation of these methods. In fact, a record type will replace your immutable (read-only) data classes; you just write the class name and the list of properties (their one annoyance is that the getters don’t have get at the front, just the property name; this is simpler, but a step back from a decades-long tradtion in Java).

To open a file when you know its class name but don’t want to bother rummaging around in various directories to find it, just do CTRL/SHIFT/R (R for Resource) or T (for Type). Enter the first three characters in the name box that pops up, and follow the by-now usual rules for narrowing down the selection until you can press Enter.

Java source files can be hundreds or even thousands of lines long. Scrolling through them to find errors is a big time sink.

First, if you know the line number you want to reach, CTRL/L will let you jump directly to that line.

Look at the right margin of the editor window. If you see a little blue box, that is a TODO item (marked by TODO or XXX in the code). Just click on the little blue box and Eclipse will jump you there. If you see a little red box, that’s an error. Again, clicking on the red box will take you right to the line with the error. Ditto for yellow, which indicates a warning.

BTW, You should eliminate all warnings as you go, from the beginning of your project. Some warnings are useless and some warn of terrible times ahead for your code. It takes some judgement to know which is which, but at least make a stab at eliminating the warnings.

And speaking of scrolling, what about when you see a stack trace in the console, or an error in JUnit output (you do use JUnit religiously, don’t you?). When you see lines in either place that are underlined, just click on them, and you will miraculously jump to that part of the code in an editor window, even if the file wasn’t already open. Really neat!

Don’t sit around typing

(Unless it’s some form of job security by slowing down your typing). Just type the code that throws an exception, which will turn red, and use Quick Fix as above, and choose Surround with Multi-Catch. Job done! Well, almost. You have to use some intelligence to provide decent error handling, but that’s gist for another document.

There’s also "Add to surrounding multi-catch" if you add additional API calls with additional checked exception(s) inside an existing try.

To comment out lines of code, select them and press CTRL-Slash. To use a block comment, Shift/CTRL-Slash. It’s a toggle, so selecting commented-out lines of code and typing CTRL-Slash will uncomment them.

Hate that ring of ugly imports that grew like topsy and is in random order? Clean it up with CTRL/Shift/O for Organize Imports.

Note also that if you follow Ian’s Rule above, you rarely have to type import statements, because when Eclipse completes a type name that hasn’t yet been imported, it will add the import statement for free, and try to keep it in organized order if it can.

Eclipse is full of confirmation dialogs. The majority of these have a "Don’t Ask Again" type checkbox, with various wordings. Almost all of those are good to check the first time you see them, assuming that you know what you’re doing and don’t want to be bothered confirming that you meant what you said, every time.

The most important one is "Always save changed files before running", which you’ll see every single time you run a program in Eclipse, until you notice the little check box and check it when running an application.

Suppose you need everyone on your team to open the same set of GIT repositories for a new project. You could give them verbal instructions, but that’s error-prone. You could give them written (aka emailed) instructions to copy-and-paste the URLs, but that’s tedious for all concerned. Instead, you want to send them a PSF file. PSF stands for Project Set File, an XML format created by & for Eclipse for this purpose. Here’s how it works:

I can not claim to have a complete list of the shortcuts baked into Eclipse. I can say that they have saved me oodles of time, and I’d like them to work for you. If you’ve read this whole article, check out this free download of my Eclipse Shortcuts Poster. And while you’re at it, please buy a copy of my fine Java Cookbook.