String类的equal(),hashCode(),==

在javaJDK中，大部分的equal函数都是先判断对象是不是属于同一类，如果是则比较对象的值是不是相等，如果是则返回相等；在String类中先判断是不是都是String类，再判断数组是不是相等，如果是则返回true;

   public boolean equals(Object anObject) {
        if (this == anObject) {
            return true;
        }
        if (anObject instanceof String) {
            String anotherString = (String)anObject;
            int n = value.length;
            if (n == anotherString.value.length) {
                char v1[] = value;
                char v2[] = anotherString.value;
                int i = 0;
                while (n-- != 0) {
                    if (v1[i] != v2[i])
                        return false;
                    i++;
                }
                return true;
            }
        }
        return false;
    }

hashCode函数的形式比较多样，在String类中以数组中每个元素的int值总和作为hashcode；

   public int hashCode() {
        int h = hash;
        if (h == 0 && value.length > 0) {
            char val[] = value;

            for (int i = 0; i < value.length; i++) {
                h = 31 * h + val[i];
            }
            hash = h;
        }
        return h;
    }

定义String的方法：
1,String str1 = "hello";
2,String str2 = new String("hello");

第一种方法：引用str1被存放在栈区，字符串常量"hello"被存放在常量池，引用str1指向了常量池中的"hello"(str1中的存放了常量池中"hello"的地址)。

第二种方法：引用str2被存放在栈区，同时在堆区开辟一块内存用于存放一个新的String类型对象。（同上，str2指向了堆区新开辟的String类型的对象）

这两种方法的区别：

第一种：常量池的字符串常量，不能重复出现，也就是说，在定义多个常量时，编译器先去常量池查找该常量是否已经存在，如果不存在，则在常量池创建一个新的字符串常量；如果该常量已经存在，那么新创建的String类型引用指向常量池中已经存在的值相同的字符串常量，也就是说这是不在常量池开辟新的内存。

第二种：在堆中创建新的内存空间，不考虑该String类型对象的值是否已经存在。换句话说：不管它的 只是多少，第二种方法的这个操作已经会产生的结果是：在堆区开辟一块新的内存，用来存放新定义的String类型的对象。

所以String str1 = "hello";和String str2 = "hello";指向的是同一个空间，str1==str2；
String str1 = new String("hello");和String str2 = new String("hello");指向的是不同的空间，str1!=str2;

测试代码和结果如下：

package test;

public class Sametest {
public void MethodA(String a,String b)
{

	if(a.equals(b))
	{
		System.out.println("a.equals(b)");
	}
	else
	{
		System.out.println("!a.equals(b)");
	}
	
	if(a.hashCode()==b.hashCode())
	{
		System.out.println("a.hashCode()==b.hashCode()");
	}
	else
	{
		System.out.println("a.hashCode()!=b.hashCode()");
	}
	
	if(a==b)
	{
		System.out.println("a==b");
	}
	else
	{
		System.out.println("a!=b");
	}
}
public static void main(String[] argv)
{
	Sametest test=new Sametest();
	
	String a="abcd";
	String b="abcd";
	String a1=new String("abcd");
	String b1=new String("abcd");
	System.out.println("常量区测试：");
	test.MethodA(a, b);
	System.out.println();
	
	System.out.println("堆区测试：");
	test.MethodA(a1, b1);
	System.out.println();

}
}

结果如下：

常量区测试：
a.equals(b)
a.hashCode()==b.hashCode()
a==b

堆区测试：
a.equals(b)
a.hashCode()==b.hashCode()
a!=b

以上对于String类的内存分配来自：http://jingyan.baidu.com/article/8275fc869a070346a03cf6f4.html

关于java内存分配，有一些文章写得很好
http://blog.csdn.net/rj042/article/details/6871030
http://www.cnblogs.com/whgw/archive/2011/09/29/2194997.html