Category Archives: object

Breaking singleton pattern


Singleton pattern in java can be implemented by the approaches explained here

Now here is the code to break it using reflection


public class NormalClass{

 private NormalClass(){ //having private constructor
 }

 private void print(){
 System.out.println("broken");
 }

}

/////////////////////////////////

public class Main{

 public static void main(String[] args) throws InstantiationException, IllegalAccessException, SecurityException, NoSuchMethodException, IllegalArgumentException, InvocationTargetException {

 Class c = NormalClass.class;
 final Constructor con = c.getDeclaredConstructor();
 System.out.println(con);

 final Method meth = c.getDeclaredMethod("print", null);

//---- You will get IllegalAccessException without this ---
AccessController.doPrivileged(new PrivilegedAction() {

public Object run() {
 con.setAccessible(true);// turning off the access check
 meth.setAccessible(true);// turning off the access check
return null;
 }

});

 NormalClass n = (NormalClass)con.newInstance(null);
 meth.invoke(n,null);
 }

}

Producer and Consumer Problem


Self explanatory Producer and Consumer problem

Producer.java

package com.producer;

import java.util.ArrayList;

import java.util.Random;

public class Producer implements Runnable{

//Engine Batch ID reference

ArrayList engineList;

//Engine No is stored here

String str;

//Assigning the BATCH ID reference

public Producer(ArrayList engineList) {

this.engineList = engineList;

}

/*

* Produce Engines

*/

public void produce(){

//Random number for engine number

str = ""+Math.abs(new Random(System.currentTimeMillis()).nextLong());

//Only one thread can enter the BATCH for any operation

synchronized (engineList) {

//Add the Engine to the batch

engineList.add(str);

//Notify all other threads that the new engine is added to the BATCH

engineList.notifyAll();

}

//Print Engine Number

System.out.println("Produced :: ENGINE CHASIS NO ["+ str + "]");

}

@Override

public void run() {

System.out.println("Production started");

//10 Engine is to be produced

for(int i=0;i<10;i++){

try {

//Produce the engine

this.produce();

//Sleep for 2 seconds for the next operation

Thread.sleep(2000);

} catch (InterruptedException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

}

}

}

Consumer.java


package com.producer;

import java.util.ArrayList;

public class Consumer extends Thread{

//Engine Batch ID reference

ArrayList<String> engineList;

//Engine No is stored here

String str;

//Assigning the BATCH ID reference

public Consumer(ArrayList<String> engineList) {

this.engineList = engineList;

}

/*

* Consume Engines from the BATCH

*/

public  void consume(int index) throws InterruptedException{

//Only one thread can enter the BATCH for any operation

synchronized (engineList) {

//if the Batch has no engines

while(engineList.size() == 0){

//then wait for some time until you get a new engine to consume

engineList.wait();

}

//If the engine is deployed to the BATCH

if(engineList.size() >= 0){

//The consume the engine from the respective position

str = engineList.get(index);

}

}

//Print Engine Number that it has been consumed

System.out.println("Consumed :: -------> ENGINE CHASIS NO ["+ str + "]" );

}

@Override

public void run() {

//10 Engine has to be consumed

for(int i=0;i<10;i++){

try {

//Produce the engine

this.consume(i);

//Sleep for 3 seconds for the next operation

Thread.sleep(3000);

} catch (InterruptedException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

}

}

}

Main.java


package com.producer;

import java.util.ArrayList;

public class Main {

public static void main(String[] args) throws InterruptedException {

//ArrayList to store the produced engines - BATCH

ArrayList<String> engine = new ArrayList<String>();

//Producer taking the engine BATCH ID Reference

Producer producer = new Producer(engine);

//Consumer taking the reference of the engine BATCH ID Reference

Consumer consumer = new Consumer(engine);

//Threads

Thread prodThread = new Thread(producer);

Thread conThread = new Thread(consumer);

//Starting the production

prodThread.start();

//Start Consumption

conThread.start();

}

}


Thoughts on Java that works


Disclaimer: This is just to get an idea of the implementation, please do not copy the source code

The problem reads like

SALES TAXES
Basic sales tax is applicable at a rate of 10% on all goods, except books,
food, and medical products that are exempt. Import duty is an additional
sales tax applicable on all imported goods at a rate of 5%, with no
exemptions.
When I purchase items I receive a receipt which lists the name of all the
items and their price (including tax), finishing with the total cost of the
items, and the total amounts of sales taxes paid.  The rounding rules for
sales tax are that for a tax rate of n%, a shelf price of p contains
(np/100 rounded up to the nearest 0.05) amount of sales tax.
Write an application that prints out the receipt details for these shopping
baskets…

Find the complete solved solution here

MARS ROVERS
A squad of robotic rovers are to be landed by NASA on a plateau on Mars.
This plateau, which is curiously rectangular, must be navigated by the
rovers so that their on-board cameras can get a complete view of the
surrounding terrain to send back to Earth.

A rover’s position and location is represented by a combination of x and y
co-ordinates and a letter representing one of the four cardinal compass
points. The plateau is divided up into a grid to simplify navigation. An
example position might be 0, 0, N, which means the rover is in the bottom
left corner and facing North.

In order to control a rover, NASA sends a simple string of letters. The
possible letters are ‘L’, ‘R’ and ‘M’. ‘L’ and ‘R’ makes the rover spin 90
degrees left or right respectively, without moving from its current spot.
‘M’ means move forward one grid point, and maintain the same heading.

Assume that the square directly North from (x, y) is (x, y+1).

Find the complete solved solution here

Single object for Singleton pattern


I have explained the basics of singleton pattern here https://vtkrishn.wordpress.com/2010/03/26/singleton-pattern-revisited/

The design goes like this

1) private constructor
2) static method to return the single objects

In this post I am going to explain some additional restrictions on this pattern

1) Lazy initialization with double lock mechanism

2) Early initialization

3) Serialization

4) ClassLoaders

5) Restrict Cloning

Lazy instantiation using double locking mechanism

The standard implementation shown in the code above is a thread safe implementation, but it’s not the best thread-safe implementation because synchronization is very expensive when we are talking about the performance. We can see that the synchronized method getInstance does not need to be checked for synchronization after the object is initialized. If we see that the singleton object is already created we just have to return it without using any synchronized block. This optimization consist in checking in an un-synchronized block if the object is null and if not to check again and create it in an synchronized block. This is called double locking mechanism.

In this case case the singleton instance is created when the getInstance() method is called for the first time. This is called lazy instantiation and it ensures that the singleton instance is created only when it is needed.

//Lazy instantiation using double locking mechanism.
class Singleton
{
 private static Singleton m_instance;

 private Singleton()
 {
 System.out.println("Singleton(): Initializing Instance");
 }

 public static Singleton getInstance()
 {
 if (m_instance == null)
 {
 synchronized(Singleton.class)
 {
 if (m_instance == null)
 {
 System.out.println("getInstance(): First time getInstance was invoked!");
 m_instance = new Singleton();
 }
 }
 }

 return m_instance;
 }

 public void doSomething()
 {
 System.out.println("doSomething(): Singleton does something!");
 }
}

Early instantiation using implementation with static field

In the following implementattion the singleton object is instantiated when the class is loaded and not when it is first used, due to the fact that the m_instance member is declared static. This is why in this implementation we don’t need to syncronize any portion of the code. The class is loaded once this guarantee the unicity of the object

//Early instantiation using implementation with static field.
class Singleton
{
 private static Singleton m_instance = new Singleton();

 private Singleton()
 {
 System.out.println("Singleton(): Initializing Instance");
 }

 public static Singleton getInstance()
 {
 return m_instance;
 }

 public void doSomething()
 {
 System.out.println("doSomething(): Singleton does something!");
 }
}

Serialization

If the Singleton class implements the java.io.Serializable interface, when a singleton is serialized and then deserialized more than once, there will be multiple instances of Singleton created. In order to avoid this the readResolve method should be implemented. See Serializable () and readResolve Method () in javadocs.

 public class Singleton implements Serializable {
 ...

 // This method is called immediately after an object of this class is deserialized.
 // This method returns the singleton instance.
 protected Object readResolve() {
 return getInstance();
 }
 }

ClassLoaders

If you have multiple classloaders(possibilities in case of servlet container) then the patterns will allow for multiple instances to be created which is not expected
To overcome this you have to have the custom implementation like

private static Class getClass(String classname)
 throws ClassNotFoundException {
 ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
 if(classLoader == null)
 classLoader = Singleton.class.getClassLoader();
 return (classLoader.loadClass(classname));
 }
}

Restrict Cloning

You can overcome cloning of the singleton object by explicitly throwing cloneNotSupportedException

public Object clone() throws CloneNotSupportedException {
 throw new CloneNotSupportedException();
 }

If we try to access the above singleton object using reflection then you will get

Exception in thread "Main Thread" java.lang.IllegalAccessException: Class com.example.thread.Main can not access a member of class com.simple.NormalClass with modifiers "private"
 at sun.reflect.Reflection.ensureMemberAccess(Reflection.java:65)
 at java.lang.Class.newInstance0(Class.java:349)
 at java.lang.Class.newInstance(Class.java:308)
 at com.example.thread.Main.main(Main.java:10)

if you are using java 1.5 and above you can use enum type which takes care of all the above


public enum Singleton{
INSTANCE;

public static void print(){
System.out.println("hi");
}

public class Main{

public static void main(String[] args) {
Singleton.INSTANCE.print();
}
}
}

OODesign concepts


Some of the main oodesign principles are available here
I hope this will help developers understand the oo concept more efficiently.

http://www.oodesign.com/design-principles.html

Refactoring the code


I suggest this link for those who wanted to refactor their code without any side effects

http://www.refactoring.com/catalog/index.html

Solving NumberFormatException


Often we tend to parse the integer value from a String object using Integer.valueOf(strValue) or Integer.parseInt(strValue). This will work as far as we pass the string like ‘1234567’ without any grouping.. The problme arises only if we have grouping on the string which is parsed..

Bump..

parseInt() and valueOf() method throws NumberFormatException for this.

So how to resolve this,

rewrite the code and make use of parse() method in java.text.NumberFormat class

String str = "123,456";
 int i = 0;
 try {
 i = NumberFormat.getNumberInstance().parse(str).intValue();
 } catch (ParseException e) {
 e.printStackTrace();
 }
 System.out.println(i);

hashcode() contract with equals()


the hashCode() method in the Object class has some specific contract with the equals() method.. Do you know that?

let’s see why these methods are there in the Object class

hashCode() – the hash code method is used to return the hash code value for the object,  this is an excerpt from the Javadoc.

This method will be used to compute or locate the object in the memory. If the object is moved to a different location during garbage collection, the hash code remains the same to locate the object. This is implemented in Object class by mapping the memory address to an integer.

The below code in Object class maps to a native implementation of the above statement


public native int hashCode();

Common Misconceptions

  • hashCode() is not unique as we suppose.
  • hashCode() is not something which is derived from some value within the object or a random number.
  • hashCode() is unsigned.

some of the implementation of this in JDK can be got from some-interesting-hashcode-values

equals() – This method is used to compare the objects.

This is method has to be used for non-null objects. Some common properties for equals() method are

  • reflexive -x.equals(x) should return true (x==x)
  • symmetryx.equals(y) , y.equals(x) should return true (x==y, y==x)
  • transitivex.equals(y) , y.equals(z) , x.equals(z) should return true (x==y,y==z, x== z)
  • consistency– when y.equals(x) is called multiple times it should provide consistent result
  • nullCheck x.equals(null) should return false
public boolean equals(Object obj) {
 return (this == obj);
 }

Now, what is the contract between these two methods?

  • when equals() between two objects return’s true then hashCode() should always return the same value for both objects.
  • when equals() returns false then hashCode() need not be the same but its desirable.
  • how many times the methods are invoked it should return the same result unless the data used in the methods are modified.

its customary to override hashCode() method whenever equals() method is overridden.

lets have an example of the implementation of the equals() and hashCode() method

 @Override
 public boolean equals(Object obj) {
 // TODO Auto-generated method stub

 if (obj instanceof hashEqualsText) {
 return true;
 }
 return false;
 }
<pre>

the equals method checks if the object is an instance of the another object and returns the output and hashCode method is made to return 1 as the hash code value

 @Override
 public int hashCode() {
 // TODO Auto-generated method stub
 return 1; //some value
 }

find the complete analysis of the hashCode() and equals() method contract

 public class hashEqualsText{

 public static void main(String[] args) throws CloneNotSupportedException {

 hashEqualsText x = new hashEqualsText();
 hashEqualsText y = x;
 hashEqualsText z = new hashEqualsText();

 Object object = new Object();

 String str = "vinod";
 String strSame = "vinod";
 String strDifferent = "vinodAndOthers";

 Boolean bool = true;
 Boolean boolSame = true;
 Boolean boolDifferent = false;

 Integer intt = 123456789;
 Integer inttSame = 123456789;
 Integer inttDifferent = 2222222;

 Long longg = 12121212121212122L;
 Long longgSame = 12121212121212122L;
 Long longgDifferent = 11111111111111111L;

 Character chr = 'a';
 Character chrSame = 'a';
 Character chrDifferent = 'z';

 //hashCode contract
 System.out.println("-----------------hashCode contract-----------------");

 System.out.println("Overrided hashCode of x::"+x.hashCode()+" - Original hashCode of x::" +System.identityHashCode(x));
 System.out.println("Overrided hashCode of y::"+y.hashCode()+" - Original hashCode of y::" +System.identityHashCode(y));
 System.out.println("Overrided hashCode of z::"+z.hashCode()+" - Original hashCode of z::" +System.identityHashCode(z));

 //equals contract
 System.out.println("-----------------equals contract-----------------");

 System.out.println("reflexive - x.equals(x) should return true :: "+x.equals(y));
 System.out.println("symmetric - x and y, x.equals(y)  should return true if and only if y.equals(x) returns true :: "+x.equals(y) + "< -- >"+y.equals(x));
 System.out.println("transitive - x, y, and z, if x.equals(y) returns true and y.equals(z) returns true, then x.equals(z) should return true :: "+x.equals(y)+"==="+y.equals(z)+"==>"+x.equals(z));
 System.out.println("null check - x.equals(null) should return false always:: "+ x.equals(null));

 //for objects
 System.out.println("-----------------for same Objects-----------------");

 System.out.println("x == y has the value true :: "+(x == y));
 System.out.println("x.equals(y) has the value true :: "+(x.equals(y)));
 System.out.println("x.hashCode() == y.hashCode() has the value true :: "+(x.hashCode() == y.hashCode()));

 //for different objects
 System.out.println("-----------------for different Objects-----------------");

 System.out.println("object hashcode value :: "+(object.hashCode()));
 System.out.println("x == object has the value false :: "+(x == object));
 System.out.println("x.equals(object) has the value false :: "+(x.equals(object)));
 System.out.println("x.hashCode() == object.hashCode() has the value false :: "+(x.hashCode() == object.hashCode()));

 //for same String
 System.out.println("-----------------for same String-----------------");

 System.out.println("str hashcode value :: "+(str.hashCode()));
 System.out.println("strSame hashcode value :: "+(strSame.hashCode()));
 System.out.println("str == strSame has the value true :: "+(str == strSame));
 System.out.println("str.equals(strSame) has the value true :: "+(str.equals(strSame)));
 System.out.println("str.hashCode() == strSame.hashCode() has the value true :: "+(str.hashCode() == strSame.hashCode()));

 //for different String
 System.out.println("-----------------for different String-----------------");

 System.out.println("str hashcode value :: "+(str.hashCode()));
 System.out.println("strDifferent hashcode value :: "+(strDifferent.hashCode()));
 System.out.println("str == strDifferent has the value false :: "+(str == strDifferent));
 System.out.println("str.equals(strDifferent) has the value false :: "+(str.equals(strDifferent)));
 System.out.println("str.hashCode() == strDifferent.hashCode() has the value false :: "+(str.hashCode() == strDifferent.hashCode()));

 //for same Boolean
 System.out.println("-----------------for same Boolean-----------------");

 System.out.println("bool hashcode value :: "+(bool.hashCode()));
 System.out.println("boolSame hashcode value :: "+(boolSame.hashCode()));
 System.out.println("bool == boolSame has the value true :: "+(bool == boolSame));
 System.out.println("bool.equals(boolSame) has the value true :: "+(bool.equals(boolSame)));
 System.out.println("bool.hashCode() == boolSame.hashCode() has the value true :: "+(bool.hashCode() == boolSame.hashCode()));

 //for different Boolean
 System.out.println("-----------------for different Boolean-----------------");

 System.out.println("bool hashcode value :: "+(bool.hashCode()));
 System.out.println("boolDifferent hashcode value :: "+(boolDifferent.hashCode()));
 System.out.println("bool == boolDifferent has the value false :: "+(bool == boolDifferent));
 System.out.println("bool.equals(boolDifferent) has the value false :: "+(bool.equals(boolDifferent)));
 System.out.println("bool.hashCode() == boolDifferent.hashCode() has the value false :: "+(bool.hashCode() == boolDifferent.hashCode()));

 //for same Integer
 System.out.println("-----------------for same Integer-----------------");

 System.out.println("intt hashcode value :: "+(intt.hashCode()));
 System.out.println("inttSame hashcode value :: "+(inttSame.hashCode()));
 System.out.println("intt == inttSame has the value true :: "+(intt == inttSame));
 System.out.println("intt.equals(inttSame) has the value true :: "+(intt.equals(inttSame)));
 System.out.println("intt.hashCode() == inttSame.hashCode() has the value true :: "+(intt.hashCode() == inttSame.hashCode()));

 //for different Integer
 System.out.println("-----------------for different Integer-----------------");

 System.out.println("intt hashcode value :: "+(intt.hashCode()));
 System.out.println("inttDifferent hashcode value :: "+(inttDifferent.hashCode()));
 System.out.println("intt == inttDifferent has the value false :: "+(intt == inttDifferent));
 System.out.println("intt.equals(inttDifferent) has the value false :: "+(intt.equals(inttDifferent)));
 System.out.println("intt.hashCode() == inttDifferent.hashCode() has the value false :: "+(intt.hashCode() == inttDifferent.hashCode()));

 //for same Long
 System.out.println("-----------------for same Long-----------------");

 System.out.println("longg hashcode value :: "+(longg.hashCode()));
 System.out.println("longgSame hashcode value :: "+(longgSame.hashCode()));
 System.out.println("longg == longgSame has the value true :: "+(longg == longgSame));
 System.out.println("longg.equals(longgSame) has the value true :: "+(longg.equals(inttSame)));
 System.out.println("longg.hashCode() == longgSame.hashCode() has the value true :: "+(longg.hashCode() == longgSame.hashCode()));

 //for different Long
 System.out.println("-----------------for different Long-----------------");

 System.out.println("longg hashcode value :: "+(longg.hashCode()));
 System.out.println("longgDifferent hashcode value :: "+(longgDifferent.hashCode()));
 System.out.println("longg == longgDifferent has the value false :: "+(longg == longgDifferent));
 System.out.println("longg.equals(longgDifferent) has the value false :: "+(longg.equals(longgDifferent)));
 System.out.println("longg.hashCode() == longgDifferent.hashCode() has the value false :: "+(longg.hashCode() == longgDifferent.hashCode()));

 //for same Character
 System.out.println("-----------------for same Character-----------------");

 System.out.println("chr hashcode value :: "+(chr.hashCode()));
 System.out.println("chrSame hashcode value :: "+(chrSame.hashCode()));
 System.out.println("chr == chrSame has the value true :: "+(chr == chrSame));
 System.out.println("chr.equals(chrgSame) has the value true :: "+(chr.equals(chrSame)));
 System.out.println("chr.hashCode() == chrSame.hashCode() has the value true :: "+(chr.hashCode() == chrSame.hashCode()));

 //for same Character
 System.out.println("-----------------for same Character-----------------");

 System.out.println("chr hashcode value :: "+(chr.hashCode()));
 System.out.println("chrDifferent hashcode value :: "+(chrDifferent.hashCode()));
 System.out.println("chr == chrDifferent has the value false :: "+(chr == chrDifferent));
 System.out.println("chr.equals(chrDifferent) has the value false :: "+(chr.equals(chrDifferent)));
 System.out.println("chr.hashCode() == chrDifferent.hashCode() has the value false :: "+(chr.hashCode() == chrDifferent.hashCode()));

 }

 @Override
 public boolean equals(Object obj) {
 // TODO Auto-generated method stub

 if (obj instanceof hashEqualsText) {
 return true;
 }
 return false;
 }

 @Override
 public int hashCode() {
 // TODO Auto-generated method stub
 return 1;
 }
 }

The output is as follows

-----------------hashCode contract-----------------
Overrided hashCode of x::1 - Original hashCode of x::7214088
Overrided hashCode of y::1 - Original hashCode of y::7214088
Overrided hashCode of z::1 - Original hashCode of z::15020296
-----------------equals contract-----------------
reflexive - x.equals(x) should return true :: true
symmetric - x and y, x.equals(y)  should return true if and only if y.equals(x) returns true :: true< -- >true
transitive - x, y, and z, if x.equals(y) returns true and y.equals(z) returns true, then x.equals(z) should return true :: true===true==>true
null check - x.equals(null) should return false always:: false
-----------------for same Objects-----------------
x == y has the value true :: true
x.equals(y) has the value true :: true
x.hashCode() == y.hashCode() has the value true :: true
-----------------for different Objects-----------------
object hashcode value :: 16130931
x == object has the value false :: false
x.equals(object) has the value false :: false
x.hashCode() == object.hashCode() has the value false :: false
-----------------for same String-----------------
str hashcode value :: 112212784
strSame hashcode value :: 112212784
str == strSame has the value true :: true
str.equals(strSame) has the value true :: true
str.hashCode() == strSame.hashCode() has the value true :: true
-----------------for different String-----------------
str hashcode value :: 112212784
strDifferent hashcode value :: -1181071670
str == strDifferent has the value false :: false
str.equals(strDifferent) has the value false :: false
str.hashCode() == strDifferent.hashCode() has the value false :: false
-----------------for same Boolean-----------------
bool hashcode value :: 1231
boolSame hashcode value :: 1231
bool == boolSame has the value true :: true
bool.equals(boolSame) has the value true :: true
bool.hashCode() == boolSame.hashCode() has the value true :: true
-----------------for different Boolean-----------------
bool hashcode value :: 1231
boolDifferent hashcode value :: 1237
bool == boolDifferent has the value false :: false
bool.equals(boolDifferent) has the value false :: false
bool.hashCode() == boolDifferent.hashCode() has the value false :: false
-----------------for same Integer-----------------
intt hashcode value :: 123456789
inttSame hashcode value :: 123456789
intt == inttSame has the value true :: false
intt.equals(inttSame) has the value true :: true
intt.hashCode() == inttSame.hashCode() has the value true :: true
-----------------for different Integer-----------------
intt hashcode value :: 123456789
inttDifferent hashcode value :: 2222222
intt == inttDifferent has the value false :: false
intt.equals(inttDifferent) has the value false :: false
intt.hashCode() == inttDifferent.hashCode() has the value false :: false
-----------------for same Long-----------------
longg hashcode value :: -1634700041
longgSame hashcode value :: -1634700041
longg == longgSame has the value true :: false
longg.equals(longgSame) has the value true :: false
longg.hashCode() == longgSame.hashCode() has the value true :: true
-----------------for different Long-----------------
longg hashcode value :: -1634700041
longgDifferent hashcode value :: 653330616
longg == longgDifferent has the value false :: false
longg.equals(longgDifferent) has the value false :: false
longg.hashCode() == longgDifferent.hashCode() has the value false :: false
-----------------for same Character-----------------
chr hashcode value :: 97
chrSame hashcode value :: 97
chr == chrSame has the value true :: true
chr.equals(chrgSame) has the value true :: true
chr.hashCode() == chrSame.hashCode() has the value true :: true
-----------------for same Character-----------------
chr hashcode value :: 97
chrDifferent hashcode value :: 122
chr == chrDifferent has the value false :: false
chr.equals(chrDifferent) has the value false :: false
chr.hashCode() == chrDifferent.hashCode() has the value false :: false