"=="的问题

Question

String s1 = new String("Hello");
String s2 = new String("Hello");
String s3 = "Hello";
String s4 = "Hello";
System.out.println(s1 == s2);//false
System.out.println(s3 == s4);//true

int a = 3;
int b = 3;
Integer a1 = 5;
Integer b1 = 5;
Integer a2 = new Integer(5);
Integer b2 = new Integer(5);
System.out.println(a == b);//true
System.out.println(a1 == b1);//true
System.out.println(a2 == b2);//falsenew String 与 直接给String引用赋值不一样吗？
为什么会是这样的结果？
还有Integer。

Answer 1

月经贴，自己去看：
http://topic.csdn.net/u/20081231/13/4c342bec-5afd-4ab7-bce7-4b7b98cabbc2.html

Answer 2

. 首先String不属于8种基本数据类型，String是一个对象。因为对象的默认值是null，所以String的默认值也是 null；但它又是一种特殊的对象，有其它对象没有的一些特性。2. new String()和new String(“”)都是申明一个新的空字符串，是空串不是null；3. String str=”kvill”；String str=new String (“kvill”);的区别：在这里，我们不谈堆，也不谈栈，只先简单引入常量池这个简单的概念。常量池(constant pool)指的是在编译期被确定，并被保存在已编译的.class文件中的一些数据。它包括了关于类、方法、接口等中的常量，也包括字符串常量。 

Answer 3

s1和s2是两个不同的引用。地址不同。而==比的时候比的是地址。肯定不同了。
s3和s4是创建在string pool中的，如果有Hello了，就会返回这个串。所以相同。
int类似

Answer 4

-128到127被缓存了！源码public static Integer valueOf(int i) {
    final int offset = 128;
    if (i >= -128 && i <= 127) { // must cache 
        return IntegerCache.cache[i + offset];
    }
        return new Integer(i);
    }

Answer 5

-128到127被缓存了！源码public static Integer valueOf(int i) {
    final int offset = 128;
    if (i >= -128 && i <= 127) { // must cache 
        return IntegerCache.cache[i + offset];
    }
        return new Integer(i);
    }

Answer 6

new 是开辟新的地址进行存贮 ，==是引用关系，没有改变存贮的地址。

Answer 7

是我没说明白呢，还是我没看懂各位的回答呢？
可以先看s1,s2,s3,s4
        System.out.println(s1 == s2);//false
        System.out.println(s3 == s4);//true主要是这个区别

Answer 8

这里s1,s2是两个指向不同的对象的一个引用，只是对象的值相同，用equals()就可以看到是true了

Answer 9

“==” 相比的时两个指针指向同一个对象！！
String s3 = "Hello";
String s4 = "Hello";
s3和s4指向的是 同一个对象"Hello"String s1 = new String("Hello");
String s2 = new String("Hello");两个new String("Hello");时两个对象，所以s1和s2时不“==”的new String("str") 创建的时一个新的对象

Answer 10

你 每new一次 就会建立一个新的对象，所以不相等
明白吗

Answer 11

下面是一些string相关的常见问题：
String中的final用法和理解
final stringbuffer a = new stringbuffer("111");
final stringbuffer b = new stringbuffer("222");
a=b;//此句编译不通过
final stringbuffer a = new stringbuffer("111");
a.append("222");//编译通过
可见，final只对引用的"值"(即内存地址)有效，它迫使引用只能指向初始指向的那个对象，改变它的指向会导致编译期错误。至于它所指向的对象的变化，final是不负责的。
String 常量池问题的几个例子
下面是几个常见例子的比较分析和理解：
【1】
Java code
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】
Java code
String a = "ab";  
String bb = "b";  
String b = "a" + bb;  
System.out.println((a == b)); //result = false
分析：jvm对于字符串引用，由于在字符串的"+"连接中，有字符串引用存在，而引用的值在程序编译期是无法确定的，即"a" + bb无法被编译器优化，只有在程序运行期来动态分配并将连接后的新地址赋给b。所以上面程序的结果也就为false。【3】
Java code
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】
Java code
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 采用连接运算符（+）效率低下原因分析，形如这样的代码：
Java code
public class 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方法理解和分析：
Java code
public class 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的值相等。