Equals和==运算符

http://apps.hi.baidu.com/share/detail/34744201

一.   Equals和==运算符 

代码：

1.  public static void test() {  

2.      String x = "hello";  

3.      String y = "world";  

4.      String z = new String("helloworld");  

5.      String a = "helloworld";  

6.      System.out.println("x+y equals z:" + (x + y).equals(z));  

7.      System.out.println("a == z:" + (a == z));  

8.      System.out.println("x == hello:" + (x == "hello"));  

9.      System.out.println("a == helloworld:" + (a == "hello" + "world"));  

10.     System.out.println("a == x+y:" + (a == (x + y)));  

11. } 

结果： 

x+y equals z:true 

a == z:false 

x == hello:true 

a == helloworld:true 

a == x+y:false 

 

分析： 

1.String.equals()方法比较的是字符串的内容,所以(x + y).equals(z)为true. 

2.“==”比较的是 String 实例的引用,很明显 a 和z 并不是同一个 String 实例,所以(a == z)为false. 

3.根据常量池的知识，容易得知(x == "hello")和(a == "hello" +"world")都为true. 

(常量池指的是在编译期被确定并被保存在已编译的.class 文件中的一些数据。它包含了关于方法、类、接口等，当然还有字符串常量的信息。也就是所谓的持久代。) 

4.那么(a == (x + y))为什么是false呢？这点暂点有点不大清楚。初步认为是x+y是引用相加，不能放入常量池。 

知识补充：摘自http://yiliner.iteye.com/blog/207723

JVM运行时数据区的内存模型由五部分组成：

【1】方法区

【2】堆：存放数据常量
【3】JAVA栈：存放数据的引用对象，可以这样理解吧
【4】PC寄存器
【5】本地方法栈

下面是一些String相关的常见问题：

String中的final用法和理解
final StringBuffer a = new StringBuffer("111");
final StringBuffer b = new StringBuffer("222");
a=b;//此句编译不通过

finalStringBuffer a = new StringBuffer("111");
a.append("222");//编译通过

可见，final只对引用的"值"(即内存地址)有效，它迫使引用只能指向初始指向的那个对象，改变它的指向会导致编译期错误。至于它所指向的对象的变化，final是不负责的。

String常量池问题的几个例子

下面是几个常见例子的比较分析和理解：
[1]
String a = "a1"; 
String b = "a" + 1; 
System.out.println((a == b)); //result = true
String a = "atrue"; 
String b = "a" + "true"; 
System.out.println((a == b)); //result = true
String a = "a3.4"; 
String b = "a" + 3.4; 
System.out.println((a == b)); //result = true

分析：JVM对于字符串常量的"+"号连接，将程序编译期，JVM就将常量字符串的"+"连接优化为连接后的值，拿"a"+ 1来说，经编译器优化后在class中就已经是a1。在编译期其字符串常量的值就确定下来，故上面程序最终的结果都为true。

[2]
String a = "ab"; 
String bb = "b"; 
String b = "a" + bb; 
System.out.println((a == b)); //result = false

分析：JVM对于字符串引用，由于在字符串的"+"连接中，有字符串引用存在，而引用的值在程序编译期是无法确定的，即"a"+ bb无法被编译器优化，只有在程序运行期来动态分配并将连接后的新地址赋给b。所以上面程序的结果也就为false。

[3]
String a = "ab"; 
final String bb = "b"; 
String b = "a" + bb; 
System.out.println((a == b)); //result = true

分析：和[3]中唯一不同的是bb字符串加了final修饰，对于final修饰的变量，它在编译时被解析为常量值的一个本地拷贝存储到自己的常量池中或嵌入到它的字节码流中。所以此时的"a"+ bb和"a"+ "b"效果是一样的。故上面程序的结果为true。

[4]
String a = "ab"; 
final String bb = getBB(); 
String b = "a" + bb; 
System.out.println((a == b)); //result = false 
private static String getBB() {
return "b"; 
}

分析：JVM对于字符串引用bb，它的值在编译期无法确定，只有在程序运行期调用方法后，将方法的返回值和"a"来动态连接并分配地址为b，故上面程序的结果为false。

通过上面4个例子可以得出得知：
String  s  =  "a" + "b" +"c";   
就等价于String s ="abc";   

String  a  =  "a";   
String  b  =  "b";   
String  c  =  "c";   
String  s  =   a  +  b  + c;  

这个就不一样了，最终结果等于：   
StringBuffer temp = new StringBuffer();   
temp.append(a).append(b).append(c);   
String s = temp.toString();

由上面的分析结果，可就不难推断出String采用连接运算符（+）效率低下原因分析，形如这样的代码：

publicclass Test {
public static void main(String args[]) {
String s = null;
for(int i = 0; i < 100; i++) {
s += "a";
}
}
}

每做一次 + 就产生个StringBuilder对象，然后append后就扔掉。下次循环再到达时重新产生个StringBuilder对象，然后 append 字符串，如此循环直至结束。 如果我们直接采用StringBuilder 对象进行append 的话，我们可以节省N - 1 次创建和销毁对象的时间。所以对于在循环中要进行字符串连接的应用，一般都是用StringBuffer或StringBulider对象来进行append操作。

String对象的intern方法理解和分析：

publicclass Test4 {
private static String a = "ab"; 
public static void main(String[] args){
String s1 = "a";
String s2 = "b";
String s = s1 + s2;
System.out.println(s == a);//false
System.out.println(s.intern() == a);//true  
}
}

这里用到Java里面是一个常量池的问题。对于s1+s2操作，其实是在堆里面重新创建了一个新的对象,s保存的是这个新对象在堆空间的的内容，所以s与a的值是不相等的。而当调用s.intern()方法，却可以返回s在常量池中的地址值，因为a的值存储在常量池中，故s.intern和a的值相等