Question: i know that java programs are first compiled and a bytecode is generated which is platform independent. But my question is why is this bytecode interpreted in the next stage and not compiled even though compilation is faster than interpretation in general??

Answer: 
You answered your own question. Byte code is platform independent. If the compiled code was executed then it would not work on every OS. This is what C does and it is why you have to have one version for every OS. 

As others have suggested, the JVM does actually compile the code using [JIT](http://en.wikipedia.org/wiki/Just-in-time_compilation). It is just not saved anywhere. Here is a nice quote to sum it up

> 
> In a bytecode-compiled system, source code is translated to an
>  intermediate representation known as bytecode. Bytecode is not the
>  machine code for any particular computer, and may be portable among
>  computer architectures. The bytecode may then be interpreted by, or
>  run on, a virtual machine. The JIT compiler reads the bytecodes in
>  many sections (or in full rarely) and compiles them interactively into
>  machine language so the program can run faster
> 
> 
>
Byte code is platform independent. Once compiled into bytecode, it could run on any system.

As it says on Wikipedia, 

> 
> [`Just-in-time compilation (JIT)`](http://en.wikipedia.org/wiki/Just-in-time_compilation), also known as dynamic translation, is
>  a method to improve the runtime performance of computer programs. 
> 
> 
> 

I recommend you to read this article. Its gives the [`basic working of JIT compiler`](http://www.javacommerce.com/displaypage.jsp?name=jit_compiler.sql&id=18268) for Java VM. 

> 
> JIT compilers alter the role of the VM a little by directly compiling
>  Java bytecode into native platform code, thereby relieving the VM of
>  its need to manually call underlying native system services. The
>  purpose of JIT compilers, however, isn't to allow the VM to relax. By
>  compiling bytecodes into native code, execution speed can be greatly
>  improved because the native code can be executed directly on the
>  underlying platform.
> 
> 
> When JIT compiler is installed, instead of the VM calling the
>  underlying native operating system, it calls the JIT compiler. The JIT
>  compiler in turn generates native code that can be passed on to the
>  native operating system for execution. The primary benefit of this
>  arrangement is that the JIT compiler is completely transparent to
>  everything except the VM.
> 
> 
>