Simplify Java Coding

Simplify Sorting of objects with Java Collections

noreply@blogger.com (Ashish) — Mon, 04 Apr 2011 09:02:00 +0000

Generic ways to sort the collection of user define objects.

Basically we used the sort method of the collections class to sort the objects. Specific sorter class or anonymous inner class every time we have to write to sort the collection objects. By default if class implements comparable interface then Collections.sort method used the methods overridden by the class. If we have to override the default behavior of the comparable interface then we have to supply methods of comparator.

Code snippet 1:

User define View Object (VO) has following properties

package com.myorg.vo;

public class User {

private Integer userid;

private String firstName;

private String lastName;

private String userType;

public Integer getUserid() {

return userid;

}

public void setUserid(Integer userid) {

this.userid = userid;

}

public String getFirstName() {

return firstName;

}

public void setFirstName(String firstName) {

this.firstName = firstName;

}

public String getLastName() {

return lastName;

}

public void setLastName(String lastName) {

this.lastName = lastName;

}

public String getUserType() {

return userType;

}

public void setUserType(String userType) {

this.userType = userType;

}

public User(Integer userid, String firstName, String lastName,

String userType) {

this.userid = userid;

this.firstName = firstName;

this.lastName = lastName;

this.userType = userType;

}

public User(){}

@Override

public String toString() {

return "UserID ("+ userid + ") First Name ("+firstName+ ") Last Name ("+lastName+") UserType ("+userType+ ")";

}

Code Snippet 2:

Sort the list of users according to user id. Generally we write the comparator to sort the result as shown in code snippet 2

/**

* @author Ashish.Chudasama

public class Main {

public static void main(String[] args) {

List<User> lstUsers = new ArrayList<User>();

lstUsers.add(new User(2, "Amit", "Sharma", "Admin"));

lstUsers.add(new User(4, "Tusha", "Koli", "P1"));

lstUsers.add(new User(1, "Ashish", "Chudasama", "P2"));

lstUsers.add(new User(3, "Amit", "Jhala", "P2"));

// sort the user by user id

Collections.sort(lstUsers, new Comparator<User>() {

@Override

public int compare(User u1, User u2) {

//for ascending Order

return u1.getUserid().compareTo(u2.getUserid());

// for Descending order

//return u2.getUserid().compareTo(u1.getUserid());

}

});

for (User user : lstUsers) {

System.out.println(user);

}

Output:

UserID (1) First Name (Tusha) Last Name (Koli) UserType (P1)

UserID (2) First Name (Riten) Last Name (Jhala) UserType (P1)

UserID (3) First Name (Ashish) Last Name (Chudasama) UserType (P2)

UserID (4) First Name (Amit) Last Name (Sharma) UserType (Admin)

Generic way to sort the any user define class object can be accomplished using combination of generic type and reflection as shown in code snippet 3.

Code snippet 3:

This code snippet describe how to write the generic sorter that sort any types of data types in ascending and descending order. By default sorter sort the result into ascending order. We can change the order by supplying order by operation through overloaded constructors.

package com.sorter.multilevel;

import java.lang.reflect.Field;

import java.util.Comparator;

import java.util.Date;

/**

* This class used to sort the User define objects.

* This class simulate the SQL like feature provided by the Orderby clause.

* @author Ashish.Chudasama

class GenericSorter<T> implements Comparator<T> {

public static int ASC = 1;

public static int DESC = 2;

Comparator<T> chainComparator = null;

String fieldName;

int orderBy = ASC;

/**

* @param fieldName

public GenericSorter(String fieldName) {

this.fieldName = fieldName;

}

public GenericSorter(String fieldName, int orderBy) {

this.fieldName = fieldName;

this.orderBy = orderBy;

}

/**

* @param chainComparator

* @param fieldName

public GenericSorter(String fieldName, Comparator<T> chainComparator) {

this.chainComparator = chainComparator;

this.fieldName = fieldName;

}

public GenericSorter(String fieldName, int orderBy,

Comparator<T> chainComparator) {

this.chainComparator = chainComparator;

this.fieldName = fieldName;

this.orderBy = orderBy;

}

@Override

public int compare(T o1, T o2) {

int result = this.orderBy == ASC ? compareValue(o1, o2) : compareValue(

o2, o1);

if (result == 0 && chainComparator != null) {

result = chainComparator.compare(o1, o2);

}

return result;

}

private int compareValue(T o1, T o2) {

int returnValue = 0;

try {

//obtain the filed.

Field field = o1.getClass().getDeclaredField(this.fieldName);

boolean isAccessible=true;

//check field is accessible or not

// if not then enable the access

if(!field.isAccessible())

{

field.setAccessible(true);

isAccessible=false;

}

//Retrieve fields values

Object objectO1 = field.get(o1);

Object objectO2 = field.get(o2);

// check for the number

if (objectO1 instanceof Number) {

if ((objectO1 != null && objectO2 != null)

&& (objectO1 instanceof Integer

|| objectO1 instanceof Long || objectO1 instanceof Byte)) {

returnValue = Long.valueOf(objectO1 + "").compareTo(

Long.valueOf(objectO2 + ""));

} else if ((objectO1 != null && objectO2 != null)

&& (objectO1 instanceof Double || objectO1 instanceof Float)) {

returnValue = Double.valueOf(objectO1 + "").compareTo(

Double.valueOf(objectO2 + ""));

}

} else if (objectO1 instanceof String

|| objectO1 instanceof Character) {

if ((objectO1 != null) && objectO2 != null) {

returnValue = String.valueOf(objectO1).compareToIgnoreCase(

String.valueOf(objectO2));

}

} else if (objectO1 instanceof Date) {

returnValue = ((Date) objectO1).compareTo((Date) objectO2);

}

//reset the field access

field.setAccessible(isAccessible);

} catch (Exception e) {

e.printStackTrace();

}

return returnValue;

}

Code snippet 4:

The code snippet 4 demonstrates the used of GenericSorter class to sort the list of users in ascending order according to userId field.

/**

* @author Ashish.Chudasama

public class Main {

public static void main(String[] args) {

List<User> lstUsers = new ArrayList<User>();

lstUsers.add(new User(4, "Amit", "Sharma", "Admin"));

lstUsers.add(new User(1, "Tusha", "Koli", "P1"));

lstUsers.add(new User(3, "Ashish", "Chudasama", "P2"));

lstUsers.add(new User(2, "Riten", "Jhala", "P1"));

// sort the user by user id

Collections.sort(lstUsers, new GenericSorter<User>("userid"));

/**

* Note: userid is a field name/variable name of class user

for (User user : lstUsers) {

System.out.println(user);

}

Output:

UserID (1) First Name (Tusha) Last Name (Koli) UserType (P1)

UserID (2) First Name (Riten) Last Name (Jhala) UserType (P1)

UserID (3) First Name (Ashish) Last Name (Chudasama) UserType (P2)

UserID (4) First Name (Amit) Last Name (Sharma) UserType (Admin)

Code snippet 5:

The code snippet 5 demonstrates the used of GenericSorter class to sort the list of users in descending order according to userId field.

/**

* @author Ashish.Chudasama

public class Main {

public static void main(String[] args) {

List<User> lstUsers = new ArrayList<User>();

lstUsers.add(new User(4, "Amit", "Sharma", "Admin"));

lstUsers.add(new User(1, "Tusha", "Koli", "P1"));

lstUsers.add(new User(3, "Ashish", "Chudasama", "P2"));

lstUsers.add(new User(2, "Riten", "Jhala", "P1"));

// sort the user by user id

Collections.sort(lstUsers, new GenericSorter<User>("userid",GenericSorter.DESC));

/**

* Note: userid is a field name/variable name of class user

for (User user : lstUsers) {

System.out.println(user);

}

Output:

UserID (4) First Name (Amit) Last Name (Sharma) UserType (Admin)

UserID (3) First Name (Ashish) Last Name (Chudasama) UserType (P2)

UserID (2) First Name (Riten) Last Name (Jhala) UserType (P1)

UserID (1) First Name (Tusha) Last Name (Koli) UserType (P1)

Code snippet 6:

SQL support the orderby clause by which we can sort the result into multiple levels. The code snippet 6 shows the lists of users are sorted according to FirstName and then UserType.

/**

* @author Ashish.Chudasama

public class Main {

public static void main(String[] args) {

List<User> lstUsers = new ArrayList<User>();

lstUsers.add(new User(2, "Amit", "Sharma", "Admin"));

lstUsers.add(new User(4, "Tusha", "Koli", "P1"));

lstUsers.add(new User(1, "Ashish", "Chudasama", "P2"));

lstUsers.add(new User(3, "Amit", "Jhala", "P2"));

// sort the user by user id

Collections.sort(lstUsers, new GenericSorter<User>("firstName" ,new GenericSorter<User>("userType")));

/**

* Note: userid is a field name/variable name of class user

for(User user : lstUsers) {

System.out.println(user);

}

Output:

UserID (2) First Name (Amit) Last Name (Sharma) UserType (Admin)

UserID (3) First Name (Amit) Last Name (Jhala) UserType (P2)

UserID (1) First Name (Ashish) Last Name (Chudasama) UserType (P2)

UserID (4) First Name (Tusha) Last Name (Koli) UserType (P1)

Code snippet 7:

SQL support the orderby clause by which we can sort the result into multiple levels. The code snippet 6 shows the lists of users are sorted according to FirstName in ascending order and then UserType in descending order.

/**

* @author Ashish.Chudasama

public class Main {

public static void main(String[] args) {

List<User> lstUsers = new ArrayList<User>();

lstUsers.add(new User(2, "Amit", "Sharma", "Admin"));

lstUsers.add(new User(4, "Tusha", "Koli", "P1"));

lstUsers.add(new User(1, "Ashish", "Chudasama", "P2"));

lstUsers.add(new User(3, "Amit", "Jhala", "P2"));

// sort the user by user id

Collections.sort(lstUsers, new GenericSorter<User>("firstName" ,new GenericSorter<User>("userType",GenericSorter.DESC)));

/**

* Note: userid is a field name/variable name of class user

for (User user : lstUsers) {

System.out.println(user);

}

Output:

UserID (3) First Name (Amit) Last Name (Jhala) UserType (P2)

UserID (2) First Name (Amit) Last Name (Sharma) UserType (Admin)

UserID (1) First Name (Ashish) Last Name (Chudasama) UserType (P2)

UserID (4) First Name (Tusha) Last Name (Koli) UserType (P1)

Singleton Design pattern with Java

noreply@blogger.com (Ashish) — Sun, 03 Apr 2011 12:53:00 +0000

Singleton Design pattern with Java

Singleton design pattern belongs to creational design pattern family. Singleton restricts instantiation of a class to one object.

Why singleton?

Share the single instance/ object among the application example:

1) Connection pool

2) Service Locator

3) Configuration properties etc.

Principle: Instance of class is not possible without constructor.

If class does not have any constructor then compiler provides the default public constructor. If class contain at least one constructor at that time complier does not provide default constructor and used the appropriate constructor defined in a class as per the requirement to instantiate object of class.

Note: Define default constructor as private to restrict the initialization of class within same class.

Code Snippet 1:

Delay the instantiation of object until it’s required. The code snippet shows the object is not initialized until Singleton.getInstacne() method called.

package com.ashish.singleton;

public class Singleton

{

//Declaring singleton field as static field

//This field has static nature and will shared among all

//instance of this class.

private static Singleton singleton=null;

//restrict object creation to this class only

// Private access modifier play the critical role

// to restrict the access of the constructor to the outsider.

private Singleton()

{

}

// Obtain instance of Singleton class with the help of

// Singleton.getInstance() method.

public static Singleton getInstance()

{

if(singleton ==null)

{

singleton=new Singleton();

}

return singleton;

}

// additional stuff ...

}

Restrict the cloning of singleton object by overriding the clone() method of object class

* Object.clone() is protected methods but it is safe to override and *restrict the cloning explicitly.

* Restrict the cloning by overriding clone method of the object class.

@Override

protected Object clone() throws CloneNotSupportedException

{

throw new CloneNotSupportedException();

}

Code snippet 2:

Initialize the singleton object as soon as class loader loads the class into the memory.

package com.ashish.singleton;

public class Singleton

{

//Singleton instance created by the class loader as soon as class

// loaded into the memory

private static Singleton singleton=new Singleton();

//restrict object creation to this class only

// Private access modifier play the critical role

// to restrict the access of the constructor to the outsider.

private Singleton()

{

}

// This method just return the instance of class which is created at the

// class loading time .

// Singleton.getInstance() method.

public static Singleton getInstance()

{

return singleton;

}

/// clone() method ....

// additional stuff ...

}

Code snippet 3:

Initialize the singleton object as soon as class loader loads the class into the memory.

Code snippet 2 & 3 are identical but code snippet 3 uses static block to instantiate the singleton instance.

package com.ashish.singleton;

public class Singleton

{

//Declaring singleton field as static field

//This field has static nature and will shared among all

//instance of this class.

private static Singleton singleton=null;

static

{

// initialization of singleton field is handle by the

// static block

singleton=new Singleton();

}

//restrict object creation to this class only

// Private access modifier play the critical role

// to restrict the access of the constructor to the outsider.

private Singleton()

{

}

// Obtain instance of Singleton class with the help of

// Singleton.getInstance() method.

public static Singleton getInstance()

{

return singleton;

}

/// clone() method ....

// additional stuff ...

}

Singleton design pattern and concurrency issues

It is advisable to initialize the object only when it’s required. Delay initialization required additional consideration to ensure that integrity of the singleton is maintained even in concurrent access.

Note: Java used the Monitor concept to implement mutual exclusion among the concurrent thread.

Code snippet 4:

The integrity of singleton object in multi-threaded environment can be sustain by declaring getInstance() as synchronize method.

package com.ashish.singleton;

public class Singleton

{

//Declaring singleton field as static field

//This field has static nature and will shared among all

//instance of this class.

private static Singleton singleton=null;

//restrict object creation to this class only

// Private access modifier play the critical role

// to restrict the access of the constructor to the outsider.

private Singleton()

{

}

// Obtain instance of Singleton class with the help of

// Singleton.getInstance() method.

public static synchronized Singleton getInstance()

{

if(singleton==null)

{

singleton=new Singleton();

}

return singleton;

}

/// clone() method ....

// additional stuff ...

}

Key points

1) Singleton object is thread safe

2) Only one thread will execute the getInstance() method that will reduce the concurrency.

3) Every time getInstance() method is called additional housekeeping task executed to achieve mutual exclusion among the thread…

Code snippet 5:

Optimize the concurrency by locking only those piece of code that need the mutual exclusion.

package com.ashish.singleton;

public class Singleton {

// declaring singleton field as static field

// this field has static nature and will shared among all

// instance of this class.

private static Singleton singleton = null;

// Sync lock to lock the object access.

private static Object SYNC_LOCK = new Object();

// restrict object creation to this class only

// Private access modifier play the critical role

// to restrict the access of the constructor to the outsider.

private Singleton() {

}

// Obtain instance of Singleton class with the help of

// Singleton.getInstance() method.

public static Singleton getInstance() {

if (singleton == null) {

synchronized (SYNC_LOCK) {

if (singleton == null) {

singleton = new Singleton();

}

return singleton;

}

// / clone() method ....

// additional stuff ...

}

Double null check required because

1) if more than one thread concurrently check for the null check condition

2) Only one thread at a time obtain the monitor to execute the critical section ( mutex section)

3) Try to check any thread initializes the singleton object or not? If yes than avoid re-initialization of singleton object and access the existing object reference.