让我郁闷的基础题！

[BenXx]

 public class TestAlll { 

public static void main(String[] args) { 

Integer a = 12; 
Integer a2 = 12; 
if(a == a2 ){ 
System.out.println("1111111111"); 
} 

Float ff = 1.0f; 
Float fb = 1.0f; 
if(ff == fb){ 
System.out.println("2222222222"); 
} 

String str1 = "1123321"; 
String str2 = "1123321"; 
if(str1 == str2){ 
System.out.println("3333333333333"); 
} 

Double df = 1.0; 
Double db = 1.0; 
if(df == db){ 
System.out.println("4444444444444"); 
} 

} 
}  
 

为什么结果是111111111111
33333333333333

在我影像中。。。String类对象不能直接用“==”比较值的呀。。。难道它们地址一样？是同一个对象？

还是我脑袋中一直是个错误的概念？

[一根黑毛]

==比较的是内存地址
equals比较的是内容。
String str1 = "1123321";
String str2 = "1123321";
由于你不是new产生的，当你String str1= "1123321";
会先在字符串池中创建一个对象，
当你String str2 = "1123321";
这时候java会先寻找是否存在"1123321"，若存在则不会创建新的，
若不存在才会创建新的。所以他们的引用都是指向同一个地址。

[BenXx]

哦~了解！还是基础不扎实！！谢谢啦

[一根黑毛]

String str1 = new String("abc");
String str2 = new String("abc");
这时候str1 == str2 的结果会是false；
因为你每new一次就会在堆中开辟内存，所以他们指向的地址是不同的。

论坛中有很多帖子讲String的，多看看。

[ol_soft]

这四组都是相等的，因为：
Integer a1 = 12;
Integer a2 = 12;
当你在内存中创建一个对象时，在创建一个相同‘值’的对象时，如果没有使用new关键字创建，编译器会到内存中寻找，如果找到了，就返回对这个‘值’的引用，如果不存在，再重新创建。
所以你已经创建了a1，再创建a2时内存中有这个‘值’,a2就会引用这个值。
如果你这么做：
Integer a1 = new Integer(12);
Integer a2 = new Integer(12);
那么a1！=a2，因为你已经告诉编译器给你再分配一个这样的值了，不考虑内存是否存在一样的值。

[aoliwen521]

高！！

[cjf068]

知道规律就好了 只是JAVA内部的一种机制

[richard_2010]

1楼回答的已经很清楚了
lz知道了就结贴吧

[coderone]

照4楼所说，那么double 和float怎么就不等呢？
是因为小数的问题吗？？

[ssqtjffcu]

[Quote=引用 8 楼 coderone 的回复:]
照4楼所说，那么double 和float怎么就不等呢？
是因为小数的问题吗？？
[/Quote]
期待高人解答

[scueczhang]

==比较的是内存地址
equals比较的是内容。
由于你不是new产生的，当你String str1= "1123321";
会先在字符串池中创建一个对象，
当你String str2 = "1123321";
这时候java会先寻找是否存在"1123321"，若存在则不会创建新的，
若不存在才会创建新的。所以他们的引用都是指向同一个地址。

[yangkaixin1226]

[Quote=引用 4 楼 ol_soft 的回复:]
这四组都是相等的，因为：
Integer a1 = 12;
Integer a2 = 12;
当你在内存中创建一个对象时，在创建一个相同‘值’的对象时，如果没有使用new关键字创建，编译器会到内存中寻找，如果找到了，就返回对这个‘值’的引用，如果不存在，再重新创建。
所以你已经创建了a1，再创建a2时内存中有这个‘值’,a2就会引用这个值。
如果你这么做：
Integer a1 = new Integer(12);
Integer a2 = new Integer(12);
那么a1！=a2，因为你…
[/Quote]
应该是这样

[鱼C缸]

楼上 有理

[xigen9901]

[Quote=引用 11 楼 yangkaixin1226 的回复:]
引用 4 楼 ol_soft 的回复:
这四组都是相等的，因为：
Integer a1 = 12;
Integer a2 = 12;
当你在内存中创建一个对象时，在创建一个相同‘值’的对象时，如果没有使用new关键字创建，编译器会到内存中寻找，如果找到了，就返回对这个‘值’的引用，如果不存在，再重新创建。
所以你已经创建了a1，再创建a2时内存中有这个‘值’,a2就会引用这个值。
如果你这么做：
Integer a1 = new Integer(12);
Integer a2 = ne…
[/Quote]
不全都是~~~楼主的例子就是说明

[chen2353551]

同问！！！[Quote=引用 8 楼 coderone 的回复:]
照4楼所说，那么double 和float怎么就不等呢？
是因为小数的问题吗？？
[/Quote]

[ZangXT]

Integer a = 12;
Integer a2 = 12;
涉及到java的自动装箱机制，实际是这么处理的
Integer a = Integer.valueOf(12);
Integer b = Integer.valueOf(12);

后面的Double同样如此，用Double.valueOf(1.0）实现

对应Integer，Integer类中自动创建了-128~127之间的对象，如果你要封装的数在这个范围之内，返回的就是固定的已经创建的对象，如果在此范围之外，则通过new来创建。
对于Double，就无法这么处理了。因为int可以精确表示，0，1，这些都可以直接缓存。
但是Double你总不能先创建0.01，0.111这样数不尽的数存起来吧
Integer的处理：

private static class IntegerCache {
	private IntegerCache(){}

	static final Integer cache[] = new Integer[-(-128) + 127 + 1];

	static {
	    for(int i = 0; i < cache.length; i++)
		cache[i] = new Integer(i - 128);
	}
    }
 public static Integer valueOf(int i) {
	final int offset = 128;
	if (i >= -128 && i <= 127) { // must cache 
	    return IntegerCache.cache[i + offset];  //从上面static内部类的cache中读取缓存的对象
	}
        return new Integer(i);
    }

double的处理：

public static Double valueOf(double d) {
        return new Double(d);
    }