A string pool is a collection of references to String
objects. Strings, even though they are immutable, are still
objects like any other in Java. Objects are created on the
heap and Strings are no exception. So, Strings that are part
of the "String Literal Pool" still live on the heap, but
they have references to them from the String Literal Pool.

When a .java file is compiled into a .class file, any String
literals are noted in a special way, just as all constants
are. When a class is loaded (note that loading happens prior
to initialization), the JVM goes through the code for the
class and looks for String literals. When it finds one, it
checks to see if an equivalent String is already referenced
from the heap. If not, it creates a String instance on the
heap and stores a reference to that object in the constant
table. Once a reference is made to that String object, any
references to that String literal throughout your program
are simply replaced with the reference to the object
referenced from the String Literal Pool.

Hi... Basically string pooling is a part of the heap memory
all string literals will be storing in the string pool 
memory.
for example: String s1="DEVARATHNAM";// This is a string 
literal ,will store in the string pool .

string pooling is maintenance of pool of strings when ever 
a String Object is created one instance will be saved on 
stack and another instance will get saved on the pool.

dont misguide please, all the string objects created 
without new operator are stored in pool which is a space in 
memory, if any other object has the same content then a new 
object will not be created.

so when we use a new operator an object will be created
right and every object will be save on garbage collectible heap.

See,

String s = new String("Shiva");

Its creating two instances and one reference.

In the Two instance one is stored in Constant pool and 
another one is stored in temp' pool.

What about String s = "Shiva";

Anybody can, pls clarify...