Hot Java

kajal

2012-10-20T22:24:00.001-07:00

clone() in java

2012-07-09T23:58:00.002-07:00

clone() in java

Here we address purpose of cloning objects, types of cloning, etc.
Definition:- Cloning means creating a new object by copying existing object state.
clone is not for initialization and instantiation. It should not be synonymously used as creating a new object, because the constructor of the cloned object never invoked in the process. Its about copying the object and creating new.
There are 2 types of cloning.They are:-

Shallow Cloning
Deep Cloning

Shallow Cloning: means object state is partially cloned.

That is, Suppose i am having Person object. In Person object I am having fields like name, age, sex, location, and Address object.

when an object containing a reference to another object is cloned, the reference object is not cloned and will be shared between the cloned object and new object. This is partial cloning also called as shallow cloning.

In Person object , Address object is a reference. so when we clone Person object, Address object will not be cloned. It is just shared between cloned Person object and new Person object.

Ex:- Object class provides a clone() and provides support for shallow copy. It returns Object as type and we need to explicitly type cast to original object.

In Object class, clone() is protected. As clone() is protected we cannot use it in all our classes.

The class which needs to be cloned must implement clone().

Also class must implement Cloneable interface. Cloneable interface is a marker interface , means which does not contain any methods. Cloneable interface just tells the compiler that object can be cloned. If Cloneable interface is not implemented then CloneNotSupportedException is thrown.

public class Person implements Cloneable

{

private String name="abdul";

private int age = 35;

private char sex = "M";

//generate setters and getter

public Object clone() throws CloneNotSupportedException()

{

return super.clone();

}

Problems with Object class cloning:

Deep Cloning:- means object state is fully cloned.

means Address object also cloned in deep cloning.

To get a deep cloning, we need to implement clone() ourselves. If we don't want to implement deep cloning ourselves then we can go for serialization.

serialization implements deep copy implicitly.

cloning using serialization:

public class CloneExample implements Cloneable, Serializable {

 int num;
 Thing thing;

 public CloneExample clone() {
  try {
   return (CloneExample) super.clone();
  } catch (CloneNotSupportedException e) {
   return null;
  }
 }

 public CloneExample deepClone() {
  try {
   ByteArrayOutputStream baos = new ByteArrayOutputStream();
   ObjectOutputStream oos = new ObjectOutputStream(baos);
   oos.writeObject(this);

   ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
   ObjectInputStream ois = new ObjectInputStream(bais);
   return (CloneExample) ois.readObject();
  } catch (IOException e) {
   return null;
  } catch (ClassNotFoundException e) {
   return null;
  }
 }

 public int getNum() {
  return num;
 }

 public void setNum(int num) {
  this.num = num;
 }

 public Thing getThing() {
  return thing;
 }

 public void setThing(Thing thing) {
  this.thing = thing;
 }

 public String toString() {
  return "num:" + num + ", thing:" + thing;
 }
}

ByteArrayOutputStream implements an output stream in which data is written to a byte array. buffer automatically grows as data is written to it. data can be retrieved using toByteArray() and toString(). The methods in this class can be called after the stream has closed.

ByteArrayInputStream: A ByteArrayInputStream contains an internal buffer that contains bytes that may be read from the stream. An internal counter keeps track of the next byte to be supplied by the read method.

Purpose of cloning an object:

Cloning of an object to avoid creation. If the cost of creating a new object is large and creation is resource intensive, we clone the object. We use the interface Cloneable and call its method clone() to clone the object.

Disadvantage of cloning :-

Most of the interface / abstract class writers in java forget to put a public clone method. For example you can take List. So when you want to clone their implementations you have to ignore the abstract type and use actual implementations like ArrayList by name. This completely removes the advantage and goodness of abstractness.

Dirty Checking in Hibernate

2012-07-09T00:10:00.002-07:00

Dirty Checking is one of the features of hibernate. In dirty checking, hibernate automatically detects whether an object is modified (or) not and need to be updated. As long as the object is in persistent state i.e., bound to a particular Session(org.hibernate.Session). Hibernate monitors any changes to the objects and executes sql.

Note:- For dirty checking to work, the object must exist in cache.

Example:-
I used oracle database and so oracle driver.

hibernate.cfg.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-configuration PUBLIC "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">

<hibernate-configuration>
<session-factory>

<property name="hibernate.connection.driver_class">oracle.jdbc.driver.OracleDriver</property>
<property name="hibernate.connection.url">jdbc:oracle:thin:@localhost:1521:serviceName</property>
<property name="hibernate.connection.username">userName</property>
<property name="hibernate.connection.password">password</property>

<property name="hibernate.connection.pool_size">10</property>



<property name="hibernate.dialect">org.hibernate.dialect.OracleDialect</property>

<property name="hibernate.show_sql">true</property>

<mapping resource="Gender.hbm.xml"/>
</session-factory>
</hibernate-configuration>

Gender.hbm.xml

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
<class name="packageName.Gender" table="M_COM_GENDER">
<id name="id" type="java.lang.Long" column="GNDR_N_ID">
<generator class="increment"/>
</id
<property name="name" type="java.lang.String" column="GNDR_VC_TYP">

</property>
<property name="status" type="java.lang.String" column="GNDR_C_STS">

</property>
</class>
</hibernate-mapping>

Gender.java
//This is the pojo class.

package packageName;
public class Gender {

private Long id;
private String name;
private String status;
public Long getId() {
return id;
}
private void setId(Long id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getStatus() {
return status;
}
public void setStatus(String status) {
this.status = status;
}
}

ClientApp.java

package packageName;

import org.hibernate.cfg.Configuration;
import org.hibernate.SessionFactory;
import org.hibernate.Session;
import org.hibernate.Transaction;
public class ClientApp {

public static void main(String[] args) {
Configuration con = new Configuration();
con.configure("com/spry/hibernate/dirtychecking/NewFile.cfg.xml");
SessionFactory sf = con.buildSessionFactory();
Session session = sf.openSession();
Transaction trans = session.beginTransaction();
try
{
//loading a gender object of genderId = 1
Gender gender = (Gender)session.get(Gender.class, new Long(1));
//print the gender naem
System.out.println("gender.getName()=======>"+gender.getName());
//modify the gender name
gender.setName("female");
session.getTransaction().commit();
session.flush();

}catch(Exception e)
{
e.printStackTrace();
}finally
{
session.close();
}

}

}

In the above client application, gender object is loaded first. and then object state is changed by altering the name of the object. Here, we are not calling update() , even though object state is written to the database. This is called automatic dirty checking. Hibernate monitors whether any changes in the session objects and automatically synchronizes them to database.
session.getTransaction.commit() is mandatory. Because, after any modifications, if commit() is not called then data will not be modified in the database eventhough update query is executed.

This also works for collections.

difference between GET and POST or GET VS POST

2012-07-06T23:12:00.000-07:00

GET VS POST:
1) “get” is the default method in forms., method=”get”.
2) Hyperlinks use get request only.
3) “get” is idempotent.(Acc. To HTTP spec)

· It should not change anything on the server.

· It can be executed more than once without any bad side effects.

· It’s safe because it does not change anything on the server (unlike post).

There are 3 main limitations:

· Size: The total number of character that can be sent using get request is limited. Only 255 bytes.

· Security: data sent with get request is insecure as all data sent will be appended to url and visible as query string. We should not use get for passwords or sensitive information.

· Bookmarking: get submissions can be book marked which should not be done.

Post:

1) With post we can either request a resource (or) can send form data to server.

2) Form data is sent to server in body of the request.

3) No limit for the amount of data sent.

4) As get the default in form’s, post must be explicitly specified.

5) Post is not idempotent. Post is intended to change things on the server. So double submissions will be a problem. Double submissions cause undesirable results on the server.

difference between Iterator and Enumeration

2012-07-06T05:07:00.001-07:00

Difference between Iterator and Enumeration

Iterators are fail-fast . i.e., while iterating the collection, suppose any other thread tries to modify the list by add/remove operations then the iterator fails quickly and throws "Concurrent Modification Exception".
Enumeration is a legacy class.
Method names have improve in Iterator than Enumeration.
Iterator has remove() while Enumeration does not have remove().
Iterator methods: hasNext(), next(), remove().

Enumeration methods: hasMoreElements(),nextElement().

final variables in Java

2012-05-31T00:02:00.002-07:00

There are 3 types of variables in java. They are:
1) Instance Variables.
2) Static Variables.
3) Local Variables.

Each object will have its own copy of instance variables. static variables are shared by the objects.

we will associate final keyword to these 3 types of variables and check the results.

variables that specify the state of an object are called instance variables. sometimes we can have the state constant. using final keyword we can make variables of an object never change.Final means the state of an object once initialized, it never changes.
Example:-

class FinalEx
{
final int a = 10,b = 20;
}

In the above example, 'a' and 'b' instance variables are final. Means their state once assigned cannot be changed.
Initialization can be done while declaring or before completion of constructor for instance final fields.
Initialization can be done while declaring or in the static intializer block for static final fields.

final primitives are considered as compile-time constants and actual values are assigned at compile-time only.
For Example:-

final int a = 10, b = 20;
do
{
System.out.println("Hello");
}while(a<b);
System.out.println("Hi");

Output:- Compiler error: Unreachable statement.
"Hi" will be unreachable statement. As values are assigned at compile-time only compiler checks a<b and safely throws the error.
This error is thrown for "while and for" loops only. For if condition this error is not thrown.

unlike final primitives, final wrapper objects are not considered as compile-time constants.

Instance and class final fields whether used (or) not used , they must be compulsory initialized.
local final fields if not used then no need to initialize.

Ways to create object to a class in java

2012-05-29T09:10:00.001-07:00

Class: A class is a template for which objects can be created. It can also be treated as visual, i.e. no physical existence.

Object: An object exists physically. It consists of properties and behaviour.

For example:

Dog is a class. Tommy is an object.
that means, Dog doesn't exist physically. tommy exists physically.
Dog is just like a template for which different objects llike tommy, cesar , can be created..

Ways of creating objects in java

1) Using new operator:
Example:
class A
{
}
A a = new A();

2) Class.forName("packageName.className").newInstance() returns super class type Object..we have to type cast to our specific object..
Example:

class A
{
}
try
{
A a = (A)Class.forName("A").newInstance();
}
catch(ClassNotFoundException e)
{
e.printStackTrace();
}
Class.forName("") throws ClassNotFoundException.

3) Deserialization:

serialization and deserialization helps to persist or store an object state to database, file system and to retrieve the object state from database, file system etc.

serialization means storing the object state to database, file system etc
deserialization means retrieving the object state from database, file system etc

In deserialization process, we open a stream and read the objects from database or file system..this means indirectly we are creating object.

Example:

Serialization example:

import java.io.IOException;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import java.io.FileOutputStream;
import java.io.FileNotFoundException;
class Test implements Serializable
{
int a = 10;
int b = 20;
public int getA() {
return a;
}
public void setA(int a) {
this.a = a;
}
public int getB() {
return b;
}
public void setB(int b) {
this.b = b;
}

}

public class Serialization {

public static void main(String[] args) {
FileOutputStream out = null;
ObjectOutputStream oos = null;
Test t = new Test();
try
{
out = new FileOutputStream("abc");
oos = new ObjectOutputStream(out);
oos.writeObject(t);
}catch(FileNotFoundException e)
{
e.printStackTrace();
}catch(IOException e)
{
e.printStackTrace();
}
}

}

Test class needs to implement Serializable interface. Serializable interface is a tagged or marker interface .

4) By using this.getClass().getClassLoader().loadClass(className).newInstance also returns the object.
5) By using cloning also we can create objects...

Configuring Second Level Cache in Hibernate

2012-05-17T23:45:00.002-07:00

Hibernate's Second Level Cache

caching is one of the features of Hibernate. caching is introduced mainly for performance reasons.
For Example:

In normal JDBC, if we update a transaction number of times it will hit the database is
number of hits to database = number of updates.
In hibernate, the object is maintained in cache. If any update is done in the object, then changes are synchronized. In hibernate if we update a transaction number number of times , it will hit the database is
number of hits to database = 1 time.

In this way there are a number of performance benefits with hibernate caching. There are 3 ways of caching.

1) Session level caching
2) Second level caching
3) Query Caching.

Now we are going to deal with Second level caching in hiberate. It comprises of configuring & execution of  second level cache of a small standalone application .

Tools Used: Eclipse IDE (Helios).

create a new java project. Add Hibernate libraries.I used hibernate 3.0 library.
Download hibernate library from http://www.hibernate.org/downloads

After downloading it unzip the zip folder. you will have hibernate & all supporting jar files.

In Eclipse , Right - Click on the project name. you will get a pop up showing different options. select properties option.
click on the java build path option. add jar files by clicking "Add External Jars" button.
locate the directory and add jar files,

Now we are ready with environment set. In the src folder create a package of yours. My package name is com.example.hibernate.cache.

Now create following files.

1) configuration file --> which contains Database (or) DataSource details and hibernate properties details.
2) mapping file --> which contains hbm file. A hbm file maps pojo class to table name.
3) Pojo class --> Pojo class is normal java class with properties , setters & getters.
4) client applicaton --> client who uses and runs the second level caching.

Also , create a table M_COM_GNDR in database.
Fields like GNDR_N_ID number, GNDR_VC_TYP varchar, GNDR_C_STS varchar.

Insert data into it.
Like GNDR_N_ID ------------> 1
  GNDR_VC_TYP------------> Male
GNDR_C_STS --------------> A

  GNDR_N_ID ------------> 2
GNDR_VC_TYP------------> Female
GNDR_C_STS --------------> A

"A" means Active.
1) Configuration file: It is an xml file. I used oracle database and so oracle driver and its port number. If any other database is used then its driver is used. I used ojdbc14.jar driver. If it is not there download it from www.java2s.com.

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-configuration PUBLIC "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
<session-factory>

<property name="hibernate.connection.driver_class">oracle.jdbc.driver.OracleDriver</property>
<property name="hibernate.connection.url">jdbc:oracle:thin:@localhost:1521:servicename</property>
<property name="hibernate.connection.username">elearn</property>
<property name="hibernate.connection.password">estudy</property>



<property name="hibernate.dialect">org.hibernate.dialect.OracleDialect</property>


<property name="hibernate.show_sql">true</property>


<property name="hibernate.cache.provider_class">org.hibernate.cache.EhCacheProvider</property>


<mapping class="Gender" package="com.example.hibernate.cache" resource="com/example/hibernate/cache/Gender.hbm.xml"/>
</session-factory>
</hibernate-configuration>

2) Mapping File:

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">

<hibernate-mapping>



<class name="com.example.hibernate.cache.Gender" table="M_COM_GNDR">
<cache usage="read-write"/>
<id name="id" type="java.lang.Long" column="GNDR_N_ID">
  <generator class="assigned" />
</id>
<property name="name" type="java.lang.String" column="GNDR_VC_TYP"></property>
<property name="status" type="java.lang.String" column="GNDR_C_STS"></property>
</class>
</hibernate-mapping>

3) Pojo class:

package com.example.hibernate.cache;

public class Gender {

private Long id;

private String name;

private String status;

public Long getId() {

return id;

}

private void setId(Long id) {

this.id = id;

}

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

public String getStatus() {

return status;

}

public void setStatus(String status) {

this.status = status;

}

4) Client App

package com.spry.hibernate.cache;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;

import com.example.hibernate.cache.Gender;

public class ClientApp {

public static void main(String[] args) {

Configuration con = new Configuration();
con.configure("com/example/hibernate/cache/NewFile.cfg.xml");
SessionFactory sf = con.buildSessionFactory();
Session session = sf.openSession();
Transaction trans = session.beginTransaction();
try
{
// loading the gender object from database for the first time.
Gender gender = (Gender)session.get(Gender.class, new Long(1));
System.out.println("gender.getName()=======>"+gender.getName());
//Closed the sesssion.
session.close();
//Again opening the session.
session = sf.openSession();
trans = session.beginTransaction();
//Again when we load the object it hits the second level cache not the database.
gender = (Gender)session.get(Gender.class, new Long(1));
System.out.println("gender.getName()=======>"+gender.getName());
session.close();
}catch(Exception e)
{
e.printStackTrace();
}
}

}

we can see the output as

Hibernate: select gender0_.GNDR_N_ID as GNDR1_0_0_, gender0_.GNDR_VC_TYP as GNDR2_0_0_, gender0_.GNDR_C_STS as GNDR3_0_0_ from M_COM_GNDR gender0_ where gender0_.GNDR_N_ID=?
gender.getName()=======>male
gender.getName()=======>male

in the console.

Here session means one database connection. we opened database connection in the program twice. loaded the object twice. But in the console the query hit the database only one time. second time the object is loaded from the second level cache...

when second level cache is enabled, hibernate loads objects from database when specified and keeps a copy of the object in second level cache. so that next time no need to hit the database. Directly we can get the object from second level cache.

If you want to test whether second level caching is working or not, just comment out
"<cache usage="read-write"/>" in hbm file. Then execute the client app.

output will be

Hibernate: select gender0_.GNDR_N_ID as GNDR1_0_0_, gender0_.GNDR_VC_TYP as GNDR2_0_0_, gender0_.GNDR_C_STS as GNDR3_0_0_ from M_COM_GNDR gender0_ where gender0_.GNDR_N_ID=?
gender.getName()=======>male
Hibernate: select gender0_.GNDR_N_ID as GNDR1_0_0_, gender0_.GNDR_VC_TYP as GNDR2_0_0_, gender0_.GNDR_C_STS as GNDR3_0_0_ from M_COM_GNDR gender0_ where gender0_.GNDR_N_ID=?
gender.getName()=======>male

2 times query is executed.

Daemon Thread in Java

2012-05-16T00:00:00.002-07:00

Daemon Thread:
Daemon thread is a special kind of thread. Normally when a thread is created in java, default it is Non-Daemon.
Daemon thread is created by setting the setDaemon(boolean value) of Thread to "true".

Example
//DaemonThread implementing Runnable interface. Has to compulsory over-ride run().
class DaemonThread implements Runnable
{
public void run()
{
//background running task like memory clean, and long running processes
}
}

//DaemonClient is the client program which uses DaemonThread
class DaemonClient
{
public static void main(String a[])
{
DaemonThread dt = new DaemonThread(); //created DaemonThread

dt.setDaemon(true); // This statement sets the thread to Daemon Thread.
dt.start(); //started the daemon thread.
}
}

Above example consists of Daemon thread & our main thread.

There is no difference between Daemon Thread & Non-Daemon Thread, except the JVM waits for the non-daemon threads to finish their execution, unlike daemon threads. JVM doesn't show any mercy on Daemon Threads.

Purpose of Daemon threads is they run in the background to support non-daemon threads.
Garbage Collector is an example of Daemon thread.
Garbage collector removes unreferenced objects and saves memory.

Before starting a thread, setDaemon() must be called.

IllegalThreadStateException:

IllegalThreadStateException is a sub-class of IllegalArgumentException. If the setDaemon(boolean arg) is called when the thread is running then IllegalThreadStateException is thrown.

Priority of Daemon thread is similar to any other thread. Default NORM_PRIORITY : 5

If you want to change the priority , can change by using setPriority() which takes 1 to 10 as input.
Other than that is input is provided, throws IllegalArgumentExcpetion.

we can use isDaemon() to test whether a thread is daemon or not. isDaemon() returns true , if thread is daemon, else false.

Constructor in Java

2012-05-15T05:26:00.001-07:00

Constructor:
A constructor is a special method that is used to initialize properties of a newly created object and is also called just after memory is allocated for the object.
Rules:
1) class name and method name must be same.
2) should have no return type, even void.

If a constructor is not specified in a class , compiler default provides a no-argument constructor.
suppose ,
public class A
{

}
When compiler executes the above class, a default constructor is provided by the compiler.

suppose if i provide a constructor with a parameter then calling default constructor is a compiler error.
Because , compiler won't provide default constructor( i.e. no-arg constructor) if a constructor is explicitly specified.

so

Example:
public class A
{
private String name;
A(String name)
{
this.name = name;
}
}

A a = new A(); //gives compiler error as default constructor doesn't exist.
A a = new A("compiler"); //works fine.

OverLoading of Constructors:

Overloading is an example for polymorphism. Constructor overloading means constructors having same name but varies with parameter list.

Constructors can be overloaded. Within a single class we can have any number of constructors that differs in parameter list.
Example:
public class A
{
private String name;
public A()
{
// Default constructor
}

public A(String name)
{
this.name = name; // constructor with single parameter
}

/*
like this we can have any number of constructors with varying parameter list and types..
*/
}

Constructor Chaining:

Constructor chaining means calling a constructor from another constructor.

Constructor chaining can be done in 2 ways.

1) we can call a constructor from another constructor in the same class using this keyword.
This can be done as follows:

public class Person
{
private String name;
private int age;
public Person ()
{
// Default constructor
}

public Person (String name)
{
this.name = name;
this(name,25);
}

public Person (String name, int age)
{
this.age = age;
}

}

The above example calls a constructor from another constructor using this keyword.
Suppose only name is specified then , Person object age is default taken as 25
you can also customize person age using the 3rd constructor.

2) we can call the super class constructor using super keyword if inheritence is allowed.

suppose we have 2 classes . one parent and child class.
class Parent
{
Parent()
{
System.out.println("Parent constructor");
}
}
class Child extends Parent
{
Child()
{
System.out.println("child constructor");
}
}

class Client
{
public static void main(String a[])
{
Child c = new Child();
}
}

If the above example is executed, we get output as:
Parent Constructor
Child Constructor

Here we did not call super class constructor. But implicitly super class constructor will be called by the child class constructor. In the child class constructor , super() is the first statement implicitly provided by the compiler if default constructor is provided.

* Suppose in the super class we provided a constructor with parameter. In the child class we provided a default constructor, then compiler error is generated.

Example:

class Parent
{
Parent(String name)
{

}
}
class Child extends Parent
{

}

Compiler Error: implicit super constructor Parent() is undefined for default constructor. Must define an explicit constructor.

Subclasses constructors may specify as the first thing they do which constructor in the superclass to invoke before executing the code in the subclass's constructor.

* suppose if super class constructor access is given as private then inheritence is not possible. suppose if Child tries to extend Parent then compiler error is shown.

* constructor can throw same Exception or supertype of parentclass exception but cannot handle them..

Suppose if super class constructor throws any checked exception then child class constructor cannot handle it. It has to throw the exception to caller.

we cannot handle the exception because in the child constructor the first statement must be super() (calling the super class constructor) . we cannot write try-catch blocks. so we cannot handle the exceptions.

Thank You,

wait() and notify() in java Multithreading

2012-05-14T04:52:00.000-07:00

Multithreading: multiple threads executing parallely. Multiple threads sharing a resource gives race condition.

Race condition: Multiple threads sharing a resource gives inefficinent results.

To know about Race condition please click on this link:
http://javabrowsers.blogspot.in/2012/05/what-is-race-condition.html

To avoid Race condition we use synchronized methods and blocks. To intercommunicate threads we use wait(), notify() or notifyAll()'s. wait/notify mechanism is a way to communicate between threads.
The idea is as follows:
1) one or more threads wait for a signal.
2) another thread comes in and notifies the waiting threads.

The wait-notify pattern is used when one thread needs to tell other threads that some event has occurred.

These methods are final methods in Object class. wait() throws InterruptedException. These methods wait(), notify() and notifyAll() must be used in synchronized method or block only. If used outside of synchronized method or block a run-time exception occurs, IllegalMonitorStateException.

To avoid Race condition , we write wait(), notify(),notifyAll()'s in synchronized method or block.

suppose take producer - cosumer problem:

1. The Producer thread tests the condition (buffer is full or not) and confirms that it must wait (after finding buffer is full).2. The Consumer thread sets the condition after consuming an element from buffer.3. The Consumer thread calls the notify () method; this goes unheard since the Producer thread is not yet waiting.4. The Producer thread calls the wait () method and goes into waiting state.

So due to race condition here we potential lost a notification and if we use buffer or just one element Produce thread will be waiting forever and your program will hang.

For example cosider following limited connection pool example using wait(),notify()

package threads;
import java.util.*;
import java.sql.*;
//implements connection pool
class ThreadWait
{
private static List<Connection> connections = createConnections(); //shared resource
//method creates 5 db connections
public static List<Connection> createConnections()
{
Connection con = null;
List<Connection> connections = new ArrayList<Connection>();
try
{
Class.forName("oracle.jdbc.driver.OracleDriver");
for(int i = 0;i<5;i++)
{
con = DriverManager.getConnection("jdbc:oracle:thin:@localhost:1521:serviceName","username","password");
connections.add(con);
}

System.out.println("connections.size()===>"+connections.size());
}catch(ClassNotFoundException e)
{
e.printStackTrace();
}
catch(Exception e)
{
e.printStackTrace();
}
return connections;
}
// End of connections

//gets a connection
public static Connection getConnection() throws InterruptedException
{
Connection con = null;

//If connections list is empty then wait() is called on connections object.
synchronized(connections)
{
if(connections.isEmpty())
connections.wait();
}
con = connections.remove(0);

System.out.println("in get Connection "+Thread.currentThread()+" ------ "+connections.size());
return con;
}
//end of getConnection

public static void returnConnections(Connection con)
{

synchronized(connections)
{
connections.add(con);
connections.notify();
}
System.out.println("in return Connection"+Thread.currentThread()+" ------ "+connections.size());
}
}

//job to be done by threads
class ThreadDemo implements Runnable
{
public void run()
{
System.out.println("in run method"+Thread.currentThread());

Connection con = null;
Statement stmt = null;
try {
con = ThreadWait.getConnection();
System.out.println("got connection object: "+Thread.currentThread());
stmt = con.createStatement();
stmt.executeQuery("select * FROM DUAL");
ThreadWait.returnConnections(con);
System.out.println("connection returned"+Thread.currentThread());
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
//client program
public class ThreadAdvance {

public static void main(String[] args) {
ThreadDemo demo = new ThreadDemo();
Thread thread1 = new Thread(demo);
Thread thread2 = new Thread(demo);
Thread thread3 = new Thread(demo);
Thread thread4 = new Thread(demo);
Thread thread5 = new Thread(demo);
Thread thread6 = new Thread(demo);
Thread thread7 = new Thread(demo);
Thread thread8 = new Thread(demo);
thread1.start();
thread2.start();
thread3.start();
thread4.start();
thread5.start();
thread6.start();
thread7.start();
thread8.start();
}

}

ThreadWait is the class that implements connection pool. copy this program to eclipse or any ide and run the program.

Multiple threads request connection objects from list connections. If no connection is currently available (i.e. connections is empty), then we need to wait until one becomes available. Then we return the first available connection.

Note first of all that we synchronize on the connection list. We then check if the list is empty. If, and while, it is, we "wait" on the list. In order to wait on an object, we must be synchronized on that object. But our thread will automatically release the lock temporarily while waiting. Calling wait() means that our thread will be suspended until it is "notified". Our thread will be "notified", and thus woken up, when another thread calls notify() on the object that we're waiting on (in this case, the connection list). When our thread wakes up, it automatically regains the lock. We can now check again that the list is not empty, and if it isn't, safely take out the first connection. This checking and removing will be atomic because we have the lock on the list.

Again with a synchronized lock on the list, we add the given connection to the list. Then, while still synchronized on it, we call notify() on the connection. Calling notify() means: "if there is at least one thread waiting on this object, please wake up one of those threads". In cases such as this, waking up a single random thread is the functionality we want: we've only added one connection to the list, so there's no point waking up more than one waiting thread. Note that we have no control over which waiting thread is woken up. In particular, we can't say "wake up the one that's been waiting longest". (Nor will most JVMs or OSs use such a policy: ensuring this kind of "fairness" turns out to decrease throughput considerably.)

Note that although notify() wakes up one of the waiting threads, the first thing that that thread needs to do is re-acquire the lock that our thread is currently holding. So after calling notify(), we should exit the synchronized block as quickly as possible.

A couple of small points about this wait-notify pattern are worth clarifying:

The waiting thread can be interrupted (either for some spurious OS/hardware reason or, more likely, becauseinterrupt() is called on the thread from within Java). Thus, wait() can throw InterruptedException. Unless you're in code that's dealing with the "outer logic" of a thread's function, the most appropriate thing is usually just to throw the exception up.
When a thread is 'awoken' from wait(), it can't tell why it's being woken. In particular, it isn't necessarily because it has been notified! (The OS could just spuriously wake it up for some reason.) So we have to check the size of the list again before pulling out a connection.
It's crucial that we don't wait if the list isn't empty. If we did, we would essentially sit waiting for a notify that wasn't about to come. (This is actually quite a common programming error in this type of code, because when you're writing it, your mind is saying "I need to wait until there's something in the list".)

Use of join() of Thread in java

2012-05-10T00:00:00.001-07:00

public final void join()
                throws InterruptedException

The thread on which this method is called will execute until its termination and remainig threads have to wait until its death.

Suppose i am having 4 threads. Each thread does me a sequence process. This means my threads have to execute in a sequence, step-by-step. For this , i use join() of Thred class.

Example:-

// Created 4 threads Thread1, Thread2, Thread3 , Thread4

class Thread1 extends Thread
{
 public void run()
 {
  System.out.println("First Thread");
 }
}
class Thread2 extends Thread
{
 public void run()
 {
  System.out.println("Second Thread");
 }
}
class Thread3 extends Thread
{
 public void run()
 {
  System.out.println("Third Thread");
 }
}
class Thread4 extends Thread
{
 public void run()
 {
  System.out.println("Fourth Thread");
 }
}
public class Immutable {

 public static void main(String[] args) {
 Thread1 t1 = new Thread1();
 Thread2 t2 = new Thread2();
 Thread3 t3 = new Thread3();
 Thread4 t4 = new Thread4();
 
 System.out.println("main thread");
 
  t1.start();
  t2.start();
  t3.start();
  t4.start();
  
 
 }

}

Created 4 threads Thread1, Thread2, Thread3 , Thread4. Each thread prints a statement on the console.When this program is executed, sop's print in a random order.

But, i want the order in sequence.Like,

first thread

second thread

third thread

fourth thread

then

Program:-

class Thread1 extends Thread
{
 public void run()
 {
  System.out.println("First Thread");
 }
}
class Thread2 extends Thread
{
 public void run()
 {
  System.out.println("Second Thread");
 }
}
class Thread3 extends Thread
{
 public void run()
 {
  System.out.println("Third Thread");
 }
}
class Thread4 extends Thread
{
 public void run()
 {
  System.out.println("Fourth Thread");
 }
}
public class Immutable {

 public static void main(String[] args) {
 Thread1 t1 = new Thread1();
 Thread2 t2 = new Thread2();
 Thread3 t3 = new Thread3();
 Thread4 t4 = new Thread4();
 
 System.out.println("main thread");
 try
 {
  t1.start();
  t1.join();
  t2.start();
  t2.join();
  t3.start();
  t3.join();
  t4.start();
  t4.join();
 }catch(InterruptedException e)
 {
  e.printStackTrace();
 }
 }

}

Then the output is sequntial as expected. Thank You.

Create an Immutable Object in Java

2012-05-09T00:38:00.001-07:00

Immutable Objects: When you have a reference to an instance of an object, the contents of that object cannot be altered.

Mutable Objects: When you have a reference to an istance of an object, the contents of that object can be altered.

String is an immutable class. That means state of the object after creation cannot be changed.

For Example:

String myString = "oldString";

myString.toUpperCase();

System.out.println(oldString);

Here the state of the object is not changed. But a new string "OLDSTRING" is created in the string constant pool. we will know about String constant pool in our next discussions.

Template of Immutable Class:-

1) fields must be private.

2) No setters. Only once the propeties have to be set.

3) Ensure that methods cannot be over-ridden by either making the class final (Strong Immutability) or the methods final(Weak Immutability).

4) If a filed isn't primitive (or) immutable, make a deep clone on the way in and on the way out.( i mean while setting and retrieving).

Example:-

final public class Person

{

private String firstName;

private String lastName;

private Date dob;

Person(String firstName,String lastName,Date dob)

{

this.firstName = firstName;

this.lastName = lastName;

this.dob = dob;

}

public String getFirstName()

{

return this.firstName;

}

public String getLastName()

{

return this.lastName;

}

public String getDob()

{

return this.dob;

}

Above class is strong immutable . but Date class is mutable.

so we should make deep copies of mutable data.

Date d1 = new Date();

Person p = new Person("first","last",d);

Date d2 = d.getDob();

d2.setMonth(d2.getMonth()+1); //changes the state of the date

System.out.println(p.getDob());

In the above code, we created a Person object. As Date object is mutable , the month is modified. Now the dob field refers to altered Date. This breaks the immutability. To overcome that

Example:

final public class Person

{

private String firstName;

private String lastName;

private Date dob;

Person(String firstName,String lastName,Date dob)

{

this.firstName = firstName;

this.lastName = lastName;

this.dob = new Date(dob.getTime());

}

public String getFirstName()

{

return this.firstName;

}

public String getLastName()

{

return this.lastName;

}

public String getDob()

{

return new Date(this.dob.getTime());

}

This class is fully immutable..

String and wrapper classes like Integer, Float, Double, Long etc., are all Immutable.

Advantage of Immutability:

Immutable objects are inherently thread safe. They require no synchronization. 2 or more threads can work on the same immutable object without any conflict. Therefore, immutable objects can be shared freely.
Security: Application is ensured that any sensitive read-only information cannot be altered.
Immutable objects are less prone to error and are more secure.
Immutable objects are simple.
An immutable object can be in exactly one state, the state in which it was created.

The only disadvantage of immutable classes is that they require a separate object for each distinct value. separate object means new object.

What is Race Condition

2012-05-08T00:25:00.001-07:00

Race Condition:
Race conditions occur in multi - threaded applications. A race condition exists when multiple threads access a shared resource that could give in unexpected results.

Ex:- Check & Act
x = 5;
if(x == 5) //check
{
y = x *2; //act
}

//If x is changed by another thread in between the if(x==5) and y = x*2, y will not be equal to 10.

In order to prevent Race conditions occurring, typically we put a lock around the shared data to ensure that only one thread access the data at a time.

//obtain the lock for x

if(x == 5) //check
{
y = x *2; //Nothing can change the x value until the lock is released.
}
//Release the lock.

lock mechanism is done by synchronized method or block.

No. of sundays fell on the first of the month during twentieth century

2012-05-03T02:12:00.002-07:00

Program:-

import java.util.Calendar;
public class TwentiethCentury {

public static void main(String[] args) {
Calendar calendar = Calendar.getInstance();
int count = 0;
for(int i = 1901;i<=2000;i++)
{
int j = 0;
while(j<=11)
{
calendar.set(i, j, 1);
System.out.println(calendar.getTime());
int result = calendar.get(Calendar.DAY_OF_WEEK);
if(result==1)
{
count++;
}

j++;
}
}
System.out.print(count);
}

}

Finding the Nth Prime Number

2012-05-02T23:18:00.002-07:00

Generally speaking 1 is not a prime. The first prime number is 2. After 2 there are no prime numbers that are even. so only odd numbers fill the remaining set of primes.
so start at 3 for the second prime, check the primeness, then increment by 2. Repeat until You find nth prime.
we will check prime of odd numbers here. odd numbers are not divisible by 2. so iteration can start at 3.

Program:-

import java.util.Scanner;
public class NPrimeNumber {

public static void main(String[] args) {
Scanner console = new Scanner(System.in);
System.out.println("enter the nth prime number to find: ");
int nthPrime = console.nextInt();
int prime = 0;
if(nthPrime<=0)
{
System.out.println("Wrong Input");
}
else
if(nthPrime==1)
{
System.out.println("Prime value "+2);
}else
if(nthPrime==2)
{
System.out.println("Prime value "+3);
}else
{
int number = 3;//last prime value i tested
prime = 2;//identified the first 2 primes.
// continue testing until prime == nth prime
while(prime<nthPrime)
{
boolean isFlag = true;
number+=2;
int sqrt = Math.sqrt(number);

for(int i = 3;i<=sqrt;i++)
{
//isFlag Becomes false only if the number is odd number and not prime.
if(number%i==0)
{
isFlag = false;

}

}
//prime value increments if and only if number is prime number
if(isFlag==true)
{
prime += 1;
}

}
System.out.println("Prime value "+number);
}

}

}

Printing Prime Numbers within Given Number

2012-05-01T23:49:00.003-07:00

This program prints prime numbers within the specified range:

Program:

//Printing prime numbers specified in the given range.
import java.util.Scanner;
public class PrintPrime
{
public static void main(String a[])
{
Scanner console = new Scanner(System.in);
System.out.println("Enter the number");
int num = 0;
num = console.nextInt();
System.out.println("Prime Numbers are: ");

for(int i=2;i<=num;i++)
{
int count = 0;
for(int j=2;j<=i;j++)
{
if(i%j==0)
count++;
}
if(count == 1)
System.out.print(i+" ");
}

}
}

Enhanced Program that reduces for loop iterations:

//Printing prime numbers specified in the given range.
import java.util.Scanner;
public class PrintPrime
{
public static void main(String a[])
{
Scanner console = new Scanner(System.in);
System.out.println("Enter the number");
int num = 0;
num = console.nextInt();
System.out.println("Prime Numbers are: ");

for(int i=2;i<=num;i++)
{
int count = 0;
for(int j=2;j<=Math.sqrt(i);j++)
{
if(i%j==0)
count++;
}
if(count==0)
System.out.print(i+" ");
}

}
}

Check Whether a Given Number is Prime OR Not

2012-05-01T22:53:00.001-07:00

//Program takes input using Scanner class and checks whether the input number is prime (or) not.

//Program:-

//check for prime number existence or not
import java.util.Scanner;
public class PrimeExisting
{
public static void main(String a[])
{
Scanner console = new Scanner(System.in); //Scanner associated with Standard Input Device
int givenNum = 0;
try
{
givenNum = console.nextInt();
//Reading input From console. if input is not a number Scanner throws Excpetion (InputMismatchException)
}catch(Exception e)
{
System.out.println("Wrong Input:");
}
int count = 0; //counts the number of times the givenNum divided by the iteration number gives remainder '0'
for(int i=2;i<=givenNum;i++) //No need to check with 1
{
if(givenNum%i==0)
{
count++;
}
}
System.out.println(count);
if(count==1)
{
System.out.println(givenNum+" is prime");
}else
{
System.out.println(givenNum+" is not prime");
}

Enhanced Prime Number checking Program:

In this program we square root the given number to reduce the for loop iterations.

//check for prime number existence or not
import java.util.Scanner;
public class PrimeExisting
{
public static void main(String a[])
{
Scanner console = new Scanner(System.in);
int givenNum = 0;
try
{
givenNum = console.nextInt();
}catch(Exception e)
{
System.out.println("Wrong Input:");
}
int count = 0;
double sqrt = Math.sqrt(givenNum);
System.out.println("sqrt value: "+sqrt);
for(int i=2;i<=sqrt;i++)
{
if(givenNum%i==0)
{
count++;
}
System.out.println("i value: "+i);
}
System.out.println(count);
if(count==0)
{
System.out.println(givenNum+" is prime");
}else
{
System.out.println(givenNum+" is not prime");
}
}
}

O/P:- javac PrimeExisting.java , press Enter.
java PrimeExisting 877

Reference site to check prime numbers below 1000

Fibonacci Numbers in O(1) Time

2012-04-30T02:42:00.002-07:00

public int fib(int n){
double x = Math.sqrt(5)/5;
double termOne = x * Math.pow((1+sqrt(5))/2, n);
double termTwo = -x * Math.pow((1-sqrt(5))/2, n);
return (int)(termOne + termTwo);
}

This solution generates the nth Fibonacci number through solving the linear recurrence. The solution is: F(n) = (sqrt(5)/5)((1+sqrt(5))/2)^n - (sqrt(5)/5)((1-sqrt(5))/2)^n.

It's actually taught in Discrete Math courses. You can solve linear, homogenous recurrences like linear, homogenous differential equations.

Bubble Sort In Java

2012-04-30T01:52:00.003-07:00

Bubble sort is the simplest sorting algorithm in java that works by repeatedly stepping through the list to be sorted, comparing each pair of adjacent items and swapping them if they are in the wrong order. The pass through the list is repeated until no swaps are needed, which indicates that the list is sorted.

Bubble sort has worst-case and average complexity both О(n²), where n is the number of items being sorted. There exist many sorting algorithms with substantially better worst-case or average complexity of O(n log n). Even other О(n²) sorting algorithms, such as insertion sort, tend to have better performance than bubble sort. Therefore, bubble sort is not a practical sorting algorithm when n is large.

Java Program for Bubble Sort

import java.util.Scanner;

public class BubbleSort {

public static void main(String[] args) {
Scanner scaner = new Scanner(System.in);//Reads the input from standard input device through console
System.out.println("Enter the number of elements to sort: ");
int num = scaner.nextInt(); //input no. of elements for sorting
int sort[] = new int[num];
for (int i = 0; i < num; i++) {
sort[i] = scaner.nextInt(); //reading each element from cosole.
}
System.out.println("Elements Before Sorting: ");
for (int i = 0; i < num; i++) {
System.out.print(sort[i] + " ");
}
sort = bubbleSort(sort); //method that does the bubble sort and returns the sorted array

System.out.println();
System.out.println("Elements After sorting: ");

for (int i = 0; i < num; i++) {
System.out.print(sort[i] + " ");
}
}

static private int[] bubbleSort(int[] sort) {
for (int i = 0; i < sort.length - 1; i++) {
for (int j = i + 1; j < sort.length; j++) {
if (sort[i] > sort[j]) { //comparison and sorting.
int temp = 0;

temp = sort[i];
sort[i] = sort[j];
sort[j] = temp;
}
}
}
return sort;
}

}

Run the above code. you will be asked number of elements for sorting. after specifying the number of elements give each number by clicking enter. Atlast you will get the output.

Step-by-step example

Let us take the array of numbers "5 1 4 2 8", and sort the array from lowest number to greatest number using bubble sort algorithm. In each step, elements written in bold are being compared. Three passes will be required.

First Pass:
( 5 1 4 2 8 )  ( 1 5 4 2 8 ), Here, algorithm compares the first two elements, and swaps them.
( 1 5 4 2 8 )  ( 1 4 5 2 8 ), Swap since 5 > 4
( 1 4 5 2 8 )  ( 1 4 2 5 8 ), Swap since 5 > 2
( 1 4 2 5 8 )  ( 1 4 2 5 8 ), Now, since these elements are already in order (8 > 5), algorithm does not swap them.
Second Pass:
( 1 4 2 5 8 )  ( 1 4 2 5 8 )
( 1 4 2 5 8 )  ( 1 2 4 5 8 ), Swap since 4 > 2
( 1 2 4 5 8 )  ( 1 2 4 5 8 )
( 1 2 4 5 8 )  ( 1 2 4 5 8 )
Now, the array is already sorted, but our algorithm does not know if it is completed. The algorithm needs one whole pass without any swap to know it is sorted.
Third Pass:
( 1 2 4 5 8 )  ( 1 2 4 5 8 )
( 1 2 4 5 8 )  ( 1 2 4 5 8 )
( 1 2 4 5 8 )  ( 1 2 4 5 8 )
( 1 2 4 5 8 )  ( 1 2 4 5 8 )

How To Create A Java Executable Jar File

2012-04-29T23:32:00.000-07:00

Creating a jar file is not difficult to do, and it is something that should certainly be learned by beginning Java programmers. If you don't like reading, try my YouTube video of this. It might make more sense.
1. Right-click and create a new folder on your desktop. The title doesn't matter. This is where you will store all of the files that will make up your jar file. Using a folder is helpful when you have a project of multiple classes.

2. Either save or drag and drop your Java files into your folder.

3. Now you will need to open the command prompt. Do this by holding the Windows key, then pressing the R key. This should bring up your Run application in which you should type "cmd" - press OK and this should bring up your command prompt.

4. In the command prompt, type "cd Desktop" to change your directory to the desktop, the location of your folder. Type "dir" to show what is in the Desktop directory. You should see the folder that has your Java files in it among the list. Type "cd <foldername>" or, for example, "cd MyJavaFolder" - this should change your directory to your folder. To see what is in it, type "dir" again.

5. By typing "dir" you should see your Java files inside of the folder. In order to turn these into class files, we need to compile them by using the "javac" command. This command requires the JDK and it requires you to change the classpath. This will not be covered in this tutorial. To compile the files, type "javac MyJavaFile.java" - to compile multiple files just put a space between them and use the same command "javac MyJavaFile1.java MyJavaFile2.java".

6. Type "dir" again and you should see your Java files and now your class files as well. You can minimize the command prompt and open the folder on your desktop. Inside the folder, right-click and create a new text document (notepad). In notepad, you need to show what your main class is for the jar file. Here's how you do this:

1Main-Class: MyMainClass

2 

3|

This part is very important, so make sure to take note of the capitalization and the spacing. Don't add the .class ending to your specified main class. You MUST press enter twice from the line you write on so that your curser ends up exactly where I placed the vertical bar. From that point, save it (to your folder of course) as "MyManifest.txt". The name doesn't really matter, but it's called a manifest document.

7. Now go back into your command prompt and navigate back to your folder if you didn't just minimize the command prompt. Type "dir" once in your folder directory and you should see your manifest document.

8. Here's how you make your jar file once you have the files all ready to go. You should be in your folder directory in the command prompt. Type "jar cfm JarFileName.jar MyManifest.txt MyJavaFile1.class MyJavaFile2.class" - Type "dir" and you should see your jar file! You choose what your jar file is called in this command as well. The order matters.

9. Now, what good does a jar file do if you can't run it? Well, not much. If your program is made to run in the command line, then you will still have to run it by typing a command (unfortunately). Otherwise, if you have a GUI, you can go to your folder and double-click your jar file.
To run a jar file from the command prompt, type "java -jar MyJarFile.jar".

Now you have a way to show off your programs on someone else's computer without having to download the JDK and configure the classpath and so on. All you need is the JRE, which most people have. If you're not into making GUIs yet, your jar file is still just as portable as the ones you can double-click. All you need to run the jar file is a computer with the JRE and, of course, the command to run a jar file.

Making executable jar files is a fun way to wrap up your code into a portable package that can run almost anywhere. I hope this tutorial helped you! Let me know if you have further questions, and let me know if I made a mistake. But again, I hope it made sense and wasn't too complicated or difficult to copy.

String Programming Question :1

2012-04-29T22:40:00.001-07:00

Problem:- Given an "out" string length 4, such as "<<>>", and a word, return a new string where the word is in the middle of the out string, e.g. "<<word>>". Note: use str.substring(i, j) to extract the String starting at index i and going up to but not including index j.

makeOutWord("<<>>", "Yay") ? "<<Yay>>"
makeOutWord("<<>>", "WooHoo") ? "<<WooHoo>>"
makeOutWord("[[]]", "word") ? "[[word]]"

Solution:-

public class makeOutWord {

public static void main(String[] args) {

String result = makeOutWord("<<>>","vipul");

System.out.println(result);

}

}

private static String makeOutWord(String out, String word)

{

String result = "";

int j = out.lastIndexOf("<");

int k = out.indexOf(">");

String first = out.substring(0, 2);

String last = out.substring(2);

result = first+""+word+""+last;

return result;

}

}

Introduction to Programming Using Java, Sixth Edition

2012-04-29T22:04:00.002-07:00

http://math.hws.edu/javanotes/index.html

Link For Java Exception Handling

2012-04-29T21:31:00.002-07:00

Click on the below link.
http://www.indiabix.com/java-programming/exceptions/

Date Exists Or Not

2012-04-27T01:29:00.001-07:00

Problem:-

Write a program which takes a date as input and checks whether the date exists (or) not?

Solution:-

import java.text.ParseException;

import java.util.Scanner;

import java.util.Calendar;

import java.text.ParseException;

import java.text.SimpleDateFormat;

import java.util.Date;

public class InputDate {

public static void main(String[] a)

{

//Scanner class takes input from console.

Scanner input = new Scanner(System.in);

String dateString = input.next();

boolean exists = new InputDate().dateExists(dateString);

System.out.println(exists);

}

private boolean dateExists(String date)

{

try

{

SimpleDateFormat sdf = new SimpleDateFormat("dd/MM/yyyy");

//This method Specifies whether or not date/time interpretation is to be lenient.

sdf.setLenient(false);

//throws ParseExcpetion if date not in correct format.

sdf.parse(date);

return true;

}catch(ParseException e)

{

return false;

}