JVM学习笔记（字符串拼接原理）

最新推荐文章于 2022-11-06 14:00:39 发布
最新推荐文章于 2022-11-06 14:00:39 发布
阅读量452 收藏 2
点赞数 2
分类专栏： 笔记 文章标签： jvm 学习 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/luocong321/article/details/126343352
版权

字符串拼接原理

  • 1、常量与常量的拼接结果在常量池，原理是编译器优化（常量可以指final修饰的变量、字面量，例如final String s1 = “abc”，字面量指“abc”）
  • 2、常量池中不会存在相同内容的常量。
  • 3、只要其中有一个是变量，结果就在堆中。变量的拼接的原理是StringBuilder
  • 4、如果拼接的结果调用intern（）方法，则主动将常量池中还没有的字符串对象放入池中，并返回此对象地址。

intern（）

When the intern method is invoked, if the pool already contains a string equal to this String object as determined by the equals(Object) method, then the string from the pool is returned. Otherwise, this String object is added to the pool and a reference to this String object is returned.
It follows that for any two strings s and t, s.intern() == t.intern() is true if and only if s.equals(t) is true.

个人翻译：
当intern（）方法被调用的时候，如果字符串常量池中含有一个字符串，与调用这个方法的this的字符串对象相同，然后这个常量池中字符串将会被返回。否则，这个字符串对象将会被添加到常量池中并且返回这个字符串对象的引用。

总结String的intern（）的使用：

  • jdk1.6中，将这个字符串对象尝试放入串池
    • 如果池中有，返回已有对象地址
    • 如果没有，把对象复制一份，放入串池，并返回对象地址
  • jdk1.7及以后，将这个字符串对象尝试放入串池
    • 如果池中有，返回已有对象地址
    • 没有，则会把对象的引用地址复制一份，放入串池，并返回串池中的引用地址

案例1

public void test02(){
   	String s1 = "a";
    String s2 = "b";
    String s3 = "ab";

    String s4 = s1 + s2;
	/*
     如下s1 + s2的细节
     StringBuilder sb = new StringBuilder();
     sb.append("a");
     sb.append("b");
     sb.toSting(); --> 与等于new String("ab");
	 */
	 // 一个是对象的地址，一个是常量池中的地址，索引false
    System.out.println(s3 == s4);//false
    System.out.println(s3.equals(s4));//true
}

equals为true可以看String的方法equals（）底层代码

public boolean equals(Object anObject) {
     if (this == anObject) { // 判断地址是否相同，如果相同既同一个东西，返回true
         return true;
     }
     if (anObject instanceof String) {
         String anotherString = (String)anObject;
         int n = value.length;//获取this.value的长度
         if (n == anotherString.value.length) {//长度相同，继续比下去，不同则肯定不一样，返回false，下面的操作就是继续比较各个char字符相不相同，不同则返回false，全部相同则返回true
             char v1[] = value;
             char v2[] = anotherString.value;
             int i = 0;
             while (n-- != 0) {
                 if (v1[i] != v2[i])
                     return false;
                 i++;
             }
             return true;
         }
     }
     return false;
 }

观察jclasslib

局部变量表

在这里插入图片描述

指令
 0 ldc #5 <a>
 2 astore_1
 3 ldc #6 <b>
 5 astore_2
 6 ldc #7 <ab>
 8 astore_3
 9 new #8 <java/lang/StringBuilder>
12 dup
13 invokespecial #9 <java/lang/StringBuilder.<init> : ()V>
16 aload_1
17 invokevirtual #10 <java/lang/StringBuilder.append : (Ljava/lang/String;)Ljava/lang/StringBuilder;>
20 aload_2
21 invokevirtual #10 <java/lang/StringBuilder.append : (Ljava/lang/String;)Ljava/lang/StringBuilder;>
24 invokevirtual #11 <java/lang/StringBuilder.toString : ()Ljava/lang/String;>
27 astore 4
29 getstatic #12 <java/lang/System.out : Ljava/io/PrintStream;>
32 aload_3
33 aload 4
35 if_acmpne 42 (+7)
38 iconst_1
39 goto 43 (+4)
42 iconst_0
43 invokevirtual #13 <java/io/PrintStream.println : (Z)V>
46 getstatic #12 <java/lang/System.out : Ljava/io/PrintStream;>
49 aload_3
50 aload 4
52 invokevirtual #14 <java/lang/String.equals : (Ljava/lang/Object;)Z>
55 invokevirtual #13 <java/io/PrintStream.println : (Z)V>
58 return
序号指令说明
0ldc #5
2astore_1将a赋值给本地变量表为1的索引，既s1
3ldc #6
5astore_2将b赋值给本地变量表为2的索引，既s2
6ldc #7
8astore_3将ab赋值给本地变量表为3的索引，既s3
9new #8 <java/lang/StringBuilder>创建StringBuilder（）对象
12dup
13invokespecial #9 <java/lang/StringBuilder. : ()V>初始化StringBuilder（）
16aload_1取出索引为1的内容，既取出s1中的内容“a”
17invokevirtual #10 <java/lang/StringBuilder.append : (Ljava/lang/String;)Ljava/lang/StringBuilder;>将取出的内容加入到StringBuilder（）对象中，前几步类似于StringBuilder sb = new StringBuilder（）；sb.append（“a”）；
20aload_2取出索引为2的内容，既取出s2中的内容“b”
21invokevirtual #10 <java/lang/StringBuilder.append : (Ljava/lang/String;)Ljava/lang/StringBuilder;>
24invokevirtual #11 <java/lang/StringBuilder.toString : ()Ljava/lang/String;>执行sb.toString（）；
27astore 4将StringBuilder的toString赋值给本地变量表为4的索引，既s4
29getstatic #12 <java/lang/System.out : Ljava/io/PrintStream;>
32aload_3
33aload 4
35if_acmpne 42 (+7)
38iconst_1
39goto 43 (+4)
42iconst_0
43invokevirtual #13 <java/io/PrintStream.println : (Z)V>
46getstatic #12 <java/lang/System.out : Ljava/io/PrintStream;>
49aload_3
50aload 4
52invokevirtual #14 <java/lang/String.equals : (Ljava/lang/Object;)Z>
55invokevirtual #13 <java/io/PrintStream.println : (Z)V>
58return

案例2

public void test01(){
    final String s1 = "a";//常量引用
     final String s2 = "b";
     String s3 = "ab";

     String s4 = s1 + s2;
     
     System.out.println(s3 == s4);//true
 }

观察jclasslib

局部变量表

在这里插入图片描述

指令
 0 ldc #5 <a>
 2 astore_1
 3 ldc #6 <b>
 5 astore_2
 6 ldc #7 <ab>
 8 astore_3
 9 ldc #7 <ab>
11 astore 4 
13 getstatic #8 <java/lang/System.out : Ljava/io/PrintStream;>
16 aload_3
17 aload 4
19 if_acmpne 26 (+7)
22 iconst_1
23 goto 27 (+4)
26 iconst_0
27 invokevirtual #9 <java/io/PrintStream.println : (Z)V>
30 getstatic #8 <java/lang/System.out : Ljava/io/PrintStream;>
33 aload_3
34 aload 4
36 invokevirtual #10 <java/lang/String.equals : (Ljava/lang/Object;)Z>
39 invokevirtual #9 <java/io/PrintStream.println : (Z)V>
42 return
序号指令说明
0ldc #5
2astore_1
3ldc #6
5astore_2
6ldc #7
8astore_3
9ldc #7
11astore 4观察发现s4的赋值方式是直接将ab在常量池的地址返回给s4
13getstatic #8 <java/lang/System.out : Ljava/io/PrintStream;>
16aload_3
17aload 4
19if_acmpne 26 (+7)
22iconst_1
23goto 27 (+4)
26iconst_0
27invokevirtual #9 <java/io/PrintStream.println : (Z)V>
30getstatic #8 <java/lang/System.out : Ljava/io/PrintStream;>
33aload_3
34aload 4
36invokevirtual #10 <java/lang/String.equals : (Ljava/lang/Object;)Z>
39invokevirtual #9 <java/io/PrintStream.println : (Z)V>
42return

练习

public void test01(){
	String s1 = "javaEEHotSpot";
	
	// 第一种情况
	String s2 = "javaEE";
	String s3 = s2 + "HotSpot";
	System.out.print(s1 == s3);
	
	// 第二种情况
	final String s4 = "javaEE";
	String s5 = s4 + "Hotspot";
	System.out.print(s1 == s5);
}


答案是false true

问题

问题1：new String(“ab”)会创建几个对象

public static void main(String[] args) {
    String ab = new String("ab");
}

观察字节码指令（jclasslib）

 0 new #2 <java/lang/String>
 3 dup
 4 ldc #3 <ab>
 6 invokespecial #4 <java/lang/String.<init> : (Ljava/lang/String;)V>
 9 astore_1
10 return

会创建两个对象，一个是new关键字在堆空间创建，另一个是在常量池中有"ab"

问题2：new String(“a”) + new String(“b”)会创建几个对象

    public static void main(String[] args) {
        String ab = new String("a") + new String("b");
    }

观察字节码指令（jclasslib）

 0 new #2 <java/lang/StringBuilder>
 3 dup
 4 invokespecial #3 <java/lang/StringBuilder.<init> : ()V>
 7 new #4 <java/lang/String>
10 dup
11 ldc #5 <a>
13 invokespecial #6 <java/lang/String.<init> : (Ljava/lang/String;)V>
16 invokevirtual #7 <java/lang/StringBuilder.append : (Ljava/lang/String;)Ljava/lang/StringBuilder;>
19 new #4 <java/lang/String>
22 dup
23 ldc #8 <b>
25 invokespecial #6 <java/lang/String.<init> : (Ljava/lang/String;)V>
28 invokevirtual #7 <java/lang/StringBuilder.append : (Ljava/lang/String;)Ljava/lang/StringBuilder;>
31 invokevirtual #9 <java/lang/StringBuilder.toString : ()Ljava/lang/String;>
34 astore_1
35 return
  • 对象1：new StringBuilder()
  • 对象2：new String(“a”);
  • 对象3：常量池中的a
  • 对象4：new String(“b”)
  • 对象5：常量池中的b

问题1和问题2对比

在问题2中并没有在常量池中创建”ab“对象，（toString不会在常量池中生成）

小结练习

public static void main(String[] args) {
        /**
         * 执行顺序
         * new String（）,用s接收保存地址,常量池中存储"1",初始化String，将"1"放入，并"1"在常量池中返回地址
         * 判断常量池中是否含有"1",没有则创建并返回引用，有则直接返回引用
         * 将常量池中"1"的引用返回，用说s2接收保存地址
         * 一个是保存字符串常量池的地址，一个是保存堆空间中对象的地址
         */
        String s = new String("1");
        s.intern();//调用此方法前，常量池中已经含有1，调用方法时不会再去常量池中创建
        String s2 = "1";
        System.out.println(s == s2);//jdk6:false jdk7:false
        /**
         * s3记录的引用为new String（"11"）的引用，这个不会在常量池中创建"11"
         * jdk6中，常量池发现没有"11"，则创建"11"对象（这个时候常量池在永久代）。在jdk7中，常量池发现没有"11"，则创建"11"对象，但是保存的是上面的new String("11")的地址引用（jdk7中的常量池是放在堆内存空间，因此不会再去创建"11"）
         * s4保存的是常量池中”11“的地址，jdk返回的是常量池中的”11“，jdk7返回的是堆内存中的new String("11")的地址
         */
        String s3 = new String("1") + new String("1");
        s3.intern();
        String s4 = "11";
        System.out.println(s3 == s4);//jdk6:false jdk7/8:true
    }

结论

  • equals比较的是this的字符串值和要比较的值的字符串相不相同
  • 而等等号比较的是对象的地址一不一样
  • 如果拼接符号左右都是常量或者常量引用（final修饰的变量），则仍然使用编译器优化，既非new StringBuilder()的方式
  • 针对于final修饰类、方法、基本数据类型、引用数据类型的量的结构时，能使用上final的时候建议使用上。
老哥不老
关注
  • 2
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
[Java学习笔记doc](必看经典)
08-11
5. **字符串处理**：String类的特性，如何进行字符串拼接、查找、替换等操作。 6. **输入/输出流**：I/O流的概念，包括FileInputStream、FileOutputStream、BufferedReader、BufferedWriter等类的使用。 7. **多...
java学习笔记整理
11-11
使用`StringBuilder`或`StringBuffer`类可以方便地进行字符串拼接。 ```java StringBuilder sb = new StringBuilder(); for (int i = 1; i ; i++) { sb.append(i); } System.out.println(sb.toString()); ``` ###...
StringTable详解
Syntactic Sugar
10-22 673
一、存储结构 jdk8及以前String底层使用char[]，一个char是两个字节，jdk9开始改用byte[]加上编码标记节约空间。 jdk9官网提供的String修改说明：http://openjdk.java.net/jeps/254 修改动机： 二、不可变性 1、当对字符串重新赋值时，需要重写指定内存区域赋值 2、当对现有字符串进行连接操作时，也需要重新指定内存区...
JVM - 【字符串常量池】字符串拼接操作
⚡
09-15 718
字符串拼接操作 String a = "hello" + "world"; final String a = "hello"; String b = a + "world"; String a = "hello"; String b = a + "world"; 一：方式一分析及验证 二：方式二分析及验证 三：方式三分析及验证 含有变量的字符串在拼接时，根据JDK版本不同，底层实现也相应不同； 四：面试题 注意：JDK9及之后现不做分析（~） package xyz.xx.
JVM-字符串底层实现原理
黑马程序员官方博客
10-29 328
1.什么字符串会进入字符串常量池 1. 直接写的字面量 2. 字面量的拼接结果（注意：如果字符串拼接中有变量则结果不会进入字符串常量池） 3. 调用String的intern方法可以将String存入字符串常量池 2. 字面量的拼接原理 有如下列展示代码： 在ideal中查看编译的class文件： 总结： 以上面两个文件我们可以看出，这种字符串的拼接在编译期间就已经优化了，直接就合并为一个字符串；并且这个字符串存放在字符串常量池 3. 字符串和变量拼接原理 java源码：
从 JVM 角度看字符串拼接
实践求真知
07-18 140
一 字符串拼接操作 常量与常量的拼接结果在常量池，原理是编译期优化 常量池中不会存在相同内容的常量 只要其中有一个是变量，结果就在堆中，变量拼接的原理是 StringBuilder。 如果拼接的结果调用 intern() 方法，则主动将常量池中还没有的字符串对象放入池中，并返回此对象地址 二 实战 1代码 @Test public void test1() { String s1 = "a" + "b" + "c"; // 编译期优化：等同于"abc".
【jvm】字符串拼接的底层原理
yqs的博客
01-29 325
String s1 = "a";//"a"会被加载到常量池里，s1引用常量池里的"a" String s2 = "b";//"b"会被加载到常量池里，s2引用常量池里的"b" String s3 = s1 + s2;//底层拼接时相当于执行了new StringBuilder().append("a").append("b").toString() 而toString()里面则调用了return new String(xxx)，我们知道new关键字创建的对象都在堆里面，所以s3指向了堆里面的一个String
study-java-notes:Java学习笔记
04-08
5. **字符串与IO流**: Java中的String类是不可变的，笔记会解释其原理和操作，包括拼接、查找、替换等。IO流则涉及文件读写、网络通信等，包括字节流和字符流的区别，以及缓冲区的概念。 6. **多线程**: Java提供...
个人笔记.zip
08-04
8. **字符串处理**：讲解String类的常用方法，如concatenation（拼接）、substring（子串）、indexOf（查找子串位置）等。 9. **集合框架**：涵盖ArrayList、LinkedList、HashSet、HashMap等常见集合类的使用，以及...
java字符串 的拼接---从JVM开始带你看底层源码---面试必要知识
Gavin
07-12 140
直接上代码— 字符串的拼接 public class Test { public static void main(String args[]) { //字符串的拼接 String str0 = "abc"; String str1 = "abc"; String str2="a"+"b"; String str3=new String ("abc"); String b=str2+"c"; System.o
从jvm字节码看String+字符串拼接为什么效率低
翻身咸鱼的博客
11-19 376
在我们的常识里面，用String的+符号的时候，效率会很低，建议使用String builder，那是为什么呢？这次我们通过一个小demo的jvm字节码来分析，首先是demo： public class TestStringAdd { public static void f1() { String src = &amp;quot;&amp;quot;; for(int i=0;i&amp;amp;lt;10...
Java中String产生对象的问题
qq_48953464的博客
11-06 712
String产生对象的问题
Java字符串常量池
weixin_43868436的博客
10-23 266
字符串常量池
字符串拼接的5种方法 +（底层实现原理）
热门推荐
qq_41065910的博客
03-19 3万+
字符串拼接： 字符串，是Java中最常用的一个数据类型了。本文，也是对于Java中字符串相关知识的一个补充，主要来介绍一下字符串拼接相关的知识。本文基于jdk1.8 我们都知道，String是Java中一个不可变的类，所以他一旦被实例化就无法被修改。 不可变类的实例一旦创建，其成员变量的值就不能被修改。这样设计有很多好处，比如可以缓存hashcode、使用更加便利以及更加安全等。 字符串不变...
java String字符串拼接原理
qq_45800640的博客
09-14 7438
java中的字符串的拼接可以分为下面三种情况： 1. 字符串常量与字符串常量的拼接 String s1 = "a"+"b"+"c"; 2. 字符串常量与变量的拼接 String s1 = "a"; String s2 = s1+"b"; 3. 变量与变量的拼接 String s1 = "a"; String s2 = "b"; String s4 = s1+s2; （1）常量与常量的拼接原理：         
java四种字符串拼接方式性能分析
腾先生的技术工坊
01-14 3万+
前几天写一个防重复提交的组件的时候，有一个操作是需要将各个字段的字符串拼接成一个requestKey。看了别人的代码，我发现，中间件这种东西，每天都要处理几百几千万的请求，但是里面很多字符串拼接的时候还是很原始的“+”号拼接，如果将所有的字符串拼接操作都换成更高效的实现方式，服务器的性能会不会要好一点，于是我简单的做了个实验对比一下我们常见的字符串拼接方法的效率。常见的四种字符串拼接方法分别是
java中是否对“+”，“=”，“+=”重载
做你所想，想你所做。
01-10 6157
概述从语言一级来看，java不支持运算符重载，这点是肯定的。String类的”=”,”+”,”+=”，看似运算符重载，实际不是，只是在java编译器里做了一点手脚。 java编译器对String的运算符做了特殊处理。比如： String s = “s1”; s += “s2”; 编译器转换成了： String s = “s1”; s = (new StringBuilder()).app
深入java String JVM对String对象的连接优化 一（源码分析）
yabay2208的博客
05-10 2175
上一篇文章我们总结了final关键字需要注意的地方和JVM对final关键字的优化。我看《阿里巴巴Java开发手册》，发现（四.OOP规则）第17条对String有进行说明。这一篇文章分析一下String、StringBuffer和StringBuilder的用法和源码。原创不易，转载请注明出处：http://blog.csdn.net/yabay2208 阿里巴巴的文档规范 String使用以及源
宋红康jvm学习笔记 逃逸分析
最新发布
05-19
逃逸分析是JVM在运行时对对象的分析，用于确定对象的作用域。如果对象只在方法内部使用，那么它就不会逃逸出该方法，否则就会逃逸。逃逸分析可以优化程序的性能，因为当对象不逃逸时，JVM可以将它们放在线程栈上分配...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

老哥不老

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值