Q:

How does Java implement String pooling?

I want to understand the string pool more deeply. Please help me get to the source class file containing this implementation in Java. 
The question is more of related to finding the source code or implementation of the String Pool to delve deeper on this concept to know more about some unknown or elusive things in it. This way we can make the use of strings even more efficiently or think of some other way to implement our own garbage collections in case we have an application creating so many literals and string objects.

A:

I am sorry to disappoint you but the Java String-Pool is not an actual Java class but somewhere implemented in the JVM i.e. it is writen as C++ code.
If you look at the source code of the String class (pretty much all the way down) you see that the intern() method is native.
You will have to go through some JVM code to get more information.
Edit:
Some implementation can be found here (C++ header, C++ implementation). Search for StringTable.
Edit2: As Holger pointed out in the comments, this is not a hard requirement of the JVM implementation. So it is possible to have a JVM that implements the String Pool differently, e.g. using an actual Java class. Though all commonly used JVMs I am aware of implement it in the JVMs C++ code.

A:

You can go through this article: Strings, Literally

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.
So, in the example shown above, there would be only one entry in the
  String Literal Pool, which would refer to a String object that
  contained the word "someString". Both of the local variables, one and
  two, would be assigned a reference to that single String object. You
  can see that this is true by looking at the output of the above
  program. While the equals() method checks to see if the String objects
  contain the same data ("someString"), the == operator, when used on
  objects, checks for referential equality - that means that it will
  return true if and only if the two reference variables refer to the
  exact same object. In such a case, the references are equal. From the
  above output, you can see that the local variables, one and two, not
  only refer to Strings that contain the same data, they refer to the
  same object.

