in first string class it create in heep memory and second 
is created object in constant memeory we cannot change the 
second one

In first statement String s = "vijay"

Means it will create a single instance and single reference 
variable

but in second statement

String s = new String("vijay");

Means it will create a two instances and single reference 
variable

i got your answer,what are all the two instance in 
that?.....

the two instances are created with the same name but one is 
storing in constant pool and another one is saved in the 
non constant pool.

Thanks a lot Karun....

am unable to get constant pool and non constant pool?

can you please explain it and send it to my id.

sushreekp@gmail.com

the first case does: if u write first case , one object and 
one refernce will be created. object will be created in 
string pool.
But when u write 2nd case , two object and one refernce 
will be created , one in string pool and one in heap.

as kiran said in the first answer that the string created 
in the heap memory can be changed,is it that the memory in 
the heap can be changed.I read it as heap provides a stable 
storage.Please clarify.Thanks in advance.

Hi All,
  Here one object is stored in the heap and you said that 
you can change that, but  bydefault String objects are 
immutable(ReadOnly), how can u change it?

first one will create an object on the heap
second one will create two objects one will saved on the 
heap and another will get saved on the string pool

Guys please don't miss guide.

Karun you r absolutely right, but there is one big
difference between them

String s="vijay"; --> This is string literal

String s=new String("vijay"); --> String Object

Definitely first one gives the better performance than
second one, why because..

JVM maintains an internal list of references for interned
Strings( POOL of unique strings) to avoid duplicate string
objects in heap memory. when ever the JVM loads string
literals from class file and executes, it checks whether
that string exists in the internal list or not. If it is
already exists in the list then it does not create new
string and it uses the references to the existing String
object. JVM does this type by checking tinternally for
string literal but not for string object which it creates
through 'new' keyword

You can explicitly force the JVM todo this type of checking
for string objects which are created through 'new' keyword
using "String.intern()" method. This forces the JVM to check
the internal list and use the existing String object if it
is already present.