== Vs equals()

Difference between heap and string pool memory: (Source: http://www.coderanch.com/t/390447/java/java/Difference-Heap-Pool)
Video of 6 minutes to explain this: https://www.youtube.com/watch?v=WTOiuY7cNTo

Heap:
The heap is just the area of RAM that is allotted to the JVM by the operating system for runtime activity. 
As such it is the place that objects get created during a JVM session. 

Pool:
Pool is a separate portion WITHIN the heap memory. This separate portion of heap memory is called "POOL"
The 'pool' is just a special area of the heap memory that Java sets up to store all String literals.
Imagine a box with a partition wall; on one side is the 'pool' on the other side the 'heap'. 
Everytime you use a string literal, it gets stored on the pool side, regular objects get stored on
the heap side.


Difference between HEAP memory and STACK memory
All objects are stored on the heap(including their attributes) memory.
Local variables of functions/methods(including function/method arguments) always contain primitive values 
or references and are stored on the stack memory.

Best video of 6 minutes to explain difference between == and equals() : https://www.youtube.com/watch?v=WTOiuY7cNTo

The == (double equals) returns true, if the variable reference points to the same object in memory. 
This is called “shallow comparison”.




The object class contains the equals() method. This equals() method is then implemented by String class,
Double class, Long class, Integer class, Byte class, Integer class, Boolean class.
The only thing to be noted is that the equals method is called using object and accepts a parameter which is
an object. Hence the primitive types need to be converted to Objects using Wrapper classes to call the their
respective equals() method.
Object equals(Object o)
return type and parameter, both are objects.

Best explantion for difference between == and equals(). It also explains the
difference between equals method of Object class and equals method of String class. It also explains the
difference between hashcode method of Object class and hashcode method of String class. Similarly Integer, Byte and other wrapper
classes have their own different version of hashcode and equals method. If they are not invoked then the default implementation
of hashcode and equals method mentioned in the Object class is invoked.
1) --> http://stackoverflow.com/questions/16089282/how-equals-method-works
2) -->http://howtodoinjava.com/2012/10/09/working-with-hashcode-and-equals-methods-in-java/

If the equals method is passes with Object of Generic type, then it has to be implemented manually, so that
it can override the equals() method of the object class. Otherwise if not implemented then, equals() method
will work similar to == operator and will only compare reference(i.e. SHALLOW COMPARISON)


The equals() method calls the user implemented equals() method, which compares the object attribute values. 
The equals() method provides “deep comparison” by checking if two objects are logically equal as opposed to
the shallow comparison provided by the operator ==.

If equals() method does not exist in a user supplied class then the inherited Object class's equals() method 
will be called which evaluates if the references point to the same object in memory. In this case, the object.
equals() works just like the "==" operator.

Source -> http://www.java2novice.com/java_interview_questions/==-and-equals/