Little things worth stumbling upon!

Git: Resolve Conflicts in PR

2018-10-25T17:40:00.000+05:30

What to do when GitHub does not allows you to merge a Pull Request due to conflicts!

First of all, rebase often to avoid this problem in most cases.

Sharing bits from my experience. The solutions that worked for me are:

1. git rebase

The best way is to do it locally using terminal or command prompt. Lets say you raised a PR from origin/develop to upstream/develop branch and got conflict. Go to your command prompt, rebase master onto develop and push to develop branch. PR should get resolved.

But this won’t work when the tips are just big time outdated.

I tried rebasing, and all I ended up was at same state but with alternated branches. Means the new branch was now compatible with master but not develop.
I also tried using GitHub’s web editor (link was present in PR comment near conflicting files), this also did not work, as after resolving, GitHub repeatedly asked me to Start Over.

That’s when git merge came to rescue.

2. git merge

See documentation.

Assuming, you are raising PR from your origin to another remote called upstream, perform the following in your local terminal or command prompt.

git checkout develop

git fetch upstream

git merge upstream/develop

Resolve any conflicts and commit. The run below to check if branch is clean now.

git status

Once confirmed, execute.

git push origin develop

And then, raise PR from origin/develop to upstream/develop. You should be able to merge it now.

3. Force push

Use this option if and only if you are sole owner of upstream and are confident that you’ve got all commits in your origin/develop.

Force Push overwrites target branch with your pushed commits, and you won’t be able to reclaim whats lost in the process.

git push origin develop

git checkout -b develop upstream/develop

git reset --hard origin/develop

git push upstream +develop

Note: origin and upstream are just regular remotes, former is your own remote repository and upstream represents the base repository from which you have forked your’s. For example,

upstream -> https://github.com/microsoft/msoffice

origin -> https://github.com/rajdeep/msoffice

Thats it! I hope it helps. Let me know in comments if this worked or you have some other scenario or solution.

Using Wiremock for quick and easy http mocks of your API

2017-08-16T02:24:00.000+05:30

I published this article at the turn of the year in my company's internal blog. I am republishing it here thinking it might be useful to outside world who are looking at a concise guide.

WireMock is an HTTP mock server. At its core it is web server that can be primed to

serve canned responses to particular requests (stubbing) and
that captures incoming requests so that they can be checked later (verification).

Imagine your application component is dependent on some other component for development or testing, here WireMock can come in and remove your dependency headaches.
You can agree the contract, design the stub and use it for your own component without tight integration with other component. This makes the development and testing much
easier and faster.

WireMock also helps in situations when you want to test against a variety of parameters but you have programming limitations or other complexity/error factors. You can read more
in the official website.

WireMock comes as a jar file that you can either

use as a library in your Java code (or any JVM application), or

run as a standalone process in your localhost or remote.

All of WireMock’s features are accessible via its REST (JSON) interface and its Java API. Additionally, stubs can be configured via JSON files.

Here we are talking about basic info on running it as a standalone process.

Running the server with stub

Step 1: Download the latest jar from http://wiremock.org/.

Step 2: Run the jar.

$ java -jar wiremock-standalone-2.4.1.jar

By default this will start the mock server on http port 8080, which is available at:

http://<host>:8080

When the WireMock server starts it creates two directories under the current one: mappings and __files in the same directory as of the jar by default.

some_folder
|---- __files
|---- mappings
|---- wiremock-standalone-2.4.1.jar

Step 3: Put the mapping and/or any stub response in a .json file inside mappings.

If you want to manage the stub in multiple files, drop it under __files, and map it against particular request in the .json file inside mappings.

Step 4: For contents to be reflected, restart server.

Step 5: Use browser, or any client like Postman to test it. You can also integrate the end point in your application code like any normal URL.

Note: There are different flags like --port, --https-port etc to start the application with that you can get from official website so as to match your requirements.

Example:

For the following outcome:

We did the following:

Created a mapping.json file inside mappings folder with following content.
{
  "request": {
  "method": "GET",
  "url": "/api/mytest"
},
  "response": {
  "status": 200,
  "body": "More content\n"
}}

We have stubbed the response with "More Content" text here directly so we did not use __files folder.
If any of the request method or URL does not matches, server will return 404.

Started the server:

$ java -jar wiremock-standalone-2.4.1.jar

Here's the folder structure:

my_folder
|---- __files
|---- mappings
|---- mapping.json
|---- wiremock-standalone-2.4.1.jar

We can do request matching based on request body or other request parameters also like URL, headers, method etc, and put in multiple mapping .json files inside mappings.

When the stub is not simple and we want to keep them arranged in our server, we can put them in files inside __files, and provide their names inside the corresponding mapping files.

Following mapping gives an example of request body matching and maps it to a particular stub file.

{
"request": {

  "method": "POST",
  "bodyPatterns": [
{
"contains":"type: CREDIT"
}
]
},
  "response": {
  "status": 200,
"bodyFileName":"Credit_Response.json"
}
}

The folder structure for above is:

Verification

WireMock maintains the log of all requests in-memory since most recent server startup. This is in JSON format. This is a critical resource for auditing for success/failure cases.

Hitting a GET request to /__admin/requests will return all requests. For example: http://localhost:8080/__admin/requests.
Hitting a GET request to /__admin/requests/unmatched will return all unmatched requests.

Similarly, there are other locations too. Refer official doc.

Reference: http://wiremock.org/

Q. Doesn't seem to work for protobuff requests. What is the way around?

Info. Protobuff is a message transfer format like json or XML, from Google.

A. For textual formats like txt or json, JSONPath can be used to identify some keywords in the request body. But this won't work for protobuf or other formats where JSONPath can't traverse itself. So following is the way in my idea:

Generate stubs at own end aforehand, serialize them and place in _files directory.
For request matching, do either of the following:
2.1. Include request header with key-value pairs that you'd like to identify, and look for them in your mapping file. I'd recommend for ease of use.
2.2 For request body searching, you need to write custom matcher class that can deserialize, read through the request body and returns whether the identification was found or not, then based upon mapping, return the already placed stub.
While returning response, return the mapped serialized file with appropriate headers such as Content-Type.

For complete control, like dynamic response generation etc, you need to write and place the whole implementation in wiremock and use (jar in java). This is an overkill for simple mocking purpose.

Stackoverflow Documentation | The way to go

2017-02-20T12:29:00.000+05:30

Many months now, the Stackoverflow documentation is maturing with new examples and continuous edits to existing examples. It covers many programming languages, and should be on top of your TO-DOs if you are trying to broaden your skill set or even validate what you already have in your kitty.

If you feel it's good, you should consider making it awesome for others. Ultimately, giving back to the community only makes sure of technology's global reach and rapid development. Click here: http://stackoverflow.com/documentation.

Recursion is all about trust.

2016-09-01T21:49:00.002+05:30

Image credit: http://www.cr31.co.uk/logoarts/

The secret of recursion is only one thing. Trust. Here's a neat example to show you what it exactly means. Quoting Stephan van Hulst from Code Ranch here.

Say there's a long queue of people, and you want to know how many are in the queue. You can simply ask the guy in front of you how many people there are in the queue, and then add 1 for yourself. You don't care how the guy in front of you got the answer, you just trust that it's correct. The guy in front uses the same technique. This goes on all the way until the guy at the front of the queue is asked how many people there are in the queue. The guy at the front sees no people in front of him, so he just reports 1. He is the base case.

final class PersonInQueue {
 
  private final PersonInQueue next;
 
  int askForLengthOfQueue() {
    if (next == null)
      return 1;
 
    return next.askForLengthOfQueue() +1;
  }
}

Here's the post: Algorithm explanation if you want to have a look. The question was on Tower of Hanoi.

IP v4 address matcher (regex)

2016-04-10T17:46:00.000+05:30

IP address is a string in the form "A.B.C.D", where the value of A, B, C, and D may range from 0 to 255. Leading zeros are allowed. The length of A, B, C, or D can't be greater than 3.

The pattern is: ^(?:(?:25[0-5]?|2[0-4]?[0-9]?|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]?|2[0-4]?[0-9]?|[01]?[0-9][0-9]?)$

Java:

public class IPv4Regex {
	static final String ipV4Pattern = "^(?:(?:25[0-5]?|2[0-4]?[0-9]?|[01]?[0-9][0-9]?)\\.){3}"
			+ "(?:25[0-5]?|2[0-4]?[0-9]?|[01]?[0-9][0-9]?)$";
	
	public static void main(String[] args) {
		System.out.println("000.123.234.245".matches(ipV4Pattern));
	}
}

Tree traversal notes

2016-03-08T23:41:00.001+05:30

1. Inorder:

- travel left subtree in inorder
- visit root
- travel right subtree in inorder

Recursive approach:

void inOrder() {
 if(root != null) {
  inOrder(root.left);
  System.out.println(root.data);
  inOrder(root.right);
 }
}

Iterative approach using stacks:

void inOrder() {

    Stack stack = new Stack();

    Node current = root;

    while(current!=null || !stack.isEmpty()) {
        //push to stack and move to left sub-tree
        if(current!=null){
            stack.push(current);
            current = current.left;
        }
        else { //we need to pop out nodes from stack and shift to its right sub-tree
            current = stack.pop(); //visited node
            System.out.println(current.data);
            current = current.right;
        }
    }
}

2. Pre-order:

- visit root
- travel left subtree in preorder
- travel right subtree in preorder

Recursive approach:

void preOrder() {
    if(root != null) {
        System.out.println(root.data);
        preOrder(root.left);
        preOrder(root.right);
    }
}

Iterative approach using stacks:

void inOrder() {

    Stack stack = new Stack();

    Node current = root;

    while(current!=null || !stack.isEmpty()) {
        //print each value, then push its right subtree to stack and move to left subtree
        if(current!=null){
            System.out.println(current.data); //visited node
            stack.push(current.right); //push right subtree
            current = current.left; //shift to left subtree
        }
        else {
            current = stack.pop();
        }
    }
}

Designing your own iterable stuff

2016-02-12T20:47:00.000+05:30

Or, simply, implementing iterator logic in your own class, on which you can iterate or even use for-each loop. Because, for-each works only on Iterator based collections.
Following is a generic Java 7 code that takes into account a simple custom linked list implementation that is generic and can be iterated over, using following steps.

1. The stuff we want to iterate upon has to be Iterable and expose
iterator().

2. Design a java.util.Iterator by overriding hasNext(), next() and remove().

package org.algorithms.linkedlist;

import java.util.Iterator;
import java.util.NoSuchElementException;


public class LinkedList<T> implements Iterable<T> {

    Node<T> head, current;

    private static class Node<T> {
        T data;
        Node<T> next;

        Node(T data) {
            this.data = data;
        }
    }

    public LinkedList(T data) {
        head = new Node<>(data);
    }

    public Iterator<T> iterator() {
        return new LinkedListIterator();
    }

    private class LinkedListIterator implements Iterator<T> {

        Node<T> node = head;

        @Override
        public boolean hasNext() {
            return node != null;
        }

        @Override
        public T next() {
            if (!hasNext())
                throw new NoSuchElementException();
            Node<T> prevNode = node;
            node = node.next;
            return prevNode.data;
        }

        @Override
        public void remove() {
            throw new UnsupportedOperationException("Removal logic not implemented.");
        }
    }

    public void add(T data) {
        Node current = head;
        while (current.next != null)
            current = current.next;
        current.next = new Node<>(data);
    }

}

class App {
    public static void main(String[] args) {

        LinkedList<Integer> list = new LinkedList<>(1);
        list.add(2);
        list.add(4);
        list.add(3);

        //Test #1
        System.out.println("using Iterator:");
        Iterator<Integer> itr = list.iterator();
        while (itr.hasNext()) {
            Integer i = itr.next();
            System.out.print(i + " ");
        }

        //Test #2
        System.out.println("\n\nusing for-each:");
        for (Integer data : list) {
            System.out.print(data + " ");
        }
    }
}

Output

using Iterator:
1 2 4 3
using for-each:
1 2 4 3

Sorting Key-Value pairs in Java

2015-06-28T23:54:00.001+05:30

Saw making your own sorting logic by implementing Comparable or Comparator? If not, click here. Now, how about sorting key-value pairs! Well, we need just a little code modification. See following code sample that sorts key-value pairs, first by key, then values. Look at the compareTo method implementation.

package collections;

import java.util.SortedSet;
import java.util.TreeSet;

/**
 * Sort by key first and then by value
 */
public class KeyValueSortingApp {
    public static void main(String[] args) {
        SortedSet<KeyValuePair> sortedSet = new TreeSet<KeyValuePair>();
        sortedSet.add(new KeyValuePair("icici",400));
        sortedSet.add(new KeyValuePair("icici",200));
        sortedSet.add(new KeyValuePair("icici",50));
        sortedSet.add(new KeyValuePair("sbi",320));
        sortedSet.add(new KeyValuePair("icici",300));
        sortedSet.add(new KeyValuePair("sbi",100));

        for (KeyValuePair pair : sortedSet) {
            System.out.println(pair.key + ":" + pair.value);
        }
    }
}

class KeyValuePair implements Comparable<KeyValuePair> {
    String key;
    int value;
    public KeyValuePair(String key, int value) {
        super();
        this.key = key;
        this.value = value;
    }
    @Override
    public int compareTo(KeyValuePair o) {
        //sort by key, then value
        return key.equalsIgnoreCase(o.key) ? 
            value-o.value : 
            key.compareToIgnoreCase(o.key);
    }
}

Output:
icici:50
icici:200
icici:300
icici:400
sbi:100
sbi:320

Comparable and Comparator- When and how to use? [Concise]

2015-06-07T04:11:00.000+05:30

When there comes the need of sorting objects, be it using Collections.sort() or just adding elements to Treeset etc, java.lang.Comparable and java.util.Comparator come into picture. For default sorting of objects in the collection, we need to implement Comparable and override below method in that class, unless we are using some pre-defined class that already implements Comparable like String, Integer etc.,

int compareTo(T o)

If we want to provide an external sorting logic to override the default one, the class needs to implement Comparator interface and override the following method:

int compare(T o1, T o2)

The question: Why use Comparator when we already have Comparable?
Answer: If you have authored that class, then you can give a default sorting behavior by implementing Comparable and use that logic to sort whenever needed. Now, let's say that you are using an existing class whose source you can not modify and the default sorting logic of which you are not satisfied with. What now? Just write a Comparator using your own sorting process and use that instance to sort. See below sample programs.

The API information is here:

1. java.lang.Comparable
2. Java.util.Comparator

Lets dig into this with our custom class.

package com.blogspot.javabambino.collections;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

class Student implements Comparable<Student> {
    String name;
    int rollNumber;
    int rank;

    public Student(String name, int rollNumber, int rank) {
        this.name = name;
        this.rollNumber = rollNumber;
        this.rank = rank;
    }

    //default sorting based on rollNumber
    public int compareTo(Student student) {
        return this.rollNumber - student.rollNumber;
    }

    public String toString(){
        return name;
    }
}

public class ComparableAndComparatorTest {
    public static void main(String[] args) {
        Student s1 = new Student("Abhi",1,3);
        Student s2 = new Student("Asha",2,10);
        Student s3 = new Student("Jacky",3,7);
        Student s4 = new Student("Ron",4,10);

        List<Student> students = new ArrayList<Student>();
        students.add(s4);
        students.add(s2);
        students.add(s3);
        students.add(s1);

        System.out.println("Before sorting:");
        System.out.println(students + "\n");

        //1. This uses default comparison, from Students class
        Collections.sort(students);

        System.out.println("Using default sorting (rollnumber):");
        System.out.println(students + "\n");

        //2. Providing a comparator to override default comparison
        Comparator<Student> rankComparator = new Comparator<Student>() {
            @Override
            public int compare(Student stud1, Student stud2) {
                int diff = stud1.rank - stud2.rank;
                if (diff==0)
                    //if rank is same, sort by rollnumber
                    diff = stud1.rollNumber-stud2.rollNumber;
                return diff;
            }
        };

        Collections.sort(students,rankComparator);

        System.out.println("Using overridden sorting logic (rank, then rollnumber): ");
        System.out.println(students);
    }
}

Our input was in following sequence (just for readability):

Name	Rollnumber	Rank
Ron	4	10
Asha	2	10
Jacky	3	7
Abhi	1	3

and the output is:

Before sorting:
[Ron, Asha, Jacky, Abhi]

Using default sorting (rollnumber):
[Abhi, Asha, Jacky, Ron]

Using overridden sorting logic (rank, then rollnumber):
[Abhi, Jacky, Asha, Ron]

native2ascii - Native-to-ASCII Converter in Java

2015-01-29T17:02:00.001+05:30

This utility converts a file with characters in any supported character encoding to one with ASCII and/or Unicode escapes, or visa versa.

You already have this tool if you have JDK. It is present in your JDK installation bin folder. Its recommended to add JAVA_HOME to your PATH environment variable for access of java tools throughout your machine.

native2ascii [options] [inputfile [outputfile]]

This is useful in translation of some string (error messages or labels or help text etc.) to Unicode format which is recognized by the Java compiler. Java tools cannot process characters other than Latin-1 or Unicode, so this native2ascii tool comes handy to convert your strings to Unicode format. I encountered this in regards to translating a few error messages. The obvious benefit is that most (or any) of the text editors or IDEs would support simple unicoded characters rather than different locales, without the need to install locale packages. And this guy also tells us something he knows about it!

An example usage if both files are in same location is as below:

>native2ascii -encoding utf8 otherlocale.txt translated.txt

2. http://www.cs.mun.ca/~michael/java/jdk1.1-beta2-docs/tooldocs/win32/native2ascii.html

Falling in love with InteliJ Idea Community IDE

2014-12-20T21:00:00.000+05:30

The local file history that keeps a track on my changes to a file, I am all smiles now! :~)

Local History - Click on the image to enlarge

Java Map/Collections Cheat Sheet : Simply 'When and What to use'?

2014-05-20T17:02:00.000+05:30

This is a notoriously simple when and what to use Java collection API cheat sheet, containing most common implementations.

This is from a blog that I stumbled upon today! I liked it and it deserves a share unless the author says - Come on bambino, time for some royalty!

Thank you Sergiy Kovalchuk for your blog article !

Find the occurrence of words in a given string

2014-05-19T00:26:00.001+05:30

IDEONE: http://ideone.com/9SENHc

package com.learning.collection;
import java.util.*;
/**
 * Count frequency of words occurring in a string
 */
public class MapExample {
    public static void main(String[] args){
        String str = "ika pika ting tong ting tong me";
        String[] strr = str.split("\\s");
        workMap(strr);
    }

    static void workMap(String...words){
        Map map = new HashMap();
        Integer ONE = new Integer(1);

        for(String word : words){
            Integer frequency = (Integer)map.get(word);
            /*
            'frequency' is the count of the words.
            For a new word getting added to the Map, we set its frequency as 1.
            For existing words, we take their existing frequency (value in the map)
            and increment it and put back into the map correspondint to that word (key in the map)
             */
            frequency = (frequency == null) ? ONE : new Integer(frequency.intValue() + 1);
            map.put(word, frequency);
        }
        System.out.println("Unsorted:");
        System.out.println(map);

        Map sortedMap = new TreeMap(map);
        System.out.println("Sorted:");
        System.out.println(sortedMap);
    }
}

Output:

Unsorted: {ika=1, pika=1, ting=2, tong=2, me=1}
Sorted: {ika=1, me=1, pika=1, ting=2, tong=2}

--Suggestion by Dr. Heinz Kabutz (Java Champion)
How you would count words in Java 8 :-) And if you want to do it in parallel, just add parallel() into the stream...

import java.util.*;
import java.util.function.*;
import java.util.stream.*;

public class MapExample {
  public static void main(String[] args) {
    String str = "hello world how are you how is life i am into ascent";

    Map<String, Integer> map = Arrays.stream(str.split("\\s"))
        .collect(Collectors.toMap(
            Function.identity(),
            n -> 1,
            (n1, n2) -> n1 + n2,
            TreeMap::new));
    System.out.println("map = " + map);
  }
}

Finding the JAR files which contain a specific .class file on Linux machine

2014-04-30T17:43:00.001+05:30

This program searches through all .jar files in the current directory, and in any sub-directories, looking for the class that you specify. This can be very handy if you need to use a class in a Java program, but aren't sure which .jar file contains it.

Logic of script: The key is to get a list of all the jar files in present directory, open each jar archive and search it with our input classname, and for all positive output, print the name of the jar file on screen.
Sample Usage:

jar -tf rt.jar | grep "Object.class"

Note:

1. After downloading, rename the file to "JarSearch.sh". Transfer the JarSearch.sh file to Linux machine in ASCII mode to the location where you want to search. Give permission:

chmod -x JarSearch.sh

Sometimes, before giving permission, it may be required to convert the file format using below command to UNIX format. This will not affect the functionality.

dos2unix JarSearch.sh

2. Before using the script, verify that the JAVA_HOME environment variable is set correctly on your system.

echo $JAVA_HOME

If not set, set it to JDK installation directory.

3. Information
About: Searches .jar in current path for a specified class file including sub-directories.
Usage: ./JarSearch.sh class_name
Example: ./JarSearch.sh Object
Caution: Give exact class name without .class extension or package inormation. This searches for file name.
Known issue: Can not be used to search inner classes due to $ sign in the name. You can fork the code.
Tested for JDK 1.5 and 1.6 on SUSE Linux in ksh, csh and bash shells.

Download link: http://ideone.com/plain/W7xM03

The script: JarSearch.sh

#!/bin/sh

className=$1
JAR=$JAVA_HOME/bin/jar
JARFILES=`find . -name "*jar"`
found=0
ask=1

#########################################
#Author: Rajdeep Biswas
#Created: 2014-04-30
#Website: www.javabambino.blogspot.com
#Known issue: Not for inner classes
#########################################
echo ""
echo "*****************************************"
echo "About: Searches .jar in current path (sub-directories inclusive) for a specified class file."
echo "Usage: $0 class_name"
echo "Example: $0 HashMap"
echo "Note: Give exact class name without .class extension."
echo "*****************************************"
echo ""

#Error if there is no or multiple arguments
if [ $# -ne 1 ]
then
 echo "ERROR: Wrong number of arguments specified, please check usage above!"
 exit 1;
fi

#Ask how to search
while [ $ask -eq 1 ]
do
 echo "1. Enter '1' to search for exactly $className.class"
 echo "2. Enter '2' to search for *$className.class pattern. For example, Sample$className.class"
 echo "3. Enter '0' to exit this program"
 read temp
 
#validate input is only 1, 2 or 0. If not, take input again.
 if [[ -n ${temp//[0-2]/} ]]; 
 then
  echo -e "Caution: Invalid input!\n"
  continue
 fi

 if [ $temp -eq 0 ]
 then
  echo "Exiting.."
  exit 1
 fi

 if [ $temp -eq 1 -o $temp -eq 2 ]
 then
  searchHow=$temp
  ask=0
 fi
done

#Set the grep pattern accordingly as user input on how to search
if [ $searchHow -eq 1 ]
then
 searchWhat="grep -w $className.class"
elif [ $searchHow -eq 2 ]
then
 searchWhat="grep $className.class"
fi

echo -e "Scanning started...\n"
#Start scan
for JARFILE in $JARFILES
do
 $JAR tvf $JARFILE | $searchWhat  > /dev/null
 
 if [ $? -eq 0 ]
 then
  found=1
  echo "==> Found in $JARFILE"
 fi
done
#End scan

if [ $found -eq 0 ]
then
 echo "$className.class not found in current path: "`pwd`
fi

echo -e "\nScanning over."

Synchronization in Java : class and object locking concept

2014-04-24T16:29:00.000+05:30

People talk about two types of multi-threaded locking - object and class. In my knowledge, locking is done on objects only. Let me explain.

Case 1: On objects we create using new or factory methods etc.

void synchronized myMethod(Type param) {
  //will lock on the instance used to call this method
}

synchronized(this) {
 //will lock on current object
}

synchronized(obj1) {
 //will lock on specified obj1 object
}

Case 2: On java.lang.Class objects This is called class lock, and can be used with static fields or methods or blocks, as they belong to class and shared among all the objects, and other class properties.

static void synchronized method() {
  //will lock the Class object
}

static {
  synchronized(SomeClass.class){
    int a = 2;
  }
}

This is also object locking because classes are loaded into the Method Area in the JVM, and all the static members of the class are wrapped inside a java.lang.Class object created by JVM. So behind abstraction, its that class' object locking and in the front picture, we consider it class locking.
So I can also infer one more thing. Just as objects locked by a thread can not be acquired by another thread as long as it is not released by first thread, class locking (the java.lang.Class instance) also works in same manner as it is essentially object locking only.

Now slightly digging into the class locking concept. Taking the following class hierarchy.

class Animal {
 static synchronized void eat() {
  //generic eating habits
 }
}

class Dog extends Animal implements Runnable{
 public void run() {
  Dog.eat();
 }
}

The above code will result into locking Animal.class object only whether we call eat() method using Dog or Animal, because eat() is present in only Animal class.
Let's change the scenario.

class Animal {
 static synchronized void eat() {
  //generic eating habits
 }
}

class Dog extends Animal implements Runnable{
 public void run() {
  Dog.eat();
 }
 static synchronized void eat() {
  //doggy eating habits
 }
}

Now that eat() method is present in both classes, lock will be acquired only on that class on which the method was called. Dog.class in above case. If it was Animal.eat(), will lock Animal.class.
Lets do a little bit more.

class Animal {
 static synchronized void eat() {
  //generic eating habits
 }
}

class Dog extends Animal implements Runnable{
 public void run() {
  Dog.eat();
 }
 static synchronized void eat() {
  super.eat();
 }
}

When started, the Dog thread will go on to lock the Dog.class and then Animal.class.

Note:

synchronized keyword helps in mutual exclusion, so when a lock is acquired on any object by a thread, only the synchronized properties are kept safe from manipulation by other threads, the non-synchronized properties like variables or methods etc, are free to get manipulated.
Each object has a synchronization lock, which can be owned by only one thread at a time. However, a thread can own multiple locks at the same time.
Synchronization can help to eliminate race conditions but can introduce deadlock into the application..

Writing singleton classes in Java

2014-04-21T18:21:00.001+05:30

Singleton classes are those classes which can be instantiated only once. We need to restrict the creation of multiple instances of that class by blocking constructor access using new keyword etc, and instead regulate the incoming instance requests by creating the instance only once and return the same instance time and again on multiple calls.
Where do we actually need this singleton design pattern?

The answer will be where you need only one instance and not multiple instances of a class across your application. This does not degrades the performance since your work needs only single instance and using this design pattern you are preventing multiple instances. The actual case might just vary according to your needs. This may be logging, or database connection object. But you have to decide:

will you ever need exactly one instance in your application?
is your application expecting the exactly same implementation of this class?

among many other factors before you finally settle in to make a class singleton. An insightful reading at the developerWorks website can be found here.

There are many ways, some ways are presented here as different code snippets. Let me know if you have a better idea and see a flaw in these codes that I may have missed.

Code snippet 1:

package designpattern;
/**
 * Early instantiation means that the singleton instance 
 * is created during class loading itself and not when 
 * first used. So, no synchronization is required by using a static field.
 * This means that whether or not we require the singleton instance, 
 * it will be created and the object will be unique.
 * Works well in singlethreaded and multithreaded environments.
 * 
 * @author xploreraj
 */
class Singleton1 {
 private static Singleton1 instance = new Singleton1();
 
 private Singleton1() {
  //disable outside access
 }
 
 public static Singleton1 getInstance(){
  return instance;
 }
}


/*
 * test
 */
public class TestSingleton1 implements Runnable {
 
 public static void main(String[] args) {
  int count = 100;
  Thread thread[] = new Thread[count];
  for(int i=0; i< count; i++){
   thread[i] = new Thread(new TestSingleton1());
  }
  for(int j=0; j< count; j++){
   thread[j].start();
  }
  
 }

 @Override
 public void run() {
  Singleton1 instance = Singleton1.getInstance();
  System.out.println("Accessed by " + Thread.currentThread().getName() +
    "; Singleton1 instance is " + instance.hashCode());
  
 }
}

Code snippet 2:

package designpattern;
/**
 * Lazy instantiation of singleton using synchronization 
 * on getInstance() method makes it is usable in 
 * multithreaded environments.
 * 


 * The instance will be null only the first time, and 
 * then it will always be not null so that the singleton 
 * instance is returned directly. We need synchronization 
 * for the first time so that multiple threads 
 * concurrently do not get inside the getInstance() method 
 * while instance == null and then create multiple singleton instances.
 * But using synchronization on the method will unnecessarily 
 * take computation resources by locking the method everytime. 
 * Since instance is not null and getInstance() should return the instance directly.
 * 
 * @author xploreraj
 *
 */
class Singleton2 {
 private static Singleton2 instance;
 private Singleton2() {
  //hide from outside
 }

 public static synchronized Singleton2 getInstance() {

  if(instance==null) {
   for(int i=0; i< 100000; i++)
    ;

   instance = new Singleton2();
  }
  return instance;
 }//getInstance()
}

/*
 * test
 */
public class TestSingleton2 implements Runnable{

 public static void main(String[] args) {
  int count = 20;
  Thread thread[] = new Thread[count];
  for(int i=0; i< count; i++){
   thread[i] = new Thread(new TestSingleton2());
  }
  for(int j=0; j< count; j++){
   thread[j].start();
  }
  
 }//main()

 @Override
 public void run() {
  Singleton2 instance = Singleton2.getInstance();
  System.out.println("Accessed by " + Thread.currentThread().getName() +
    "; Singleton2 instance is " + instance.hashCode());
  
 }//run()

}

Code snippet 3:

package designpattern;
/**
 * clever but DEFECTIVE SINGLETON
 * Lazy instantiation of the singleton.
 * 

 * Checking the instance variable for null and then 
 * applying synchronization improves the code
 * at Singleton2 class, because if instance is 
 * not null, i.e., after first execution of the code,
 * the control will never get inside the synchronized 
 * block and computation cost will be saved. 

 * But there will be a problem. 
 * Say Thread1 checks instance = null and gets inside
 * the block but is preempted by Thread2 before executing 
 * the synchronized block. Now instance being null
 * Thread2 will also enter the block and for each of those 
 * threads, different instances will be created.
 * SO SINGLETON WILL NOT BE POSSIBLE IN MULTITHREADED ENVIRONMENT.
 * 
 * @author xploreraj
 *
 */
class Singleton3 {
 private static Singleton3 instance;
 private Singleton3() {
  //to do
 }
 
 public static Singleton3 getInstance() {
  if (instance==null){
   
   for(int j = 0; j< 100000;j++)
    //lets say that a thread is involved in something 
    //after coming inside this null checked block
    ;   
   
   synchronized(Singleton3.class){
     instance = new Singleton3();
   }
  }
  
  return instance;
 }
}

public class TestSingleton3 implements Runnable {

 public static void main(String[] args) {
  int count = 20;
  Thread thread[] = new Thread[count];
  for(int i=0; i< count; i++){
   thread[i] = new Thread(new TestSingleton3());
  }
  for(int j=0; j< count; j++){
   thread[j].start();
  }
  
 }//main()

 @Override
 public void run() {
  Singleton3 instance = Singleton3.getInstance();
  System.out.println("Accessed by " + Thread.currentThread().getName() +
    "; Singleton3 instance is " + instance.hashCode());
  
 }//run()

}

Code snippet 4:

package designpattern;
/**
 * Lazy instantiation of the singleton.
 * 

 * This is double-checked locking example and will prevent 
 * following scenario from breaking the singleton policy.

 * Description:

 * 1. Thread-1 enters getInstance() method for first time 
 * since instance == null, and then is preempted by Thread-2.

 * 2. Thread-2 enters getInstance() since instance is still null. 
 * It goes inside the inner synchronized block and 
 * once more instance == null check is done. It is null so 
 * instance has a new object now.

 * 3. Thread-2 is preempted by Thread-1, and now Thread-1 enters the 
 * internal synchronized block. Since an additional
 * check for instance == null is made, and this time 
 * instance is non-null, it will not reach the code for fresh
 * initialization.

 * Note:

 * There is a memory problem known as Out of Order writes in older JVM,
 * meaning a reference to an object could be returned by JVM just by
 * allocation memory and making the reference but before the construction,
 * precisely constructor logic, is actually over, so returning a partially
 * created object to one thread which cou,d lead to a lot of discrepancies.
 * Ref: http://www.javaworld.com/article/2074979/java-concurrency/double-checked-locking--clever--but-broken.html
 * 
 * @author xploreraj
 *
 */
class Singleton4 {
 private static Singleton4 instance;
 private Singleton4() {
  //to do
 }
 
 public static Singleton4 getInstance() {
  if (instance==null){
   
   for(int j = 0; j< 100000;j++) 
    //lets say that a thread is involved in something 
    //after coming inside this null checked block
    ;
   
   synchronized(Singleton4.class){
    if (instance==null){
     instance = new Singleton4();
    }
   }
  } 
  return instance;
 }
}

public class TestSingleton4 implements Runnable {

 public static void main(String[] args) {
  int count = 20;
  Thread thread[] = new Thread[count];
  for(int i=0; i< count; i++){
   thread[i] = new Thread(new TestSingleton4());
  }
  for(int j=0; j< count; j++){
   thread[j].start();
  }
  
 }//main()

 @Override
 public void run() {
  Singleton4 instance = Singleton4.getInstance();
  System.out.println("Accessed by " + Thread.currentThread().getName() +
    "; Singleton4 instance is " + instance.hashCode());
  
 }//run()

}

Code snippet 5:

package designpattern;

/**
 * enums are by default singleton, inherently serializable, not clonable, with final fields
 * @author Rajdeep
 *
 */
enum EnumSingleton {
 INSTANCE;
 
 private EnumSingleton(){
  //can initialize something internally
 }
 
 public void doSomething(){
  //do something using same instance
 }
}

public class BestSingleton extends Thread{

 public static void main(String[] args) {
  int count = 100;
  Thread thread[] = new Thread[count];
  for(int i=0; i< count; i++){
   thread[i] = new Thread(new BestSingleton());
  }
  for(int j=0; j< count; j++){
   thread[j].start();
  }
  
 }//main()

 @Override
 public void run() {
  EnumSingleton instance = EnumSingleton.INSTANCE;
  System.out.println("Accessed by " + Thread.currentThread().getName() +
    "; EnumSingleton instance hashcode is " + instance.hashCode());
  
 }//run()

}

Bubble Sorting in Java

2014-04-11T18:57:00.000+05:30

Bubble sorting sorts the array in-place bubbling up the largest value.
Complexity:
Worst case - O(n^2); average case - O(n^2); best case - O(n)

Visualization: (src. Wiki)

package org.algorithms.sorting;
import java.util.Arrays;

public class BubbleSortDemo {
public static void doBubbleSort(int[] args) {
        boolean swapped;
        do {
            swapped = false;
            for (int i=1; i<args.length; i++)
                if (args[i-1] > args[i]) {
                    int temp = args[i - 1];
                    args[i - 1] = args[i];
                    args[i] = temp;
                    swapped = true;
                }
        } while(swapped);
    }

    public static void main(String[] args) {
        int[] numbers = {5,4,3,2,1,6};
        System.out.println("Original: " + Arrays.toString(numbers));
        doBubbleSort(numbers);
        System.out.println("Sorted: " + Arrays.toString(numbers));
    }

}

Output:

Original: [5, 4, 3, 2, 1, 6]
Sorted: [1, 2, 3, 4, 5, 6]

Fibonacci Series in Java

2014-03-20T16:15:00.001+05:30

Q. Print Fibonacci series in Java.
0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55

public class FibonacciSeries {
  
 public static void main(String[] args) {
  int sum = 0;
  //how many numbers to print
  for(int i=0, j=1; i<=10; i++){
   if(i==0){
    //for printing first number which is 0
    System.out.print(0 + ", ");
   }
   else{
    //j has last 'sum', and sum now stores latest added value
    //while the control enters again, j gets latest 'sum' value before
    //new sum is calculated and printed again
    sum = j + (j=sum);
    System.out.print(sum + ", ");
   }
  }
 }
}

Matrix Multiplication in Java

2014-01-30T11:20:00.001+05:30

package com.learning.ds.matrices;
import com.learning.ds.arrays.ArrayUtil;

/**
 * Created by Rajdeep on 28/1/14.
 */
public class MatrixMultiplicationDemo {
    public static void main(String[] args){
        //the temp1 and temp2 array values can be changed to test this program
        int[][] temp1 = {{2,0}};
        int[][] temp2 = {{1,1,1}, {2,2,2}};

        System.out.println("Matrix 1: ");
        ArrayUtil.print2DIntArray(temp1);
        System.out.println("Matrix 2: ");
        ArrayUtil.print2DIntArray(temp2);

        if( !( isFilledMatrix(temp1) && isFilledMatrix(temp2) ) ){
            System.out.println("One of the matrices is not filled completely and can't be used for multiplication.");
        }
        else{
            //check dimension
            if(!areMatricesMultipliable(temp1, temp2)){
                System.out.println("The number of columns in first matrix is unequal to number of rows in second matrix. The must be equal for dot product.");
            }
            else{
                System.out.println("can be multiplied");
                int[][] tempNew = multiplyMatrices(temp1, temp2);
                System.out.println("new matrix is: ");
                ArrayUtil.print2DIntArray(tempNew);
            }
        }
    }

    private static int[][] multiplyMatrices(int[][] temp1, int[][] temp2) {
        //
        int rowCount1 = temp1.length;
        int colCount1 = temp1[0].length;
        int colCount2 = temp2[0].length;

        int[][] tempNew = new int[rowCount1][colCount2];

        for(int i=0; i < rowCount1; i++){
            int k=0;
            while(k < colCount2){
                int tempVal = 0;
                for (int j=0; j < colCount1; j++){
                    tempVal = tempVal + ( temp1[i][j] * temp2[j][k] );
                }
                tempNew[i][k] = tempVal;
                k++;
            }

        }

        return tempNew;
    }

    //matrix multiplication rule is
    //no of columns of left matrix == no of rows in right matrix
    // (m x n) . (n x p) = (m x p)
    private static boolean areMatricesMultipliable(int[][] mat1, int[][] mat2){
        return (mat1[0].length == mat2.length);
    }

    //check the matrix has all elements filled or not
    //In other words, checking whether number of columns in each row is same
    private static boolean isFilledMatrix(int[][] mat){
        boolean retVal = false;
        int rows = mat.length;
        
        if(rows == 1){
            retVal = true;
        }
        else {
            for(int i=0; i < (rows-1); i++){
                if(mat[i].length != mat[i+1].length){
                    retVal = false;
                    break;
                }
                else
                    retVal = true;
            }
        }

        return retVal;
    }
}

The

ArrayUtil.print2DArray(int[][] args)

prints the array on screen through normal 'for' loops.
One sample output:

Matrix 1:
2 0
Matrix 2:
1 1 1
2 2 2
can be multiplied
new matrix is:
2 2 2

Another sample output by changing the temp1 and temp2 arrays in main() method:

Matrix 1::
2 0 3:
Matrix 2::
1 1 1:
2 2 2:
One of the matrices is not filled completely and can't be used for multiplication.

Matrix Operation in Java: Addition of two 2x2 matrices demonstrated

2014-01-27T18:44:00.001+05:30

For addition or subtraction, the dimensions of the matrices must be same. This is just a demonstration code and can be rewritten in a far more optimized manner.

package com.learning.ds.matrices;

/**
 * Created by Rajdeep on 27/1/14.
 */
public class MatrixAdditionDemo {
    public static void main(String[] args){
        int[][] arr1 = {{1,2,3},{4,2,6}};
        int[][] arr2 = {{10,20,30},{40,50,60}};

        System.out.println("Matrix A:");
        for(int i=0; i < arr1.length; i++){
            for(int j=0; j < arr1[i].length; j++){
                System.out.print(arr1[i][j] + " ");
            }
            System.out.println();
        }

        System.out.println("Matrix B:");
        for(int i=0; i < arr2.length; i++){
            for(int j=0; j < arr2[i].length; j++){
                System.out.print(arr2[i][j] + " ");
            }
            System.out.println();
        }

        System.out.println("Addition of A and B:");
        int[][] tempArr = addMatrices(arr1,arr2);
        if(tempArr!=null){
            for(int i=0; i < tempArr.length; i++){
                for(int j=0; j < tempArr[i].length; j++){
                    System.out.print(tempArr[i][j] + " ");
                }
                System.out.println();
            }
        }

    }

    //add the matrices
    private static int[][] addMatrices(int[][] m1, int[][] m2){
        //check size
        if(!ofSameSize(m1, m2)){
            System.out.println("[Error] The matrices' dimension in operation do not match!");
            return null;
        }
        int len1 = m1.length;
        int[][] tempArr = new int[2][3];
        for(int i=0; i < tempArr.length; i++){
            for(int j=0; j < tempArr[i].length; j++){
                tempArr[i][j] = m1[i][j] + m2[i][j];
            }
        }
        return tempArr;
    }

    //for adding, the size must be same
    private static boolean ofSameSize(int[][] m1, int[][] m2) {
        int len1 = m1.length;
        int len2 = m2.length;
        boolean check = true;
        if(len1==len2 & len1!=0){
            //System.out.println("length is: " + len1 + " and " + len2);
            for(int i=0; i < len1; i++){
                if(!(m1[i].length == m2[i].length)){
                    check = false;
                }
            }
        }
        else
            check = false;

        return check;
    }
}

Sample output 1:

Matrix A:
1 2 3
4 2 6

Matrix B:
10 20 30

Addition of A and B:
[Error] The matrices' dimension in operation do not match!

Sample output 2:

Matrix A:
1 2 3
4 2 0

Matrix B:
10 20 30
11 5 3

Addition of A and B:
11 22 33
15 7 3

Quick Sort Demo

2014-01-27T17:20:00.000+05:30

This is a divide and conquer approach. Take a pivot as the last element of array, and place all numbers lesser than this to the left. This is done using partitioning as seen in the code.
Complexity:
Best - O(n logn); Average - O(n logn); Worst - O(n^2)

package org.algorithms.sorting;

import java.util.Arrays;

public class QuickSortDemo {

    public static void main(String...args){
        int[] arr = {4,5,3,2,1,7};
        System.out.println("initial array:"+ Arrays.toString(arr));
        quickSort(arr, 0, arr.length-1);
        System.out.println("\nfinal array:"+Arrays.toString(arr));
    }

    /**
     * Applies the quicksort
     * @param arr The array to be sorted
     * @param start Starting index for sorting
     * @param end End index for sorting
     */
    private static void quickSort(int[] arr, int start, int end) {
        if(start < end) {
            int pIndex = partition(arr,start, end);
            quickSort(arr, start, pIndex-1);
            quickSort(arr, pIndex+1, end);
        }
    }

    /**
     * Push all elements lesser than or equal pivot to left
     * of partition index, and finally, replace pivot with
     * element at partition index, so that we have the sub-array
     * from partition index towards left sorted in ascending fashion.
     * @param start index
     * @param end index
     * @return partition index
     */
    private static int partition(int[] arr, int start, int end) {
        int pivot = arr[end];   //pivot, last element here
        int pIndex = start;       //partition index
        for(int i = start; i<= (end-1); i++)
            if(arr[i] < pivot) {
                swap(arr, i,pIndex);
                pIndex++;
            }
        //now that all elements left to pIndex are lesser
        // than pivot (which is at end until now),
        //swap the pIndex element and pivot, so that
        // the pivot is in correct place now
        swap(arr, pIndex, end);
        return pIndex;
    }

    /**
     * Swaps the elements in the 'arr' array on specified indices
     * @param index1
     * @param index2
     */
    private static void swap(int[] arr, int index1, int index2) {
        int temp = arr[index1];
        arr[index1] = arr[index2];
        arr[index2] = temp;
    }

}

Learning Data Structures now

2013-12-30T17:28:00.001+05:30

Nowadays, I am learning data structures starting with simple sorting techniques, searches, linked-list, stack algorithms etc, and I will post about my experiences. I don't know how far, but I'll share so far I learn. :-)

Insertion Sorting Logic

2013-12-30T13:26:00.000+05:30

Insertion sort iterates, consuming one input element each repetition, and growing a sorted output list. Each iteration, insertion sort removes one element from the input data, finds the location it belongs within the sorted list, and inserts it there. It repeats until no input elements remain. -Wiki

The insertion sorting logic is as follows: An array with one element is already sorted. For multiple elements, take an element starting from index 1 into temp variable, and sort its left, then place the temp to its correct location.
Now take 2nd element into temp variable, and sort its indices 0, 1 and 2. Put value at temp to appropriate location.
We are looking left of the pivot element that we have stored in temp variable in each iteration, while gradually moving towards right direction while sorting the portion of the array from the pivot to the beginning. The appropriate location is found when do not find a value in the left side of array which can be sorted after comparing with temp, so we put temp there.

Complexity:
Best - O(n), average - O(n^2), worst - O(n^2)

package org.algorithms.sorting;

import java.util.Arrays;

public class InsertionSortDemo {
    public static void main(String[] args) {
        int[] numbers = {5,4,3,2,1};
        System.out.println(Arrays.toString(numbers));
        
        if (numbers.length > 1)
            doInsertionSort(numbers);
        
        System.out.println(Arrays.toString(numbers));
    }

    public static void doInsertionSort(int[] input){
        for (int i = 1; i < input.length; i++) {
            int j = i;
            //does not runs for sorted array, leaving best case to O(n)
            while (j>0 && input[j-1] > input[j]) {
                swap(input, j, j - 1);
                j--;
            }
            //O(n^2) even for sorted array
            /*for(int j = i ; j > 0 ; j--) {
                System.out.println("ran ");
                if(input[j] < input[j-1])
                    swap(input,j,j-1);
                    }*/
        }
    }

    private static void swap(int[] input, int i, int j) {
        int temp = input[i];
        input[i] = input[j];
        input[j] = temp;
    }
}

Visualization:

5 4 3 2 1 (in)

i=1
j=1 :: 4 5 3 2 1
i=2
j=2 :: 4 3 5 2 1
j=1 :: 3 4 5 2 1
i=3
j=3 :: 3 4 2 5 1
j=2 :: 3 2 4 5 1
j=1 :: 2 3 4 5 1
i=4
j=4 :: 2 3 4 1 5
j=3 :: 2 3 1 4 5
j=2 :: 2 1 3 4 5
j=1 :: 1 2 3 4 5

LinkedList: Node creation and display example

2013-12-16T01:20:00.000+05:30

package ds;

/**
 * @author Rajdeep
 * 
 * Note
 * Creating the list:
 * 1. 'start' refers to the first node and 'now' is made to refer to the latest
 *   added node.
 * 2. after creating the first linkedlist object and assigning value,
 *   'start' points to it because we are checking for start==null
 *   'start' is null in first node addition only.
 *   'now' also points to it, this being the latest node.
 * 3. Second node onwards, start is never null, so control goes to else part.
 *   'now.next' points to nothing because its of reference type.
 *   so assign 'now.next' to the newly created object after
 *   checking 'now.next==null'.
 * 4. Now 'start' pointed or the first object's (node's) 'next' part is linked
 *   to the 2nd object since now was referring to it, and then after
 *   'while' execution, 'now' points to the newly created node, referred by
 *   the local 'temp' variable.
 * 5. e.g.: start -> [10|add1] at add0 -> [20|add2] at add1 -> [30|NULL] at add2;
 *   'now' points to this add2 having info 30, and 'now.next' is NULL,
 *   so that when another node is created, 'now.next' refers to the new
 *   node, and then 'now' refers to the new node, and so on.
 * 
 * Displaying the list:
 * We start from the starting node, and display 'info' part of each node, and
 * move on to next node by checking the current node's 'next' part is not null.
 */

// This is the Linked List node
class LinkedList{
 int info;   //has value
 LinkedList next; //for pointing to next node
}

// Demonstration on creation of node and displaying the values
public class LinkedListDemo {

 static LinkedList start = null;
 static LinkedList now = null;
 
 public static void main(String[] args) {
  createNode(0);
  createNode(1);
  createNode(5);
  createNode(7);
  createNode(10);
  createNode(11);
  createNode(54);
  createNode(76);
  
  display();
 }
 
 static void createNode(int val){
  LinkedList temp = new LinkedList();
  
  temp.info = val;
  if (start==null){
   start = temp;
   now = temp;
  }
  else{
   while(now.next==null){
    now.next=temp; 
   }
   now = temp;
  }
 }
 
 static void display(){
  LinkedList temp = start;
  System.out.print("[");
  while(temp!=null){
   System.out.print(temp.info + "|");
   temp = temp.next;
  }
  System.out.println("\b]");
 }

}

The output will be:

[0|1|5|7|10|11|54|76]

This was a demo program for my understanding, and now I understand how the nodes are connected, and so the term "linked list".

The try-catch-finally love affair!

2013-10-01T11:32:00.000+05:30

Ok, everybody here already know about the affair, I am just discussing some more bits of this love triangle.
Lets dig hard to the shallow level :)

try{
    //try something
}
//and if the trial goes wrong, catch the issue and handle
catch(Exception e){
    //handling the problematic part
    //or at least letting the program to continue
    //and exit gracefully and not shut at face!
}
//but
finally{
    //do this, so you are the winner!!
}

So from even the baddest of our common-sense, we smell that finally block supercedes the two others, viz., try and catch. Lets prove a point in this.

class Dodo {

    public static void main(String...args) {
        int num = doSomething();
        System.out.println(num);
    }

    private static int doSomething() {
        try {
            return (1+2+3);
        }
        catch(Exception e) {
            return -1;
        }
        finally {
            return 0;
        }
    }
}

The output will always be 0.
So, basically, I can have a conversation as follows:

Asker: Dude, what you are gonna do with this finally?
Me: Ok dude, since this is the one that will be run no matter how my program logic screws up in the try block, I may write only that part which will not throw any problems like (1+2*3). But I will not. I will not involve my business logic in this love-triangle.
Asker: What then?
Me: I'd love to clear up things only.
Asker: I'm not clear!
Me: For example, if I am doing input-output operations, then I will close the connections in finally and nullify the references to help Mr. GC.
Asker: Ok
Me: Enjoy!

public class TCFTest {
    static int i;
    public static void main(String[] args) {
        m1();
        System.out.println(i); //What will be the output? ^_^
    }
    static void m1(){
        //the value of static variable 'i' will be set
        try{
            i= 1;
            try{
                i= 4;
            }
            finally{
                i= 5;
            }
        }
        catch(Exception e){
            i= 2;
        }
        finally{
            i= 3;
            try{
                i= 6;
            }
            finally{
                i= 7;
            }
        }
    }//m1() end
}