Java迷题：等于，还是不等于？

xiaoyu1985ban

浏览: 132566 次
性别:
来自: 大连

最近访客更多访客>>

a805617894a

上海正受

loven_11

yangganboy

博主相关

博客

微博

相册

留言

关于我

文章分类

社区版块

存档分类

博客分类：

Java

自动装箱相等字节码缓存

等于还是不等于？

看来看下面的一段代码：

代码片段1

public static void main(final String[] args) {
    Integer a = new Integer(100);
    Integer b = 100;
    System.out.println(a == b); 
}

这段代码的输出是什么？相信很多人都会很容易的猜到：false，因为a、b两个对象的地址不同，用“==”比较时是false。恭喜你，答对了。

再看下面的一段代码：

代码片段2

public static void main(final String[] args) {
    Integer a = 100;
    Integer b = 100;
    System.out.println(a == b); 
}

你可能会回答，这没什么不一样啊，所以还是false。很遗憾，如果你执行上面的一段代码，结果是true。

上面的代码可能让你有些意外，那好吧，再看看下面的这段代码：

代码片段3

public static void main(final String[] args) {
    Integer a = 156;
    Integer b = 156;
    System.out.println(a == b); 
}

结果是true吗？很遗憾，如果你执行上面的一段代码，结果是false。

感到吃惊吗？那最后再看下面的一段代码：

代码片段4

public static void main(final String[] args) {
    Integer a = Integer.valueOf(100);
    Integer b = 100;
    System.out.println(a == b); 
}

最后的结果，可能你已经猜到了，是true。

为什么会这样？

现在我们分析一下上面的代码。可以很容易的看出，这一系列代码的最终目的都是用“==”对两个对象进行比较。Java中，如果用“==”比较两个对象结果为true，说明这两个对象实际上是同一个对象，false说明是两个对象。

现在，我们来看看为什么会出现上面的现象。

我们先看代码片段4：最后的运行结果是true，说明a、b两个对象实际上是同一个对象。但是a对象是通过调用Integer的valueOf方法创建的，而b对象是通过自动装箱创建出来的，怎么会是同一个对象呢？难道问题在字节码那里，毕竟Java程序是依靠虚拟器运行字节码来实现的。

通过jdk中自带的工具javap，解析字节码，核心的部分摘取如下：

   0:	bipush	100
   2:	invokestatic	#16; //Method java/lang/Integer.valueOf:(I)Ljava/lang/Integer;
   5:	astore_1
   6:	bipush	100
   8:	invokestatic	#16; //Method java/lang/Integer.valueOf:(I)Ljava/lang/Integer;

代码中我们只调用了一次Integer.valueOf方法，但是字节码中出现了两次对Integer.valueOf方法的调用。那么另一次是哪里呢？只可能在自动装箱时调用的。因此这段代码实际上等价于：

public static void main(final String[] args) {
    Integer a = Integer.valueOf(100);
    Integer b = Integer.valueOf(100);
    System.out.println(a == b); 
}

现在问题就简单了：看jdk源代码，查看valueOf方法的具体实现：

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);
}

看到这儿，上面的代码就很明确了：对于-128到127的数字，valueOf返回的是缓存中的对象。所以两次调用Integer.valueOf(100)返回的都是同一个对象。

我们再先看代码片段3：根据上面的分析，代码片段3实际上等价于以下代码：

public static void main(final String[] args) {
    Integer a = Integer.valueOf(156);
    Integer b = Integer.valueOf(156);
    System.out.println(a == b); 
}

由于156不在-128到127范围内，所以两个对象都是通过new Integer()的方式创建的，所以最后结果为false。

片段1和片段2就不做具体分析了，相信读者可以自行分析。

最后，请大家思考一下问题：通过上面的分析，了解到整数的自动装箱是通过Integer.valueOf(int number)实现的，那么自动拆箱是如何实现的呢？

声明：

文章来自于ITeye，欢迎访问我的博客:xiaoyu1985ban.iteye.com

ITeye文章版权属于作者，受法律保护。没有作者书面许可不得转载。若作者同意转载，必须以超链接形式标明文章原始出处和作者。

63
顶

9
踩

分享到：

【转】给自己的建议 | 【转】三种健身妙法-每天五分钟简便易行有 ...

2012-01-30 15:38
浏览 10110
评论(38)
分类:编程语言
查看更多

38 楼 lantian_123 2012-02-04

期望更多高质量的文章

37 楼 kjj 2012-02-04

据说对象相等得用equals,对于int == 足够了, 而 Integer是对象,需要equals ,你懂得!!

36 楼 zhangkaitao 2012-02-04

之前看到过类似的帖子 http://sishuok.com/forum/blogPost/list/500.html

35 楼 zhangkaitao 2012-02-04

之前看到过类似的帖子 http://sishuok.com/forum/blogPost/list/500.html

34 楼 greatwqs 2012-02-03

    public final class Integer extends Number implements Comparable<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];
	}
        return new Integer(i);
    }

}

装箱: 自动Integer.valueOf();
Integer   jjj = 1;
编译后源码:
Integer   jjj = Integer.valueOf(1);

拆箱: 自动对象.intValue();
int       jjj = new Integer(2);
编译后源码:
int       jjj = (new Integer(2)).intValue();

33 楼 shuangpan.zhang 2012-02-03

受教了。。。

32 楼 zhao_chong 2012-02-03

多看看源码就什么都有了...

31 楼 JoysXX 2012-02-02

nice……好文章

30 楼 mj2342003 2012-02-02

蛮有意思的呵呵..看源代码有好处...`

29 楼 yekui 2012-02-02

补充一句，
java使用该机制是为了达到最小化数据输入和输出的目的,这是一种优化措施,提高效率
其他的包装器:
Boolean： (全部缓存)
Byte：    (全部缓存)

Character (   <=127 缓存)
Short     (-128~127 缓存)
Long      (-128~127 缓存)

Float     (没有缓存)
Doulbe    (没有缓存)

28 楼 yekui 2012-02-02

自动拆箱就更为简单了。

废话不说看代码
举例：
int i = new Integer(2);
System.out.println(i);

编译后源码为
int i = (new Integer(2)).intValue();
         System.out.println(i);

/**
     * The value of the <code>Integer</code>.
     *
     * @serial
     */
    private final int value;

    /**
     * Constructs a newly allocated <code>Integer</code> object that
     * represents the specified <code>int</code> value.
     *
     * @param   value   the value to be represented by the
     * <code>Integer</code> object.
     */
    public Integer(int value) {
this.value = value;
    }

      /**
     * Returns the value of this <code>Integer</code> as an
     * <code>int</code>.
     */
    public int intValue() {
return value;
    }

相信看过源码后，不需要在解释了。

27 楼 taoge2121 2012-02-02

好文章……

26 楼 yekui 2012-02-02

解释:
第一个为什么是false呢？很明显Integer b = 100被编译成了Integer b = Integer.valueOf(100);
而
public static Integer valueOf(int i) {
        if(i >= -128 && i <= IntegerCache.high)
            return IntegerCache.cache[i + 128];
        else
            return new Integer(i);
    }
100在-128到127之间，这时编译器会从缓存取，继续看缓存代码

private static class IntegerCache {
        static final int high;
        static final Integer cache[];

        static {
            final int low = -128;

            // high value may be configured by property
            int h = 127;
            if (integerCacheHighPropValue != null) {
                // Use Long.decode here to avoid invoking methods that
                // require Integer's autoboxing cache to be initialized
                int i = Long.decode(integerCacheHighPropValue).intValue();
                i = Math.max(i, 127);
                // Maximum array size is Integer.MAX_VALUE
                h = Math.min(i, Integer.MAX_VALUE - -low);
            }
            high = h;

            cache = new Integer[(high - low) + 1];
            int j = low;
            for(int k = 0; k < cache.length; k++)
                cache[k] = new Integer(j++);
        }

        private IntegerCache() {}
    }

IntegerCache 第一次用时依然会被new出来，换句话说，

   Integer a = new Integer(100);
Integer b = Integer.valueOf(100);
System.out.println(a == b);

等同于

Integer a = new Integer(100);
Integer b = new Integer(100);
System.out.println(a == b);

故为false。

第二种情况，
//true
Integer c = 100;
Integer d = 100;
System.out.println(c == d);

编译后Integer c = Integer.valueOf(100);
Integer d = Integer.valueOf(100);
System.out.println(c == d);
实际上第等同于Integer c = new Integer(100)；
Integer d = Integer.valueOf(100); //取缓存，

故为true

第三种情况
Integer e = Integer.valueOf(156);
Integer f = Integer.valueOf(156);
System.out.println(e == f);

由于不在-128到127之间所以不会取缓存。
等同于

Integer e = new Integer(100);
Integer f = new Integer(100);
System.out.println(e == f);

故为false

第四种情况
Integer g = Integer.valueOf(100);
Integer h = Integer.valueOf(100);
System.out.println(g == h);

等同于

Integer g = new Integer(100);
Integer h = Integer.valueOf(100);//取缓存。

故为true

以上 ‘等同于’    解答适用于单独执行。若一次性执行。Integer g = Integer.valueOf(100);由于第一次已经执行了，后面的都会区缓存。

25 楼 yekui 2012-02-02

编译之后的结果:
//false
Integer a = new Integer(100);
Integer b = Integer.valueOf(100);
System.out.println(a == b);

//true
Integer c = Integer.valueOf(100);
Integer d = Integer.valueOf(100);
System.out.println(c == d);
//false

Integer e = Integer.valueOf(156);
Integer f = Integer.valueOf(156);
System.out.println(e == f);
//true

Integer g = Integer.valueOf(100);
Integer h = Integer.valueOf(100);
System.out.println(g == h);

24 楼 yekui 2012-02-02

看过代码之后更正一下，

//false
Integer a = new Integer(100);
Integer b = 100;
System.out.println(a == b);

//true
Integer c = 100;
Integer d = 100;
System.out.println(c == d);

//false
Integer e = 156;
Integer f = 156;
System.out.println(e == f);

//true
Integer g = Integer.valueOf(100);
Integer h = 100;
System.out.println(g == h);

23 楼 yekui 2012-02-02

燈小嗨写道

通过此方法实现
public int intValue() {return value;}

返回的是自动装箱之前的int类型的值

自动封箱，自动拆箱是编译器内部实现的，至于编译器的具体实现就要看java虚拟机编译原理了。

22 楼 volking 2012-02-02

我用的jdk是1.6.0_30
Integer valueOf代码有点变化，最大缓存已经不是固定127了，可以手动设定

21 楼 pingfan 2012-02-02

受教了，谢谢！

20 楼燈小嗨 2012-02-01

hanmiao 写道

做J2EE开发快三年了，直到今天才明白这里面的道理，通过这篇文章，我联想下Long，Float和Double是不是都有类似的情况，改天仔细钻研下。

基本类型的包装类除了Float和Double之外都是实现了缓冲机制，而且范围都是-128~127

19 楼 hanmiao 2012-02-01

做J2EE开发快三年了，直到今天才明白这里面的道理，通过这篇文章，我联想下Long，Float和Double是不是都有类似的情况，改天仔细钻研下。

发表评论

您还没有登录,请您登录后再发表评论

最近访客更多访客>>

博主相关

文章分类

社区版块

存档分类

最新评论