I've been an ardent IntelliJ IDE user for a long time now. IntelliJ IDE provides ample keyboard shortcuts to help programmers write code fast. Below shortcuts are the top of my most used list.

## `Ctrl + Shift + Enter`

This shortcuts lets me quickly puts the cursor in the new line, even if my cursor is in the middle of my current line. While I mostly uses it to move the cursor to the new line, this shortcut is more advanced than that - it can complete the current statement and place the cursor in the next possible edit.

## `Ctrl + y`

Removes the current line.

## `Ctrl + Shift + E` and then `Ctrl + Shift + E`

The first shortcut shows me the recent location of my cursor and when I press again it filters and shows only the recently edited locations. Once I learned this shortcuts, my mouse usage has come down drastically.

## `Ctrl + E` and then `Ctrl + E`

Similar to the above shortcut, but it shows the files instead of locations.

## `Ctrl + Shift + A`

I can control anything on the IDE basically using just this one shortcut. Search for the settings / action that I want and run it. Switching theme, toggling word wrap, building projects, solving world hunger - anything you want.







5 most useful IntelliJ IDE keyboard shortcuts


In my last post about [common Java violations][1], I listed a set of mistakes that java developers tend to make. While refactoring a Java project with the objective to resolve those violations, I used the refactoring features of Eclipse extensively to quickly change the code. Below is the compilation of such refactoring techniques.

[1]: https://veerasundar.com/blog/common-code-violations-in-java "common code violations in Java"

## 1. Adding curly braces around block level statements

It is often a good practice to wrap the block level statements with `{curly braces}`. But still, if there is only one statement in the block, then some developers prefer not to wrap them with `{}`. But Checkstyle will complain if you do so.

If you want to change this,

```java
    if(condition)
        doSomething;
```

to this:

```java
    if(condition){
        doSomething();
    }
```

Eclipse's **source cleanup **is there for your help.

1.  In *Project Explorer, *right click on the source folder and select *Source -> Clean up'¦*[![using source clean up to add curly braces around block statements][3]][3]
2.  Choose *Use custom profile *and then click *configure *next to the custom profile section.
3.  By default, clean up action is configured to do multiple cleanup task. Since we are focused only on adding curly braces, we will disable all other cleanup tasks. To do this, navigate to all the tabs in the *Custom Clean ups *window and deselect all the cleanups.
4.  Then in the *Code Style *tab, select the *Use blocks in if/while/for/do statements *option and click *OK.*
5.  Then in *Clean Up *dialog, click *Next *and the refactoring will occur. You'll be presented with a review page with the changes made.

[]: https://veerasundar.com/img/2012/10/use-block-statements.png

## 2. Joining to if statements into one

Lets say, you have a code like this:

```java
    if(isLoggedIn){
      if(isAdmin){
        doSecretStuff();
      }
    }
```

It is safe to combine the two _if_ statements into one, unless you have some other code in between the two *if *statements. Of course, you can manually edit the code to remove the second if and move the condition to up. But wait, when Eclipse can do this for us, why should we do it ourselves?![Join inner if statement with outer if statements][3]

[3]: https://veerasundar.com/img/2012/10/join-if-statements.png "join-if-statements"

1.  Place your cursor on the *if *keyword of the inner *if *statement.
2.  Press *Ctrl 1 *which will open a context menu.
3.  Select the option *Join 'if' statement with outer 'if' statement*.
4.  Voila! the two if statements are now combined into one.

You'll get:

```java
    if(isLoggedIn && isAdmin){
      doSecretStuff();
    }
```

## 3. Renaming a filed and its getter / setter methods

According to a [this][4], renaming an element is the mostly used refactoring in Eclipse. So, when you rename a field which has setter/getter methods, you'd manually rename those method names. But Eclipse can help here to simplify this.[![][6]][6]

[4]: http://stackoverflow.com/a/1858592/42372 "Eclipse: Most useful refactorings"

[]: https://veerasundar.com/img/2012/10/rename-field-getter-setter.png

1.  Place your cursor on the field name that you want to rename.
2.  Press *Ctrl Shift *and then press *R key *two times continuously which will open the '*Rename Field' *dialog box.
3.  Check the options 'Rename getter' and '_Rename setter'_ while providing a new name to your field.
4.  On clicking OK, this will rename the field as well as its getter/setter methods.

## 4. Inverting *if *statement

Suppose you have a code like this:

```java
    if(!isLoggedIn){
      // ask to login
    }else{
      // allow access
    }
```

Above code is 100% valid. But code quality tools such as Checkstyle might complain, because we are using a negativity check in the first condition (i.e. *!isLoggedIn*). When you have only one case (just the if block), then we can't do much about it. But when you have both *if *and *else*, then you can just invert the conditions to avoid this scenario.

1.  Place your cursor on the first *if *keyword.
2.  Press *Ctrl 1 *and then select *Invert 'if' statement*.
3.  Eclipse will invert the conditions and the corresponding blocks.
4.  Finally, you'll get:
    if(isLoggedIn){
    // allow access
    }else{
    // ask to login
    }

Helps to improve the readability of the code.

## Conclusion:

Of course, the above are just the tip of the iceberg. Eclipse is capable of doing much-more advanced refactoring. So, what are **your** secret refactoring techniques?


Eclipse refactoring on steroids


I have started using [Sublime text][1] as my preferred code editor (for JS, CSS, Coffee). But, I still rely on Eclipse for writing Java code because it auto-imports Java packages and auto suggests variables and method names from my custom class files.

[1]: https://veerasundar.com/blog/unix-alias-with-parameters-or-opening-sublime-text-editor-from-command-line

Working on multiple editors throws in another problem: whenever I make a change in some file outside of Eclipse, the IDE does not silently reload. It shows a blank page saying 'The resource is out of sync. Press F5 to reload'. The message started annoying me soon as I had to switch back and forth often.

It is not just for the multiple editors. Even when I do a *git pull,* the resources go out of sync.

Then, I found a workaround for this. Eclipse provides a built-in option that auto reloads a resource if its out f sync. Here's how you  can enable it.

Go to **Window -> Preferences -> General -> Workspace **and check the option **'Refresh using native hooks or polling'**.

So, the next time when you try to open a out of sync file, the IDE will sync it for you (thus saving you a keystroke, one at a time ![:)][2] ).

[2]: https://veerasundar.com/blog/wp-includes/images/smilies/icon_smile.gif


How to auto reload external code changes in Eclipse project


Recently learned a really cool trick for copy-pasting code in Eclipse.

Let's say you have the following code:

```java
    package com.veerasundar.demo;

    public class CopyCode {
    	private int nothing;
    }
```

Now copy the above code, go to any Eclipse project and right click on *source *folder and paste. See what happens! Impressive isn't it!?

Here's what Eclipse did: it parsed the clipboard, found that there's a Java code in it, create the necessary package structure for the code to fit in and then copied the code there.

Neat!


Copy paste code directly in Eclipse


In Eclipse, when you press *Ctrl *button and click on any Class names, the IDE will take you to the source file for that class. This is the normal behavior for the classes you have in your project.

But, in case you want the same behavior for Java's core classes too, you can have it by attaching the Java source with the Eclipse IDE. Once you attach the source, thereafter when you _Ctrl Click_ any Java class names (_String_ for example), Eclipse will open the source code of that class.

To attach the Java source code with Eclipse,

1.  When you install the JDK, you must have selected the option to install the Java source files too. This will copy the **src.zip **file in the installation directory.
2.  In Eclipse, go to **Window -> Preferences -> Java -> Installed JREs -> Add **and choose the JDK you have in your system.
3.  Eclipse will now list the JARs found in the dialog box. There, select the **rt.jar** and choose **Source Attachment**. By default, this will be pointing to the correct **src.zip**. If not, choose the **src.zip **file which you have in your java installation directory.  
    ![java source attach in eclipse][1]
4.  Similarly, if you have the **javadoc **downloaded in your machine, you can configure that too in this dialog box.

[1]: https://veerasundar.com/img/2011/08/source-attach.png "source-attach"

Done! Here after, for all the projects for which you are using the above JDK, you'll be able to browse the Java's source code just like how you browse your own code.


Attaching Java source with Eclipse IDE


![Google App Engine on Netbeans][1]If you just started with App engine development, you might be having a feeling that Eclipse is the preferred IDE. And, Google also has offered its [official plug-in][2] to Eclipse IDE alone.

[1]: https://veerasundar.com/img/2011/04/nb.png "Google App Engine on Netbeans"
[2]: http://code.google.com/appengine/docs/java/tools/eclipse.html "It's easy to use the Eclipse development environment to develop your Java App Engine application, just as you can to develop any other servlet-based web application. With the Google Plugin for Eclipse, it's even easier. The plugin lets you create, test and upload App Engine applications from within Eclipse."

But what about the people who are not using Eclipse? Of course, you can always do a command line development but who does that these days!?

For **[Netbeans][3]** users, the plug-in **[nbappengine][4] **brings the Java app engine development to the Netbeans platform. Here's how you can start developing your app engine apps on Netbeans.

[3]: http://netbeans.org/
[4]: http://kenai.com/projects/nbappengine/pages/Home "Plugin enables J2EE development web modules on Google App Engine."

## Installing nbappengine plugin on Netbeans

1.  First thing first: Install the latest Netbeans (6.9 at the time of typing these characters) and open the IDE.
2.  Go to **Tools -> Plugins -> Settings **and click 'Add' button to add the nbappengine update center URL.
3.  Now give a name and the URL of the update center according to your version of Netbeans.
    - **Netbeans 6.9**: http://kenai.com/downloads/nbappengine/NetBeans69/updates.xml
    - **Netbeans 6.8**: http://kenai.com/projects/nbappengine/downloads/download/Latest_NetBeans68/updates.xml
    - **Netbeans 6.7**: http://kenai.com/projects/nbappengine/downloads/download/1.0_NetBeans671/updates.xml
4.  After adding it, now come back to the **'Available Plugins' **tab and do a search for 'Google'. Select all the plug-ins that are related to the App Engine and click install button.

## Configuring App Engine SDK with Netbeans

Now you've installed the nbappengine plugin on your Netbeans IDE.  The coming steps will tell you how you can configure the plugin with the App Engine SDK.

1.  Download the [App Engine SDK][5] for Java and extract the zip contents to your favorite location.
2.  In the Netbeans IDE, go to **Services window **(Ctrl 5 is the shortcut key) and right click on the **Servers **menu and select '**Add Server**'.
3.  Now select the '**Google App Engine' **from the list of servers and in the next screen choose the folder where you extracted your SDK files.
4.  Configure the server properties if you wish to change it and then click '**Finish'**

[5]: http://code.google.com/appengine/downloads.html#Google_App_Engine_SDK_for_Java

## Creating and deploying your first App Engine app on Netbeans

Now its the time to create a brand-new app engine application.

1.  In Netbeans, select '**File -> New Project -> Java Web -> Web application' **and follow the wizard to create the project.
2.  In the '**Server and Settings' **page choose '**Google App Engine' **as your server so that you'll get the app-engine related files (such as appengine-web.xml) pre-created for you.
3.  When you run/debug this application, Netbeans will start the app engine server (Jetty) and will deploy your application there.
4.  To deploy the application to the App Engine server, just right click on the project and choose '**Deploy to Google App Engine'. **it'll prompt you for the Google account credentials. After you provided that info, your app will be uploaded to the cloud.


App Engine Java development on Netbeans


\*\*In this post, I'm going to explain how you can setup a Java development environment (JDK Eclipse) in Ubuntu. I'm using Ubuntu 10.10, but these steps should be applicable to majority of Ubuntu versions.

Let's start with JDK first.

## Install Sun JDK:

1.  Download the Linux version of latest JDK binary from the [Oracle website][1]. For Java 6, the file name would be: **_jdk-6u22-linux-i586.bin_**
2.  Copy the downloaded JDK file to a directory where you want to install the JDK. I use ***/home//java/*jdk-6u22-linux-i586.bin\*\***
3.  Open terminal window and navigate to the directory where you copied the downloaded file. Then type the command: **\*sudo sh jdk-6u22-linux-i586.bin** \*and press enter.
4.  If it asks for root password, give it and JDK installation will begin. The JDK will be installed on the same directory where the binary is placed.

[1]: http://www.oracle.com/technetwork/java/javase/downloads/index.html "JDK downloads"

That's it. JDK installation is done. But we still have one more step to complete. That is, setting up the _JAVA_HOME_ environment variable.

## Setting up JAVA_HOME environment variable:

1.  Go to Nautilus file browser (_Places -> Home Folder_) and open this file: **_'.bashrc'_**. By default this file is hidden. So, press *Ctrl H *which will show all hidden files and then you can see the *.bashrc *file.
2.  Add the below code snippet at the end of the *.bashrc *file:
    export JAVA_HOME=/home//java/jdk1.6.0_22
    PATH=.:$JAVA_HOME/bin:$JAVA_HOME/jre/bin:$PATH

    **Don't forget to change the path in first line according to where you installed your JDK**

    - That's it. Log off and Log in again for the changes to take effect. To test whether the installation successful, open Terminal and type *java -version *which should show you the currently installed JDK version.

    ## Install Eclipse:

    Installing Eclipse in Ubuntu is pretty simple. Just [download][2] the ZIP file from Eclipse.org and then unzip it. The installation is done. ![;-)][3]

[2]: http://www.eclipse.org/downloads/ "Eclipse downloads"
[3]: https://veerasundar.com/blog/wp-includes/images/smilies/icon_wink.gif


#ide (7)