Less known features of Java

Every time I start (or think of starting) a blog post, a question arises in my mind, ‘How to start? What to write in the first paragraph?’Almost every time, an idea gets popped up in my mind, but today, my mind blanked out. I didn’t get any idea despite of thinking for more than 15 minutes. I even fell asleep a couple of times during that thought process. Then I thought of googling it. I opened google and typed ‘How to start a blog post’, I opened first 2-3 links, went through first link (patience: 100%), found nothing related to this, then went through the second one (patience: 50%), still, same result, then went through the third one hoping that this will really help me, but alas, nothing useful again(patience: 0%). Then I thought, ‘screw this’ and clicked on red button on upper right corner. And here we are, done with the first paragraph! Bingo!

Coming to the main aspect of this blog, this blog discusses about the features which are less known in java but are really useful. They help us a lot in our day to day programming. Even I was not aware of these. But when I came across such requirements, instead of implementing them with the traditional approach, I thought, ‘there must be some other way of doing it.’ Then I googled it and found the alternate solutions which are described in this blog. I have covered very small number of features in this blog. If I come across more of such features, I will definitely add them in my subsequent blog posts. We will look into these features one by one.

Double brace initialization:

Have you ever come across a requirement where you need to create a collection (say List) and fill it with the values available to you? May be you have to invoke the method which takes a collection filled with some predefined values as an argument, in this case, what will you do? You will probably go by the following traditional approach:

List<String> list = new ArrayList<String>();

list.add("A");

list.add("B");

list.add("C");

//pass this list to the method

Or if your list is static then, you will probably initialize it like this

public static final List<String> list = new ArrayList<String>();

      static{

            list.add("A");

            list.add("B");

            list.add("C");

      }

Java provides a way to do this in a single go, by double brace initialization. All we need to do is to pass all the calls to add method while creating the collection itself, as described in the code below:

List<String> list = new ArrayList<String>(){{

     add("A");

     add("B");

     add("C");

}};

//pass this list to the method

Voila! Your list is created in a single go. Isn’t this wonderful? You can do the same for static list as well. Here are some technical details of this double brace initialization.

The first brace creates a new anonymous inner class, the second declares an instance initializer block that is run when the anonymous inner class is instantiated. This type of initializer block is formally called an "instance initializer", because it is declared within the instance scope of the class.

This is just an excerpt; you can find the full article here.

Add shutdown hook:

Shutdown hook contains the code which is executed when an application goes down. Suppose if you want to do some activities before the application gets shut down (just like destroy() method of servlet) i.e. cleaning up resources, closing connections and streams, notify the administrator/user about the shutdown then you can use this shutdown hook to do the same. Following code shows how to do it.

public static void main(String[] args) {

        Runtime.getRuntime().addShutdownHook(new Thread() {

                 @Override

                 public void run() {

                     System.out.println("Inside Add Shutdown Hook...");

                 }

        });

        System.out.println("Last instruction of Program....");

        System.exit(0);

}

Output of this program will be:

Last instruction of Program....

Inside Add Shutdown Hook...

We can attach any number of shutdown hooks to the application. But but but, all shutdown hooks will run in parallel as they run in separate threads. Hence, in case of multiple shutdown hooks, we need to consider all the aspects of concurrency, deadlock, thread interaction etc.

We can also remove the shutdown hook by calling Runtime.removeShutdownHook(Thread hook)method.

The case when these shutdown hooks will not be executed is when JVM crashes unexpectedly or is killed by the user. Because, after all, it’s JVM which executes all these instructions. Hence, no JVM means no execution. More on shutdown hooks is described here and here.

Atomic classes (part of Java.util.concurrent.atomic package):

Atomic classes (e.g. Atomic Integer, Atomic Long etc) can be very useful when you want to share the variables across multiple threads. They provide “lock free thread safe programming on single variables” i.e. you can leave aside the concurrency problems if you use this classes. They have incrementAndGet() method which will provide you the next value.

Say, if you have requirement like how many threads have used a particular method or if you want to have some kind of counter which needs to be shared across the threads and these classes fit the bill. More on Atomic package is described here. A practical example of Atomic Integer is also shown here.

I am done with the features here. Hope you have liked it and will use it in future if required. Now starts the problem of what to write in the ending paragraph. My mind has again blanked out about this and I am not in a mood to google again. Hence, I am leaving it here.

A special thanks to my colleague Harshal Choksi who inspired me to write the blogs. Thanks for the inspiration mate. Keep inspiring people like this.

Happy coding!