JAVA String a = “abc“ 中发生了什么

最新推荐文章于 2022-08-21 09:52:55 发布
最新推荐文章于 2022-08-21 09:52:55 发布
阅读量2.5k 收藏 30
点赞数 5
分类专栏： java 文章标签： java jvm
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Bubblegz/article/details/121505568
版权

JAVA String a = "abc" 中发生了什么

和上次int a = 1 后续

测试代码

javac TestCode.java

 public class TestCode {
     public static void main(String[] args) {
         // 此处写aaaa是便于看字节码
         String aaaa = "bbbb";
         aaaa = "cccc";
     }
 }

反编译

javap -v -p -l TestCode(l是小写的L)

注解：javap是jdk自带的反解析工具。作用是根据class字节码文件，反解析出当前类对应的code区(汇编指令)、本地变量表、异常表和代码行偏移量映射表、常量池等等信息。

 Classfile xxxxx/com/code/baseCode/TestCode.class
   Last modified 2021-11-22; size 475 bytes
   MD5 checksum 0a108c035194f620555926cf7d113c8b
   Compiled from "TestCode.java"
 public class com.code.baseCode.TestCode
   minor version: 0
   major version: 52
   flags: ACC_PUBLIC, ACC_SUPER
 Constant pool:
    #1 = Methodref          #5.#21         // java/lang/Object."<init>":()V
    #2 = String             #22            // bbbb
    #3 = String             #23            // cccc
    #4 = Class              #24            // com/code/baseCode/TestCode
    #5 = Class              #25            // java/lang/Object
    #6 = Utf8               <init>
    #7 = Utf8               ()V
    #8 = Utf8               Code
    #9 = Utf8               LineNumberTable
   #10 = Utf8               LocalVariableTable
   #11 = Utf8               this
   #12 = Utf8               Lcom/code/baseCode/TestCode;
   #13 = Utf8               main
   #14 = Utf8               ([Ljava/lang/String;)V
   #15 = Utf8               args
   #16 = Utf8               [Ljava/lang/String;
   #17 = Utf8               aaaa
   #18 = Utf8               Ljava/lang/String;
   #19 = Utf8               SourceFile
   #20 = Utf8               TestCode.java
   #21 = NameAndType        #6:#7          // "<init>":()V
   #22 = Utf8               bbbb
   #23 = Utf8               cccc
   #24 = Utf8               com/code/baseCode/TestCode
   #25 = Utf8               java/lang/Object
 {
   public com.code.baseCode.TestCode();
     descriptor: ()V
     flags: ACC_PUBLIC
     Code:
       stack=1, locals=1, args_size=1
          0: aload_0
          1: invokespecial #1                  // Method java/lang/Object."<init>":()V
          4: return
       LineNumberTable:
         line 8: 0
       LocalVariableTable:
         Start  Length  Slot  Name   Signature
             0       5     0  this   Lcom/code/baseCode/TestCode;
 ​
   public static void main(java.lang.String[]);
     descriptor: ([Ljava/lang/String;)V
     flags: ACC_PUBLIC, ACC_STATIC
     Code:
       stack=1, locals=2, args_size=1
          0: ldc           #2                  // String bbbb
          2: astore_1
          3: ldc           #3                  // String cccc
          5: astore_1
          6: return
       LineNumberTable:
         line 11: 0
         line 12: 3
         line 55: 6
       LocalVariableTable:
         Start  Length  Slot  Name   Signature
             0       7     0  args   [Ljava/lang/String;
             3       4     1  aaaa   Ljava/lang/String;
 }
 SourceFile: "TestCode.java"

反编译后，会发现aaaa存在于Constant pool（常量池）和LocalVariableTable（本地变量表）中

同时发现和int a = 1的区别在于字符串“bbbb”和“cccc”也会在常量池中

JVM中常量池的划分，请看上篇文章

图片解释

java1.8的内存布局

image-20211122224530763

在编译后内存情况

image-20211123212545822

运行时发生情况

如何查看Java bytecode指令？

https://en.wikipedia.org/wiki/List_of_Java_bytecode_instructions

Jvm系列3—字节码指令 - Gityuan博客 | 袁辉辉的技术博客

其中java byte code为

 0: ldc           #2                  // String bbbb
 2: astore_1
 3: ldc           #3                  // String cccc
 5: astore_1

ldc：push a constant #index from a constant pool (String, int, float, Class, java.lang.invoke.MethodType, java.lang.invoke.MethodHandle, or a dynamically-computed constant) onto the stack

意思就是：int、float或String型等常量从常量池推送至栈顶

astore_1：store a reference into local variable 1

意思就是将：一个引用放入到局部变量1中(也就是aaaa中)

ldc #2

image-20211123213852082

astore_1

image-20211123214132207

ldc #3

image-20211123214251552

astore_1

image-20211123214346740

图片解释：用new String()创建

将代码改成如下：

 public class TestCode {
     public static void main(String[] args) {
         String aaaa = new String("bbbb");
         aaaa = new String("cccc");
     }
 }

则会发现常量池多了一些东西，并且执行指令多了。

其中执行指令如下

 0: new           #2                  // class java/lang/String
 3: dup
 4: ldc           #3                  // String bbbb
 6: invokespecial #4                  // Method java/lang/String."<init>":(Ljava/lang/String;)V
 9: astore_1
 10: new           #2                  // class java/lang/String
 13: dup
 14: ldc           #5                  // String cccc
 16: invokespecial #4                  // Method java/lang/String."<init>":(Ljava/lang/String;)V
 19: astore_1

new：创建类实例

dup：复制数值，并压入栈顶

ldc：从常量池推送至栈顶

invokespecial：调用特殊实例方法（包括实例初始化方法、父类方法）

astore_1：一个引用放入到局部变量1中(也就是aaaa中)

常量池如下

 Constant pool:
    #1 = Methodref          #7.#23         // java/lang/Object."<init>":()V
    #2 = Class              #24            // java/lang/String
    #3 = String             #25            // bbbb
    #4 = Methodref          #2.#26         // java/lang/String."<init>":(Ljava/lang/String;)V
    #5 = String             #27            // cccc
    #6 = Class              #28            // com/code/baseCode/TestCode
    #7 = Class              #29            // java/lang/Object
    #8 = Utf8               <init>
    #9 = Utf8               ()V
   #10 = Utf8               Code
   #11 = Utf8               LineNumberTable
   #12 = Utf8               LocalVariableTable
   #13 = Utf8               this
   #14 = Utf8               Lcom/code/baseCode/TestCode;
   #15 = Utf8               main
   #16 = Utf8               ([Ljava/lang/String;)V
   #17 = Utf8               args
   #18 = Utf8               [Ljava/lang/String;
   #19 = Utf8               aaaa
   #20 = Utf8               Ljava/lang/String;
   #21 = Utf8               SourceFile
   #22 = Utf8               TestCode.java
   #23 = NameAndType        #8:#9          // "<init>":()V
   #24 = Utf8               java/lang/String
   #25 = Utf8               bbbb
   #26 = NameAndType        #8:#30         // "<init>":(Ljava/lang/String;)V
   #27 = Utf8               cccc
   #28 = Utf8               com/code/baseCode/TestCode
   #29 = Utf8               java/lang/Object
   #30 = Utf8               (Ljava/lang/String;)V

new #2

image-20211123223808106

dup

image-20211123223942761

ldc #3

image-20211123224047739

invokespecial #4

image-20211123224141928

astore_1

image-20211123224232319

后续的操作一样，因此会出现

 String a = new String("bbbb");
 String b = new String("bbbb");
 System.out.println(a == b); // false

面试题

做下面的题是，需要知道几个知识点

1.编辑时，编译器会对确切的值进行优化：

比如String a = "a" + "b"; -> 比如String a = "ab";

final String a = "a"; String b = "a" + a; -> String b = "aa";

2.字符串变量相加会创建StringBuilder调用append方法，然后StringBuilder转换成new String

3.intern：Java查找常量池中是否有相同Unicode的字符串常量，如果有，则返回其的引用，如果没有，则在常量池中增加一个Unicode等于str的字符串并返回它的引用。

 String s11 = "a";
 String s22 = "bc";
 ​
 String s1 = "abc";
 String s2 = "a" + "bc";
 String s3 = new String("a") + "bc";
 String s4 = new String("a") + new String("bc");
 String s5 = new String("abc");
 String s6 = s11 + s22;
 ​
 System.out.println(s1 == s2);
 System.out.println(s1 == s3);
 System.out.println(s1 == s4);
 System.out.println(s1 == s5);
 System.out.println(s1 == s6);
 System.out.println(s3 == s4);
 System.out.println(s4 == s5);
 ​
 System.out.println(s1 == s5.intern());
 System.out.println(s1 == s6.intern());
 ​
 System.out.println(s1.equals(s5));
 System.out.println(s1.equals(s6));

答案解释：[java面试题]判断字符串相等，看这一篇就够了 - 知乎

结尾

之前出了int类型的情况，上述是String类型的情况，后续出包装类型的情况

Bubblegz
关注
  • 5
    点赞
  • 踩
  • 30
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
String a = “abc“ 和 new String(“abc“)的区别
qq_52978553的博客
07-25 1606
JVM会使用常量池来管理字符串直接量。在执行这句话时，JVM会先检查常量池中是否已经存有"abc"，若没有则将"abc"存入常量池，否则就复用常量池中已有的"abc"，将其引用赋值给变量a。所以System.out.println(a==b);结果位true。在执行这句话时，JVM会先使用常量池来管理字符串直接量，即将"abc"存入常量池。然后再创建一个新的String对象，这个对象会被保存在堆内存中。并且，堆中对象的数据会指向常量池中的直接量。有两种情况。......
深入了解String类
hyly_zhard的博客
12-22 183
让学习成为一种习惯。 &nbsp;&nbsp;&nbsp;&nbsp;之前对于String类型一直有很多疑问。比如说：String类为什么不可变？String str=new String(“abc”)创建了几个对象？String str=new String(“abc”)和String str=“abc”;的区别？String类中的intern()是否会创建对象？等。今天我就来介绍一下Stri...
【Java】String a = “abc“ 和 String a = new String(“abc“) 创建字符串的区别
m0_64210833的博客
08-21 1097
Java中的所有的对象都存储在堆内存当中，空间大，但是读取速度比较慢。 字符串常量池就是比如是String a = "abc"，String a = "ac"这些都是存储在字符串常量池中。在字符串常量池中，不管String a = "abc"，String b = "abc"...这些在字符串常量池中只会存储一个，然后a，b都指向字符串常量池中的同一个字符串常量"abc"【指向的是地址】。字符串常量池空间不大，读取速度比较快。
JAVA中String的内存详解
weixin_44049427的博客
08-12 537
JAVA中String的内存详解
有如下4个变量： String a="abc"; String b="abc"; String c=new String("abc"); String d=new String("abc"); 为什么
u011368399的专栏
07-11 3847
有如下4个变量： String a="abc"; String b="abc"; String c=new String("abc"); String d=new String("abc"); 为什么a==b结果是true，而c==d的结果却是false。   在学习《effective java》的时候遇到这么一条：避免创建重复的对象。想起一个很基础的问题：Stri
Java常用类（String类）的简单用法
01-19
Java 程序中的所有字符串字面值（如 "abc" ）都作为此类的实例实现 　常用方法： 　public char charAt(int index) 　返回指定索引处的 char 值。索引范围为从 0 到 length() - 1。 　序列的个 char 值位于索引 ...
EDA/PLD中的Java常用类（String类）的简单用法
11-09
Java 程序中的所有字符串字面值（如 "abc" ）都作为此类的实例实现 　常用方法： 　public char charAt(int index) 　返回指定索引处的 char 值。索引范围为从 0 到 length() - 1。 　序列的第一个 char 值位于...
Java String类的使用详解
12-20
Java 程序中的所有字符串字面值(如 “abc” )都作为此类的实例实现。 2.特点 字符串是常量，它们的值在创建之后不能更改。 字符串缓冲区支持可变的字符串。因为String 对象是不可变的，所以可以共享。 字符串效果上...
Ruby语言中的String深入理解
01-21
比如 代码如下: str1=”abc” str2=”abc” 在java中，对于字面量的字符串，jvm内部维持一张表，因此如果在java中，str1和str2是同一个String对象。而在Ruby中， str1和str2是完全不同的对象。同样，在java中对于...
跟我学Java-day13-String和StringBuilder.pdf
03-07
String s3 = "abc"; String s4 = "abc"; //比较字符串对象地址是否相同 System.out.println(s1 == s2); System.out.println(s1 == s3); System.out.println(s3 == s4); System.out.println("--------"); //...
Java基础笔记（10）— String a= “abc” String b = “abc” String c = new String(“abc”) String d = “ab” + “c”相比较
weixin_40689446的博客
09-19 4483
Java基础笔记（10）— String a= “abc” String b = “abc” String c = new String(“abc”) String d = “ab” + “c” .他们之间用 == 比较的结果 String a= “abc” String b = “abc” String c = new String(“abc”) String d = “ab” + “c” .他...
浅谈jvm内存中，String a=“abc“；与String b=new String(“abc“)；的区别
qq_25971673的博客
04-01 951
在聊这个问题之前，不妨先谈谈java的内存结构，栈空间、本地方法区、程序计数器、堆、方法区。其中栈空间是私有的，堆空间是共有的，栈空间存放着一些对对象的使用，和一些基本类型，但是空间是极小的一部分，堆空间是jvm内存最大的空间，存放着数组、实体、和一些new出来的对象。了解了这一些知识，我们可以往下分析了。 1、 String a ="abc" 首先在栈空间里面创建变量名a，然后在常量池里面寻找，是否存在abc的常量，如果存在，则将a指向abc的地址，如果不存在，就将在堆空间开辟一个String对象，对象
String a= “abc” String b = "abc" String c = new String("abc") String d = "ab" + "c" .他们之间用 == 比较的结果
热门推荐
请叫我大师兄
08-19 1万+
做个string的测试咯。如下： String a= “abc” String b = "abc" String c = new String("abc") String d = "ab" + "c" .他们之间用 == 比较的结果 Java中字符串对象创建有两种形式。 一种为字面量形式，如String str = "droid";， 另一种就是使用new这种标准的构造对象的方法，如String str = new String("droid"); 这两种方式我们在代码编写时都经常使用，尤其是字面量的方式
String a="abc"与String b=new String（"abc"）的区别
yin_xing_ye的博客
07-23 5333
先说几个概念 1、常量池 指的是在编译期确定，并被保存在已编译的字节码文件中的一些数据，它包括类、方法、接口等中的常量，存放字符串常量和基本类型常量（public static final）。 2、栈（stack） 主要保存基本数据类型（或者叫内置类型）（char、byte、short、int、long、float、double、boolean）和对象的引用，数据可以共享，速度仅次于寄存器（re...
String a = "abc";和String b = new String("abc")；
猪猪神功屁
11-01 7470
String a = "abc"; 首先会在栈中创建一个对String类对象的引用变量a，然后去查找字符串常量池中是否有"abc"。如果有，会把a指向这个对象的地址。如果字符串常量池中没有"abc"，则在栈中创建三个char型的值'a','b','c'，然后在堆中创建一个String对象object，它的值是刚才在栈中创建的三个char型值组成的数组{'a','b','c'}，接着这个String...
String a="abc"和String b=new String("abc")的区别及String相关常用操作
qq_24558789的博客
07-27 6092
在讨论两者区别之前我们先明确.equals()和==的区别   String a = "abc";   String b = new String("abc");   String c = "abc";   String d = new String("abc");   System.out.println(a==b);   System.out.println(a==c);
关于Java中String a ="abc"和String a=new String("abc")的区别？
xie1147641046的博客
11-01 2644
String a =&amp;quot;abc&amp;quot;是指如果在字符串常量池中没有这个字符串， 则在字符串常量池中新建一个 abc 的字符串，如果常量池中 有这个字符串，则只需要把这个字符串的地址赋给 a这个引 用即可,注意，字符串常量池在方法区中。 ...
String a = "abc" 与String b = new String("abc")的区别
sunjiaminaini的专栏
08-08 2901
假如我们， String a = “abc”; “abc”存在字符串常量池中 String b = “abc”;if(a == b){} //这里 == 判断的是a b 是否指向”abc”这个字符内存池，在堆区里面的一块相同地址！——-假如我们这样做——- String a = “abc”; String b = “ab” + “c”;if(a == b){} //这里也是相等的，因为只有
String a = "abc";和String a = new String("abc");的区别
最新发布
04-27
当使用 String a = "abc" 时，Java 会先检查字符串池中是否已经存在 "abc" 这个字符串，如果存在，直接将 a 指向字符串池中的 "abc"；如果不存在，会在字符串池中新建一个 "abc" 字符串，然后将 a 指向这个新建的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值