Thread.sleep() sends the current thread into the "Not 
Runnable" state for some amount of time. The thread keeps 
the monitors it has aquired -- i.e. if the thread is 
currently in a synchronized block or method no other thread 
can enter this block or method. If another thread calls 
t.interrupt() it will wake up the sleeping thread. 
Note that sleep is a static method, which means that it 
always affects the current thread (the one that is 
executing the sleep method). A common mistake is to call 
t.sleep() where t is a different thread; even then, it is 
the current thread that will sleep, not the t thread. 

object.wait() sends the current thread into the "Not 
Runnable" state, like sleep(), but with a twist. Wait is 
called on a object, not a thread; we call this object 
the "lock object." Before lock.wait() is called, the 
current thread must synchronize on the lock object; wait() 
then releases this lock, and adds the thread to the "wait 
list" associated with the lock. Later, another thread can 
synchronize on the same lock object and call lock.notify(). 
This wakes up the original, waiting thread. Basically, wait
()/notify() is like sleep()/interrupt(), only the active 
thread does not need a direct pointer to the sleeping 
thread, but only to the shared lock object.

The main difference is if we need the thread wants to block
particular period of time we just choose sleep().
and when the thread called wait() means it will blocked
untill we will call notify(),notifyAll();

Wait() : This function takes parameters as milliseconds and
puts the thread in wait state for the desired time of the
programmer after time passes the execution starts again.

Sleep() : This function is also used for same purpose using
his function by java you can put a thread in sleep state
.sleep does not contains any parameters so the thread will
not be automatically start execution It needs a wake up
signal again which can be Notify().or other function are
also provided by java.

So the main difference in Wait() and sleep() is wait takes
time parameter and wait for specific time only and sleep
throws a thread in sleep mode for unspecified time.

Sleep():

Pause  for  NUMBER  seconds.  SUFFIX may be 's' for seconds 
(the default), 'm' for minutes, 'h' for hours or 'd' for 
days.  Unlike most implementations that require NUMBER be 
an integer, here NUMBER may be an arbitrary floating point 
number.


Wait():

The  wait  function  suspends execution of the current 
process until a child has exited, or until a signal is 
delivered whose action  is  to terminate  the  current 
process or to call a signal handling function. If a child 
has already exited by the time of  the  call (a  so-
called "zombie" process),  the  function  returns  
immediately. Any system resources used by the child are 
freed.