从Java的堆栈到Equals和==的比較

<span style="font-family:Microsoft YaHei;font-size:12px;">public class TestString {
	public static void main(String[] args) {
		String s1 = "Monday";
		String s2 = "Monday";
		if (s1 == s2) {
			System.out.println("s1 == s2");
		} else {
			System.out.println("s1 != s2");
		}
	}
}</span>

<span style="font-family:Microsoft YaHei;font-size:12px;">public class TestString {
public static void main(String[] args) {
String s1 = "Monday";
String s2 = new String("Monday");
if (s1 == s2)
{System.out.println("s1 == s2");}
else
{System.out.println("s1 != s2");}
if (s1.equals(s2)) {System.out.println("s1 equals s2");}
else{
System.out.println("s1 not equals s2");}
}
}</span>

<span style="font-family:Microsoft YaHei;font-size:12px;">public class TestString {
public static void main(String[] args) {
String s1 = "Monday";
String s2 = new String("Monday");
s2 = s2.intern();
if (s1 == s2)
{System.out.println("s1 == s2");}
else
{System.out.println("s1 != s2");}
if (s1.equals(s2)) {System.out.println("s1 equals s2");}
else{
System.out.println("s1 not equals s2");}
}
}</span>

<span style="font-family:Microsoft YaHei;font-size:12px;">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;
    }</span>

认识Java中堆和栈

栈与堆都是Java用来在Ram中存放数据的地方。

与C++不同。Java自己主动管理栈和堆，程序猿不能直接地设置栈或堆。
Java的堆是一个执行时数据区,类的对象从中分配空间。这些对象通过new、newarray、anewarray和 multianewarray等指令建立，它们不须要程序代码来显式的释放。

堆是由垃圾回收来负责的，堆的优势是能够动态地分配内存大小，生存期也不必事先告诉编译器。由于它是在执行时动态分配内存的。Java的垃圾收集器会自己主动收走这些不再使用的数据。但缺点是，由于要在执行时动态分配内存，存取速度较慢。

栈的优势是，存取速度比堆要快。仅次于寄存器，栈数据能够共享。

但缺点是。存在栈中的数据大小与生存期必须是确定的，缺乏灵活性。栈中主要存放一些基本类型的变量（,int, short, long, byte, float, double, boolean, char）和对象句柄。

栈有一个非常重要的特殊性，就是存在栈中的数据能够共享。

如果我们同一时候定义：
int a = 3。
int b = 3；

编译器先处理int a = 3；首先它会在栈中创建一个变量为a的引用。然后查找栈中是否有3这个值。假设没找到。就将3存放进来，然后将a指向3。

接着处理int b = 3；在创建完b的引用变量后，由于在栈中已经有3这个值，便将b直接指向3。这样，就出现了a与b同一时候均指向3的情况。

这时。假设再令a=4。那么编译器会又一次搜索栈中是否有4值，假设没有，则将4存放进来。并令a指向4；假设已经有了，则直接将a指向这个地址。因此a值的改变不会影响到b的值。 

 要注意这样的数据的共享与两个对象的引用同一时候指向一个对象的这样的共享是不同的。由于这样的情况a的改动并不会影响到b, 它是由编译器完毕的，它有利于节省空间。

而一个对象引用变量改动了这个对象的内部状态。会影响到还有一个对象引用变量。 
String是一个特殊的包装类数据。

能够用： 
String str = new String("abc"); 
String str = "abc"; 

 两种的形式来创建，第一种是用new()来新建对象的。它会在存放于堆中。每调用一次就会创建一个新的对象。 而另外一种是先在栈中创建一个对String类的对象引用变量str，然后查找栈中有没有存放"abc"，假设没有。则将"abc"存放进栈，并令str指 向”abc”，假设已经有”abc” 则直接令str指向“abc”。 

比較类里面的数值是否相等时，用equals()方法。当測试两个包装类的引用是否指向同一个对象时，用==，以下用样例说明上面的理论。 
String str1 = "abc"; 
String str2 = "abc"; 
System.out.println(str1==str2); //true 
能够看出str1和str2是指向同一个对象的。 

String str1 =new String ("abc"); 
String str2 =new String ("abc"); 
System.out.println(str1==str2); // false 
用new的方式是生成不同的对象。

每一次生成一个。

因此用另外一种方式(String str1 ="abc")创建多个”abc”字符串,在内存中事实上仅仅存在一个对象而已. 这样的写法有利与节省内存空间. 同一时候它能够在一定程度上提高程序的执行速度，由于JVM会自己主动依据栈中数据的实际情况来决定是否有必要创建新对象。而对于String str = new String("abc")的代码。则一概在堆中创建新对象，而无论其字符串值是否相等，是否有必要创建新对象，从而加重了程序的负担。

 还有一方面, 要注意: 我们在使用诸如String str = "abc"；的格式定义类时。总是想当然地觉得，创建了String类的对象str。操心陷阱！对象可能并没有被创建！

而可能仅仅是指向一个先前已经创建的 对象。仅仅有通过new()方法才干保证每次都创建一个新的对象。 
因为String类的immutable性质，当String变量须要常常变换其值时。应该考虑使用StringBuffer类，以提高程序效率。 

************************************************************************************************************************************************************

Java中Equals和==的差别

java中的数据类型，可分为两类： 
1.基本数据类型，也称原始数据类型。byte,short,char,int,long,float,double,boolean 
  他们之间的比較，应用双等号（==）,比較的是他们的值。

 
2.复合数据类型(类) 
  当他们用（==）进行比較的时候，比較的是他们在内存中的存放地址，所以，除非是同一个new出来的对象，他们的比較后的结果为true，否则比較后结果为false。

JAVA其中全部的类都是继承于Object这个基类的。在Object中的基类中定义了一个equals的方法，这种方法的初始行为是比較对象的内存地 址，但在一些类库其中这种方法被覆盖掉了。如String,Integer,Date在这些类其中equals有其自身的实现。而不再是比較类在堆内存中的存放地址了。

  对于复合数据类型之间进行equals比較。在没有覆写equals方法的情况下，他们之间的比較还是基于他们在内存中的存放位置的地址值的，由于Object的equals方法也是用双等号（==）进行比較的。所以比較后的结果跟双等号（==）的结果同样。

<span style="font-family:Microsoft YaHei;font-size:12px;">public class TestString {
	public static void main(String[] args) {
		String s1 = "Monday";
		String s2 = "Monday";
		if (s1 == s2) {
			System.out.println("s1 == s2");
		} else {
			System.out.println("s1 != s2");
		}
	}
}</span>

编译并执行程序，输出：s1 == s2说明：s1 与 s2 引用同一个 String 对象 -- "Monday"!
2.再略微修改一下程序，会有更奇怪的发现：

<span style="font-family:Microsoft YaHei;font-size:12px;">public class TestString {
public static void main(String[] args) {
String s1 = "Monday";
String s2 = new String("Monday");
if (s1 == s2)
{System.out.println("s1 == s2");}
else
{System.out.println("s1 != s2");}
if (s1.equals(s2)) {System.out.println("s1 equals s2");}
else{
System.out.println("s1 not equals s2");}
}
}</span>

我们将s2用new操作符创建
程序输出：
s1 != s2
s1 equals s2
说明：s1 s2分别引用了两个"Monday"String对象

3. 字符串缓冲池
原来，程序在执行的时候会创建一个字符串缓冲池当使用 s2 = "Monday" 这种表达是创建字符串的时候，程序首先会在这个String缓冲池中寻找同样值的对象，在第一个程序中。s1先被放到了池中，所以在s2被创建的时候，程序找到了具有同样值的 s1
将s2引用s1所引用的对象"Monday"
第二段程序中，使用了 new 操作符，他明确的告诉程序："我要一个新的！不要旧的。"于是一个新的"Monday"Sting对象被创建在内存中。他们的值同样。可是位置不同。一个在池中游泳一个在岸边歇息。哎呀。真是资源浪费。明明是一样的非要分开做什么呢？

4.再次更改程序：

<span style="font-family:Microsoft YaHei;font-size:12px;">public class TestString {
public static void main(String[] args) {
String s1 = "Monday";
String s2 = new String("Monday");
s2 = s2.intern();
if (s1 == s2)
{System.out.println("s1 == s2");}
else
{System.out.println("s1 != s2");}
if (s1.equals(s2)) {System.out.println("s1 equals s2");}
else{
System.out.println("s1 not equals s2");}
}
}</span>

这次增加：s2 = s2.intern();
程序输出：
s1 == s2
s1 equals s2
原 来。（java.lang.String的intern()方法"abc".intern()方法的返回值还是字符串"abc"，表面上看起来好像这个方 法没什么用处。但实际上。它做了个小动作：检查字符串池里是否存在"abc"这么一个字符串，假设存在，就返回池里的字符串。假设不存在。该方法会 把"abc"加入到字符串池中，然后再返回它的引用。
）

************************************************************************************************************************************************************

查看源代码发表小结：

<span style="font-family:Microsoft YaHei;font-size:12px;">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;
    }</span>

上面的这一段是String的equals源代码，通过细心的解读我们能够发现当中的奥妙。

String重写的equals方法保留了Object比較两个对象内容地址是否相等。

在此基础上添加了一个比較String的值是否相等。这是什么意思呢。 假设equals括号中的对象不是String类型的。那么比較他和原对象的内存地址是否相等。假设instanceofString 那么先把这个对象转为String，再把它的值变为char数组，也就是以下的value，假设他们的char数组长度相等再对这个数组的char进行一个个遍历比較是否一样。假设都一样就equals为true，否则为false。