JVM-String比较-字节码分析（转载）

最新推荐文章于 2024-05-30 11:09:09 发布

weixin_30487201

最新推荐文章于 2024-05-30 11:09:09 发布

阅读量49

点赞数

CC 4.0 BY-SA版权

原文链接：http://www.cnblogs.com/fanxiumin/p/6034204.html

public class a {
    public static void main(String[] args)throws Exception{
        
    }
    public static void aa(){
        String s1="a";//内存在方法区的常量池
        String s2="b";//内存在方法区的常量池
        String s12 = "ab";//内存在方法区的常量池
        String s3 = s1 + s2;//s3的内存所在？？？
        p(s3==s12);//false
    }
    public static void bb(){
        String s1="a"+"b";//s1的内存所在？？？
        String s2 = "ab";//内存在方法区的常量池
        p(s1==s2);//true
    }public static void p(Object obj){
        System.out.println(obj);
    }
}

这是我们经常碰到的烦人的String比较问题，要得到答案，就要弄清楚aa()方法中的s3的内存在哪里？，和bb()方法中的s1的内存在哪里？

不多说，贴上a.class文件反编译的字节码指令：

首先是 aa()方法：

public static void aa();
    flags: ACC_PUBLIC, ACC_STATIC
    Code:
      stack=2, locals=4, args_size=0                                                  共4个本地变量空间
         0: ldc           #3                  // String a　　                          将字符串"a"从常量池中推送至栈顶
         2: astore_0                                                                  将栈顶引用类型（即字符串"a"）存入第一个本地变量
         3: ldc           #4                  // String b                              将字符串"b"从常量池推送至栈顶
         5: astore_1                                                                  将栈顶引用类型（即字符串"b"）存入第二个本地变量
         6: ldc           #5                  // String ab                             将字符串"ab"从常量池推送至栈顶
         8: astore_2                                                                  将栈顶引用类型（即字符串"ab"）存入第三个本地变量
         9: new           #6                  // class java/lang/StringBuilder         创建StringBuilder对象sb，并将引用值压入栈顶
        12: dup                                                                       复制栈顶数值，并将复制值压入栈顶
        13: invokespecial #7                  // Method java/lang/StringBuilder.       调用对象的初始化方法
"<init>":()V
        16: aload_0                                                                   将第一个本地变量（即字符串"a"）推送至栈顶
        17: invokevirtual #8                  // Method java/lang/StringBuilder.       调用实例方法sb.append("a");
append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
        20: aload_1                                                                   将第二个本地变量（即字符串"b"）推送至栈顶
        21: invokevirtual #8                  // Method java/lang/StringBuilder.       调用实例方法sb.append("b");
append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
        24: invokevirtual #9                  // Method java/lang/StringBuilder.       调用实例方法sb.toString(),并将结果【Java堆地址】放在栈顶
toString:()Ljava/lang/String;
        27: astore_3                                                                   将栈顶引用类型（即堆地址）存入第四个本地变量                                                            
        28: aload_3                                                                    将第四个本地变量（即堆地址）推送至栈顶
        29: aload_2                                                                    将第三个本地变量（即字符串"ab"）推送至栈顶
        30: if_acmpne     37                                                           比较栈顶两引用数值，结果不同跳转（当然不同啦）
        33: iconst_1
        34: goto          38
        37: iconst_0                                                                   将int类型 0 压入栈顶
        38: invokestatic  #10                 // Method java/lang/Boolean.valueO       调用静态方法Boolean.valueOf();实现基本数据类型->包装类型自动转换
f:(Z)Ljava/lang/Boolean;
        41: invokestatic  #11                 // Method p:(Ljava/lang/Object;)V        调用静态方法p(false);//输出false
        44: return                                                                     从当前方法返回void

针对其中的一些解释：（下面的数字是字节码偏移量）

24 为何在sb.toString()我说的是【堆地址】，大家看源码就知道了。

//这是StringBuilder的源码，返回的是堆上的字符串地址
public String toString() {
    return new String(value, 0, count);
}

所以在aa()方法中，s3的内存其实在Java堆上，s12在方法区的常量池上，所以两者不相等。

37 boolean到底分配几个字节，在这里大家可以看到。

如果为true，编译器翻译的字节码是iconst_1，意思将int类型1存入栈顶，所以单个引用boolean值时，分配4个字节，和int相同。（数组boolean没测试，不清楚）

如果为false，编译器翻译的字节码是iconst_0，意思将int类型0存入栈顶。

38 在这里我们还能看到自动类型转换的身影，这里是基本数据类型boolean->包装类Boolean的自动类型转换，实际调用的就是Boolean.valueOf()静态方法，这是因为下面的p()方法里面需要的是Object引用类型，所以进行了自动类型转换。

然后是 bb()方法：

public static void bb();
    flags: ACC_PUBLIC, ACC_STATIC
    Code:
      stack=2, locals=2, args_size=0                                                   两个本地变量空间
         0: ldc           #5                  // String ab                             将字符串"ab"从常量池中推送至栈顶
         2: astore_0                                                                   将栈顶引用类型（字符串"ab"）存入第一个本地变量
         3: ldc           #5                  // String ab                             将字符串"ab"从常量池中推送至栈顶
         5: astore_1                                                                   将栈顶引用类型（字符串"ab"）存入第一个本地变量
         6: aload_0                                                                    将第一个本地变量（"ab"）推送至栈顶
         7: aload_1                                                                    将第二个本地变量（"ab"）推送至栈顶
         8: if_acmpne     15                                                           比较栈顶两引用类型数值，结果不同跳转（这里当然相同啦）
        11: iconst_1                                                                   将int类型 1 推送至栈顶
        12: goto          16                                                           无条件跳转到16字节码偏移量
        15: iconst_0
        16: invokestatic  #10                 // Method java/lang/Boolean.valueO       调用静态方法Boolean.valueOf();并将返回的Boolean类型的true压入栈顶
f:(Z)Ljava/lang/Boolean;                                            
        19: invokestatic  #11                 // Method p:(Ljava/lang/Object;)V        调用静态方法p(true);输出true
        22: return                                                                     从当前方法返回void

转载于:https://www.cnblogs.com/fanxiumin/p/6034204.html