As it currently stands, this question is not a good fit for our Q&A format. We expect answers to be supported by facts, references, or expertise, but this question will likely solicit debate, arguments, polling, or extended discussion. If you feel that this question can be improved and possibly reopened, visit the help center for guidance.
Closed 11 years ago.
Locked. This question and its answers are locked because the question is off-topic but has historical significance. It is not currently accepting new answers or interactions.
Alright it can be a lame question, but everybody uses these things differently. What's some of the best time savers out there for this IDE.
Tom
Don't forget Ctrl+Shift+L, which displays a list of all the keyboard shortcut combinations (just in case you forget any of those listed here).
Ctrl-2 something
Seems that nobody mentioned Ctrl-2 L (assign to new local variable) and Ctrl-2 F (assign to a new field), these ones have changed how I write code.
Previously, I was typing, say (| is cursor location):
Display display = new |
and then I pushed Ctrl-Space to complete the constructor call. Now I type:
new Display()|
and press Ctrl-2 L, which results in:
Display display = new Display()|
This really speeds things up. (Ctrl-2 F does the same, but assigns to a new field rather than a new variable.)
Another good shortcut is Ctrl-2 R: rename in file. It is much faster than rename refactoring (Alt-Shift-R) when renaming things like local variables.
Actually I went to Keys customization preference page and assigned all sorts of additional quick fixes to Ctrl-2-something. For example I now press Ctrl-2 J to split/join variable declaration, Ctrl-2 C to extract an inner class into top-level, Ctrl-2 T to add throws declaration to the function, etc. There are tons of assignable quick fixes, go pick your favourite ones and assign them to Ctrl-2 shortcuts.
Templates
Another favourite of mine in my “npe” template, defined as:
if (${arg:localVar} == null)
throw new ${exception:link(NullPointerException,IllegalArgumentException)}("${arg:localVar} is null");
This allows me to quickly add null argument checks at the start of every function (especially ones that merely save the argument into a field or add it into a collection, especially constructors), which is great for detecting bugs early.
See more useful templates at www.tarantsov.com/eclipse/templates/. I won't list them all here because there are many, and because I often add new ones.
Completion
A few code completion tricks:
camel case support mentioned in another answer: type cTM, get currentTimeMillis
default constructor: in the class declaration with no default constructor push Ctrl-Space, the first choice will be to create one
overloading: in the class declaration start typing name of a method you can overload, Ctrl-Space, pick one
getter/setter creation: type “get”, Ctrl-Space, choose a getter to create; same with “is” and “set”
Assign To A New Field
This is how I add fields.
If you have no constructors yet, add one. (Ctrl-Space anywhere in a class declaration, pick the first proposal.)
Add an argument (| is cursor position):
public class MyClass {
public MyClass(int something|) {
}
}
Press Ctrl-1, choose “assign to a new field”. You get:
public class MyClass {
private final Object something;
public MyClass(Object something) {
this.something = something;
}
}
Add a null-pointer check if appropriate (see “npe” template above):
public class MyClass {
private final Object something;
public MyClass(Object something) {
npe|
this.something = something;
}
}
Hit Ctrl-Space, get:
public class MyClass {
private final Object something;
public MyClass(Object something) {
if (something == null)
throw new NullPointerException("something is null");
this.something = something;
}
}
A great time saver!
ctrl-shift-r and its buddy, ctrl-shift-t, to open a resource or type, respectively. Resources includes all files in your open projects (including non-java files), and types includes java types either in your projects, or in a library included in the projects.
Crtl+1 is my favorite. The quick fixes for the red-squiggles.
It is also located in the Edit Menu -> Quick Fix.
Ctrl+Shift+O to organize imports, which will format them nicely, remove unneeded imports, and add missing imports.
Ctrl-J starts an incremental find.
Hit Ctrl-J, then start typing. Use up/down to find previous/next instances of what you typed.
Ctrl-Shift-J searches backwards.
Type 'syso' then press Ctrl+Space to expand it to System.out.println().
Tres handy.
CTRL+3 brings up a type-ahead list of any menu command.
CTRL-SHIFT-g : finds usages of the method or field under the cursor, absolutely necessary for understanding code
CTRL-F6 : navigate between the list of open editor windows, if you just type it once and let go you toggle back to the previous editor window, doing this successively is a nice way to jump back and forth
CTRL-t : on a class or method will show you the type hierarchy, very useful for finding implementations of an interface method for example
Clicking on the return type in a method's declaration highlights all exit points of the method.
for instance:
1: public void foo()
2: {
3: somecode();
4: if ( blah ) return;
5:
6: bar();
7: }
clicking on void will highlight the return on line 4 and the close } on line 7.
Update: It even works for try{} catch blocks. If you put cursor on exception in the catch block and eclipse will highlight the probable methods which may throw that exception.
Code completion supports CamelCase, e.g., typing CWAR will show a result for ClassWithAReallyLongName. Start using this feature and you'll never type another long classname again.
(parts copied from another answer because i think answers w/ just one hint/tip are best for polling)
Alt-Up Arrow moves the current selection up a line, Alt-Down Arrow moves it down. I also use Alt-Shift-Up/Down Arrow all the time. Ctrl-K and Ctrl-Shift-K is quite handy, finding next/previous occurrence of the current selection (or the last Find, if nothing is selected).
There's an option to place the opening curly brace and a semicolon automagically in the "correct" position. You'll have to enable this - Choose Window/Preferences and type "brace" in the searchbox - should be easily findable (no eclipse on this computer). The effect:
Typing a semicolon anywhere on the line will place it at this lines end (as in word/openoffice: Backspace if you'd like to have it in the original place)
Typing an opening curly brace when you're just inside another pair of braces will place it at the end of this line - as in this example
("|" is the cursor):
if(i==0|)
typing "{" now will result in
if(i==0) {|
Hippie expand/Word Complete, afaik inspired by Emacs: will autocomplete any word in any editor based on other words in that file. Autocomplete inside String literals in Java code, in xml files, everywhere.
Alt + /
Alt-Shift-R stands for rename, not refactor. Refactoring is a more general term (as defined by the book).
Nevertheless, it is one of my favorite refactorings. Others include:
Alt-Shift-M: Extract Method (when a code block or an expression is selected)
Alt-Shift-L: Extract Local Variable (when an expression is selected)
Extract Local Variable is especially useful when I don't remember (or bother to type) the result type of a method. Assuming you have a method JdbcTemplate createJdbcTemplate() in your class, write some code such as this:
void someQuery() {
createJdbcTemplate()
}
Select the expression createJdbcTemplate(), click Alt-Shift-L, type the name of variable and press enter.
void someQuery() {
JdbcTemplate myTemplate = createJdbcTemplate();
}
CTRL + D - to delete current line
Absolutely, Ctrl+Q to go to last edit location.
It is very useful just after being interrupted by phone, boss or others.
Ctrl + Shift + M: changes a static method or static attribute reference of a class to a static import.
Before
import X;
...
X.callSomething();
After
import static X.callSomething;
...
callSomething();
Alt+Shift+Up Arrow does escalating selection. Alt+Shift+Down does the opposite.
Alt+Up or Alt+Down to move lines
Nobody's mentioned the best one yet. Click on a class or method name and press Ctrl+T.
You get a quick type hierarchy. For a class name you see the entire class hierarchy. For a method name you get the hierarchy showing superclasses and subclasses, with implementations of that method distinguished from abstract mentions, or classes that don't mention the method.
This is huge when you are at an abstract method declaration and quickly want to see where it is implemented.
F3 has been my favorite, opens the definition for the selected item.
Ctrl+Shift+R has an interesting feature, you can use just the uppercase camel letters from a class when searching (such as typing CWAR will show a result for ClassWithAReallyLongName).
Alt+Shift+W > Package Explorer makes life easier when browsing large projects.
A non-keyboard shortcut trick is to use commit sets in your Team->Synchronise view to organise your changes before committing.
Set a change set to be the default, and all changes you make on files will be put in that set, making it easy to see what you have changed while working on a specific defect/feature, and other changes you had while testing etc.
CTRL+SPACE, for anything, anywhere.
Generate getters and setters.
Create Constructors using Fields
Extract Method...
Refactor->Rename
CTRL+O for the quick outline. CTRL+O+CTRL+O for the inherited outline.
F4 to display a type hierarchy
Open Call Hierarchy to display where a method is called from.
CTRL+SHIFT+T to open a Java Type
CTRL+SHIFT+R to open any resource.
ALT + left or right to go forward or backwards through edit places in your documents (easy navigation)
Override/Implement methods if you know you're going to do a lot of methods (otherwise, CTRL+SPACE is better for one at a time selection.
Refactor->Extract Interface
Refactor->Pull up
Refactor->Push down
CTRL+SHIFT+O for organize imports (when typing the general class name such as Map, pressing CTRL+SPACE and then selecting the appropriate class will import it directly for you).
CTRL+SHIFT+F for formatting (although Eclipse's built in formatter can be a little braindead for long lines of code)
EDIT: Oh yeah, some debugging:
F5: Step into (show me the details!)
F6: Step over (I believe you, on to the next part...)
F7: Step out (I thought I cared about this method, but it turns out I don't, get me out of here!)
F8: Resume (go until the next breakpoint is reached)
CTRL+SHIFT+I: inspect an expression. CTRL+SHIFT+I+CTRL+SHIFT+I: create a watch expression on the inspected expression.
Conditional breakpoints: Right click a breakpoint and you may set a condition that occurs which triggers its breaking the execution of the program (context assist, with Ctrl+Space, is available here!)
F11 - Debug last launched (application)
CTRL+F11 - Run last launched (application)
Breakpoint on Exception
Eclipse let you set breakpoints based on where an Exception occurs.
You access the option via the "j!" alt text http://help.eclipse.org/stable/topic/org.eclipse.jdt.doc.user/images/org.eclipse.jdt.debug.ui/elcl16/exc_catch.png icon in the debugging window.
alt text http://blogs.bytecode.com.au/glen/2007/04/06/images/2007/AddExceptionWindow.png
The official help topic "Add Java Exception Breakpoint " has more on this.
The Uncaught Exception option is to suspend execution when an exception of the same type as the breakpoint is thrown in an uncaught location.
The Caught Exception option is to suspend execution when an exception of the same type as the breakpoint is thrown in a caught location.
do not forget the Exception Breakpoint Suspend on Subclass of this Exception:
to suspend execution when subclasses of the exception type are encountered.
For example, if an exception breakpoint for RuntimeException is configured to suspend on subclasses, it will also be triggered by a NullPointerException.
alt text http://help.eclipse.org/stable/topic/org.eclipse.jdt.doc.user/reference/breakpoints/images/ref-breakpoint_suspendsubclass.PNG
Ctrl+Alt+H on a method to get the call hierarchy for it. Fast way to see where it is called from.
Ctrl+Alt+UP or Ctrl+Alt+DOWN to copy lines
Alt + Shift + R to refactor and rename.
Here is my collection of the most useful keyboard shortcuts for Eclipse 3:
Eclipse 3 Favorite Keyboard Shortcuts.
by -=MaGGuS=-
Navigate:
• Ctrl + Shift + L – Shows useful keyboard shortcuts in popup window
• Ctrl + H – Search.
• Ctrl + K – Goes to next search match in a single file. Shift + Ctrl + K – goes to previous match.
• F3 - Goes to ‘declaration’ of something. Same as Ctrl + Click.
• Ctrl + Shift + G - Use this on a method name or variable. It will search for references in the code (all the code) to that item.
• Ctrl + O – Shows outline view of the current class or interface.
• Ctrl + T – Shows class hierarchy of the current class or interface. F4 – shows the same in separate tab.
• Ctrl + Shift + T - Open Type. Search for any type globally in the workspace.
• Ctrl + Shift + R – Open Resource. Search for any file inside workspace.
• Ctrl + J – Incremental search. Similar to the search in firefox. It shows you results as you type. Shift + Ctrl +J - Reverse incremental search.
• Ctrl + Q – Goes to the last edit location.
• Ctrl + Left|Right – Go Back/Forward in history.
• Ctrl + L – Go to line number.
• Ctrl + E – This will give you a list of all the source code windows that are currently open. You can arrow up or down on the items to go to a tab.
• Ctrl +PgUp|PgDown – Cycles through editor tabs.
• Ctrl + Shift + Up|Down - Bounces you up and down through the methods in the source code.
• Ctrl + F7 – Switches between panes (views).
• Ctrl + ,|. – Go to the previous/next error. Great in combination with Ctrl + 1.
• Ctrl + 1 on an error – Brings up suggestions for fixing the error. The suggestions can be clicked.
• Ctrl + F4 – Close one source window.
Edit:
• Ctrl + Space – Auto-completion.
• Ctrl + / – Toggle comment selected lines.
• Ctrl + Shift + /|\ – Block comment/uncomment selected lines.
• Ctrl + Shift + F – Quickly ‘formats’ your java code based on your preferences set up under Window –> Preferences.
• Ctrl + I – Correct indentations.
• Alt + Up|Down – move the highlighted code up/down one line. If nothing is selected, selects the current line.
• Ctrl + D – Delete row.
• Alt + Shift + Up|Down|Left|Right – select increasing semantic units.
• Ctrl + Shift + O – Organize Imports.
• Alt + Shift + S – Brings up “Source” menu.
o Shift + Alt + S, R – Generate getter/setter.
o Shift + Alt + S, O – Generate constructor using fields.
o Shift + Alt + S, C – Generate constructor from superclass.
• Alt + Shift + T – Brings up “Refactor” menu.
• Alt + Shift + J – Insert javadoc comment.
• F2 – Display javadoc popup for current item. Shift + F2 – Display javadoc in external browser.
Run/Debug:
• F11 / Ctrl + F11 – Execute/debug.
• Ctrl + Shift +B – Toggle breakpoint.
• When paused: F5 – Step into, F6 – Step over, F7 – Step out, F8 – Resume.
• Ctrl + F2 – Terminate.
EOF
Not so Hidden but IMO the best Trick.
Assuming Default Settings (and you have'nt added new snippets)
Highlight (or select) a Text (String or Variable)...Press Ctrl+Space. Hit End+Enter.
the "sysout" snippet is triggered which wraps the selection around as its parameter.
eg.
"hello world!"
becomes
System.out.println("hello world!");
I love it so much that i've implemented a similar snippet for Android's Toast and Log.i()
HUGE Time saver during Manual Debugging....
Related
When I am writing anonymous classes, I want my anonymous class to look like:
SaleTodayOnly sale = new SaleTodayOnly() // line 1
{ // line 2
some implementation
}
But when I hit enter after line 1, Eclipse will automatically position my cursor at | on line 2:
SaleTodayOnly sale = new SaleTodayOnly() // line 1
| // line 2
some implementation
And when I backspace my way to the front and write {, Eclipse will reposition this { to:
SaleTodayOnly sale = new SaleTodayOnly() // line 1
{ // line 2
some implementation
How can I set my own indentation preferences (for this specific scenario only)?
edit: I have my anonymous class set to next line. It's probably a wrapping issue.
edit2: I give up. I'll just use java conventions of { on the same line as the anonymous class declaration...
edit3: after hunting around the Preference window, toggling without much effect + seeing how Format produces the right output whereas the problem described still persists -- I'd agree that this is probably a bug and I will file a report when I have time.
Go into your preferences. (Window -> Preferences, probably; on mac it'll be under the leftmost menu option ('Eclipse')) - in the filter type 'formatter' to find the entry Java > Code Style > Formatter.
The behaviour you are witnessing is non-standard so you must already have a format defined; you picked this indent behavior, or somebody did who set this as default formatter.
edit this format. Alternatively, check if your project has a custom formatting rule in which case, this same answer applies, but instead go via your project's properties and update the formatting rules there.
The specific rule you are looking for is Brace positions, Anonymous class declaration. You have this set to Next line indented. Set it to something else. It sounds like you want Next line (not indented).
I have this:
Arrays.asList(from(A, 14), from(A, 21), ...
What I need is:
Arrays.asList(of(from(A, 14), 1), of(from(A, 21), 2), ...
The call from(A, number) should be turned into of(from(A, number), anotherNumber).
In other words: I have to update a lengthy list of such from() calls by enclosing them within an of() and adding a second parameter. Ideally, that second parameter would simply count upwards.
Is there a way to that with IntelliJ refactoring tools?
( instead of doing it all manually )
And note: I am not asking for a tools recommendation. I am asking whether a known tool supports a specific refactoring situation.
You can highlight from( and use the "select next occurrence" hot key. Once you have selected all occurrences just replace it with of(from. Once you are done adding of you can use the "alt + left arrow key" to move the cursor to the position where you want to add the number OR use the "select next occurrence" by highlighting the ),.
On Mac the hot key is "CTRL + G" and on Windows\Linux "ALT + J". Here is a list of the hot keys https://resources.jetbrains.com/storage/products/intellij-idea/docs/IntelliJIDEA_ReferenceCard.pdf
It is still a bit manual, but beats doing it one by one.
You can try the following:
Extract method with replacing the duplicates for from(A, param)
Inside the extracted method write something like of(from(A, param), NNN)
Inline method
Replace NNN with numbers you need (this has to be performed manually)
If there is some formula that can calculate anotherNumber based on number, you can use it instead of NNN.
"Replace structurally" can do some of what you need.
Select Edit > Find > Replace Structurally...
Enter from($a$, $b$) as the search template
Enter of(from($a$, $b$), i) as the replacement template
Choose Scope: Current File (or Selection, if you prefer)
Hit Find
Hit Replace all
Assuming i is undefined you'll then be left with lots of errors. You can cycle through the errors with F2 and replace the undefined i with the values you want.
Bonus tip: on a Mac, run seq 1 100 | pbcopy at a terminal to put the numbers 1-100 into your clipboard. Then, with multiple cursors in IntelliJ, hit Paste. 1 will be pasted at the first cursor, 2 at the second, etc.
I usually use python/php but currently writing an Android app so playing with java at the moment.
I can't figure out why the following piece of my code doesn't work.
It's meant to take a long representing the time the last check occurred (last_check) and add a predefined number of minutes to it (CHECK_INTERVAL) which is currently set to 1 minute.
Log.i(this.toString(), "Last check: " + Long.toString(last_check));
long add_to_check = CHECK_INTERVAL * 60 * 1000;
long next = last_check + add_to_check;
Log.i(this.toString(), "Add to check: " + Long.toString(add_to_check));
Log.i(this.toString(), "Next check: " + Long.toString(next));
scheduleNextRun(next);
My expectation is that the first log will show the last_check time, the second log will show 60000 and the third log will show the sum of those two.
However, I am getting the same value for the first log and the third log - it's like my addition isn't working at all but I can't figure out why.
I thought I might have had issues with log vs int but have tried adding L to one of the variables and it doesn't make a difference.
FYI the second log is showing 60000 as expected.
thanks
Aaron
Is CHECK_INTERVAL 0? You wrote that "the second log is showing 60000 as expected" but perhaps CHECK_INTERVAL was 0 the first time this code ran, then initialized, then 1 on a later iteration when you're looking at that part of the log.
Are you initializing CHECK_INTERVAL to something non-zero but after this code runs? Do you have an initialization bug?
This problem will be easy to solve if you step through the code in the debugger and watch the results. If you're not using a debugger, do yourself a huge favor and get Android Studio (a wonderful tool built on IntelliJ IDEA) or Eclipse + ADT (a good tool).
Java initialization is defined in a way that's predictable, portable, and useful, but it can still be tricky. E.g. given
class Foo {
static final int A2 = A1 * 1000;
static final int A1 = 60;
}
The JVM first initializes all variables to default values, then runs the initialization expressions in order. Since A1 is 0 when A2's initializer runs, A2 will end up 0.
See Java Puzzlers for more subtle cases such as when one class's initialization code refers to a second class, causing the second class's initialization code to run, which then refers to values in the first class which haven't yet been initialized beyond their default values (0 and null). A class runs its initialization code on first demand, but nothing guarantees that it finishes initializing before those values are used.
Another tricky case happens when one class, C1, refers to a static final value from a second class, C2.A, then you edit the initialization code for A without recompiling class C1. Java has precise rules about when to cache such constants in the first class's .class file, but they aren't the ideal rules, and the compiler doesn't notice that it needs to recompile C1 for this!
BTW 1: If CHECK_INTERVAL is an int, the expression CHECK_INTERVAL * 60 * 1000 will compute an int value and wrap around within a 32-bit signed range. Still, 1 * 60 * 1000 will easily fit in an int.
BTW 2: The first arg to Log.i() is a tag. It's OK to pass in this.toString() [or toString() for short] but the idea is to pass in a constant tag like the current class name that you can use for log filtering.
[Added] Quick intro to Eclipse debugging
In the source code editor, double-click in the left margin to set a breakpoint. Then use the menus or toolbar to "debug as" a Java application rather than "run as". Eclipse will go into its "Debug perspective" (arrangement of views).
https://www.google.com/search?q=eclipse+debugger finds nice tutorials with step-by-step pictures (I checked the first 3; IBM's is the most concise and introduces more features) and videos. The Eclipse docs are good but harder to navigate.
It's all slicker in Android Studio.
How can I get the type automatically of returned object for method using hotkeys in Intellij IDEA?
Quite often there are times when you need to modify such line:
myinstance.getMyMethod();
in the following:
IMySomeObject mysomeobject = myinstance.getMySomeObject();
I wish that IDEA did it itself for me to save time. I do not wish to explore method's signature, find its returned type and manually create this reference with a specific type of returned object. It's not convenient.
Using the Introduce Variable refactor.
Select
myinstance.getMyMethod();
press <ctrl>+<alt> + V and you will see a selections of names to give it like
IMySomeObject mySomeObject = myinstance.getMySomeObject();
I then select <Enter> as the first option is usually fine.
I suggest you have a look at all the refactoring tools in the Refactor Menu and learn what they all do.
You can type m
then type .
then <Enter>
then press <ctrl> + <alt> + V
lastly press <Enter> to accept the default name.
Another way besides Introduce Variable is by using their postfix completion feature.
The key thing is to type .var after the expression and then press the tab key.
Eg
myinstance.getMyMethod().var
With your cursor right after .var, press ctrl + space, and then press tab to select the suggestion. You'll then end up with:
IMySomeObject mySomeObject = myinstance.getMySomeObject();
btw, there's many more postfix completions options; I find it to be a very handy feature.
I would like to configure my Eclipse preferences to allow me to type:
printf<CTRL+SPACE> (or ALT+/, or anything I use as a "Content Assist" sequence)
and get this:
System.out.printf("<BANANA>%n", <argument1>);
with the ability to TAB-jump between <BANANA> and <argument1>.
The last part is important, the TAB-jump/replace. Notice the selected text would not include the %n constant, that stays.
I guess to know this I would need to know how to specify snippets, how to use the built-in variables and convert that into an entry in an .epf file.
Also, Eclipse seems to be wicked smart in figuring out from the surrounding context which variable I may want in a certain place. Probably from the type, the line proximity, whatever. Do I have any control on that myself when defining a snippet? Example:
System.out.printf("<BANANA>%n", <argument1>);
// Make BANANA equal to the second public static final String from the top + " split"
// Make argument1 the closest Float in the current block or any other Double, anywhere
I needed something "like" this in an .epf file:
/instance/org.eclipse.jdt.ui/org.eclipse.jdt.ui.text.custom_templates=<?xml version\="1.0" encoding\="UTF-8" standalone\="no"?><templates><template autoinsert\="true" context\="java" deleted\="false" description\="System.out.printf" enabled\="true" name\="pf">System.out.printf("${Message}%n", ${argument1\:var}${cursor});</template></templates>
Cursor after first argument to easily add the eventual argument2, ...
What's missing is a way to specify choice among a set, e.g. "choose one of %s, %d, %f, ..."