String、SpringBuilder和StringBuffer的区别，性能对比 | 底层原理 | 字节码

已于 2024-08-21 17:58:48 修改
阅读量840 收藏 30
点赞数 25
分类专栏： java 源码探究 文章标签： java jdk
于 2024-08-01 14:15:10 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_62467665/article/details/140846342
版权

目录

先看结果

测试结果

字节码层面

JDK8

性能差异原因

JDK的优化

JDK14、17 writeByString字节码：

减少对象创建的方式

示例

字节码分析

总结

众所周知，涉及大量的字符串拼接操作时，要用StringBuilder（或线程安全的StringBuffer）的append方法，取代String的拼接操作。正好有空，顺着好奇心，来一探究竟

先看结果

JVM内存分配：2048M

测试方法：从大小相同的list中，分别通过String和StringBuilder的方式，构建一个大的字符串，并写入文件。比较各自耗时。

写入文件：

public void writeToFile(String content) {
    String path = "D:\\test\\test.txt";
    Path filePath = Paths.get(path);
    Path parentDir = filePath.getParent();
    if (parentDir != null) {
        try {
            Files.createDirectories(parentDir);
        } catch (IOException e) {
            System.err.println("Failed to create directories: " + e.getMessage());
            return;
        }
    }
    try {
        Files.write(filePath, content.getBytes());
        System.out.println("Write to file success");
    } catch (IOException e) {
        System.err.println("Failed to write to file: " + e.getMessage());
    }
}

获取数据集合：

public List<TestBean> getList() {
    return getList(20000);
}
public List<TestBean> getList(int size) {
    List<TestBean> list = new ArrayList<>();
    for (int i = 0; i < size; i++) {
        TestBean testBean = new TestBean();
        testBean.setName("name" + i);
        testBean.setAge(i);
        testBean.setAddress("address" + i);
        list.add(testBean);
    }
    return list;
}

两种字符串拼接方法：

public void writeByStringBuilder() {
    List<TestBean> list = getList();
    StringBuilder sb = new StringBuilder();
    for (TestBean testBean : list) {
        sb.append(testBean.getName()).append(",")
                .append(testBean.getAge()).append(",")
                .append(testBean.getAddress()).append("\n");
    }
    writeToFile(sb.toString());
}
public void writeByString() {
    List<TestBean> list = getList();
    String s = "";
    for (TestBean testBean : list) {
        s += testBean.getName() + ","
                + testBean.getAge() + ","
                + testBean.getAddress() + "\n";
    }
    writeToFile(s);
}

测试结果

JDK版本String耗时StringBuilder耗时
85167ms51ms
143134ms49ms
171361ms51ms

从测试结果来看，无论是JDK8、14还是17，StringBuilder的方式都要远远快于String，但随着JDK的升级，String方式的性能也在不断提升。

字节码层面

JDK8

StringBuilder方法字节码：

 0 aload_0
 1 invokevirtual #8 <test/T10.getList : ()Ljava/util/List;>
 4 astore_1
 5 new #2 <java/lang/StringBuilder>
 8 dup
 9 invokespecial #3 <java/lang/StringBuilder.<init> : ()V>
12 astore_2
13 aload_1
14 invokeinterface #9 <java/util/List.iterator : ()Ljava/util/Iterator;> count 1
19 astore_3
20 aload_3
21 invokeinterface #10 <java/util/Iterator.hasNext : ()Z> count 1
26 ifeq 84 (+58)
29 aload_3
30 invokeinterface #11 <java/util/Iterator.next : ()Ljava/lang/Object;> count 1
35 checkcast #12 <test/TestBean>
38 astore 4
40 aload_2
41 aload 4
43 invokevirtual #13 <test/TestBean.getName : ()Ljava/lang/String;>
46 invokevirtual #7 <java/lang/StringBuilder.append : (Ljava/lang/String;)Ljava/lang/StringBuilder;>
49 ldc #14 <,>
51 invokevirtual #7 <java/lang/StringBuilder.append : (Ljava/lang/String;)Ljava/lang/StringBuilder;>
54 aload 4
56 invokevirtual #15 <test/TestBean.getAge : ()I>
59 invokevirtual #16 <java/lang/StringBuilder.append : (I)Ljava/lang/StringBuilder;>
62 ldc #14 <,>
64 invokevirtual #7 <java/lang/StringBuilder.append : (Ljava/lang/String;)Ljava/lang/StringBuilder;>
67 aload 4
69 invokevirtual #17 <test/TestBean.getAddress : ()Ljava/lang/String;>
72 invokevirtual #7 <java/lang/StringBuilder.append : (Ljava/lang/String;)Ljava/lang/StringBuilder;>
75 ldc #18 <>
77 invokevirtual #7 <java/lang/StringBuilder.append : (Ljava/lang/String;)Ljava/lang/StringBuilder;>
80 pop
81 goto 20 (-61)
84 aload_0
85 aload_2
86 invokevirtual #19 <java/lang/StringBuilder.toString : ()Ljava/lang/String;>
89 invokevirtual #20 <test/T10.writeToFile : (Ljava/lang/String;)V>
92 return

String方法：

 0 aload_0
 1 invokevirtual #8 <test/T10.getList : ()Ljava/util/List;>
 4 astore_1
 5 ldc #21
 7 astore_2
 8 aload_1
 9 invokeinterface #9 <java/util/List.iterator : ()Ljava/util/Iterator;> count 1
14 astore_3
15 aload_3
16 invokeinterface #10 <java/util/Iterator.hasNext : ()Z> count 1
21 ifeq 92 (+71)
24 aload_3
25 invokeinterface #11 <java/util/Iterator.next : ()Ljava/lang/Object;> count 1
30 checkcast #12 <test/TestBean>
33 astore 4
35 new #2 <java/lang/StringBuilder>
38 dup
39 invokespecial #3 <java/lang/StringBuilder.<init> : ()V>
42 aload_2
43 invokevirtual #7 <java/lang/StringBuilder.append : (Ljava/lang/String;)Ljava/lang/StringBuilder;>
46 aload 4
48 invokevirtual #13 <test/TestBean.getName : ()Ljava/lang/String;>
51 invokevirtual #7 <java/lang/StringBuilder.append : (Ljava/lang/String;)Ljava/lang/StringBuilder;>
54 ldc #14 <,>
56 invokevirtual #7 <java/lang/StringBuilder.append : (Ljava/lang/String;)Ljava/lang/StringBuilder;>
59 aload 4
61 invokevirtual #15 <test/TestBean.getAge : ()I>
64 invokevirtual #16 <java/lang/StringBuilder.append : (I)Ljava/lang/StringBuilder;>
67 ldc #14 <,>
69 invokevirtual #7 <java/lang/StringBuilder.append : (Ljava/lang/String;)Ljava/lang/StringBuilder;>
72 aload 4
74 invokevirtual #17 <test/TestBean.getAddress : ()Ljava/lang/String;>
77 invokevirtual #7 <java/lang/StringBuilder.append : (Ljava/lang/String;)Ljava/lang/StringBuilder;>
80 ldc #18 <>
82 invokevirtual #7 <java/lang/StringBuilder.append : (Ljava/lang/String;)Ljava/lang/StringBuilder;>
85 invokevirtual #19 <java/lang/StringBuilder.toString : ()Ljava/lang/String;>
88 astore_2
89 goto 15 (-74)
92 aload_0
93 aload_2
94 invokevirtual #20 <test/T10.writeToFile : (Ljava/lang/String;)V>
97 return

分析字节码文件可以发现：

StringBuilder的方式，创建了一个StringBuilder和一个String对象，中间操作都是在StringBuilder的基础上进行追加；

而String的方式，每次循环都会创建一个StringBuilder和一个String对象，测试用例中，循环20000次，即至少创建40000个对象；

性能差异原因

  1. 对象创建：第二个方法在每次迭代中都会创建一个新的 StringBuilder 对象，这会导致更多的对象分配和垃圾收集压力。第一个方法只创建一次 StringBuilder 对象，然后在其上连续进行追加操作。
  2. 字符串转换：第二个方法在每次迭代结束后都将 StringBuilder 转换成 String，这意味着每迭代一次就会创建一个新的 String 对象。第一个方法只在循环结束后将整个 StringBuilder 转换成 String，因此创建的 String 对象数量少得多。
  3. 缓存局部性：第一个方法中，所有的操作都在同一个 StringBuilder 对象上完成，这有助于提高数据缓存的局部性。第二个方法中，由于每次迭代都涉及到新对象的创建，这可能会导致缓存效率降低。
  4. JIT优化：尽管JIT编译器可能会尝试优化第二个方法中的字符串拼接操作，但由于每次迭代都需要创建新的 StringBuilder 和 String 对象，这增加了优化的难度。

通过观察字节码文件，发现使用 StringBuilder 的方式要优于直接使用 String 方式，创建更少的对象，缓解垃圾回收的压力。

JDK的优化

上述实验，得知StringBuilder要优于String，那么同样是使用String的方式，JDK17版本要比JDK8版本快了很多，接下来分析JDK17对于String拼接的优化

JDK14、17 writeByString字节码：

 0 aload_0
 1 invokevirtual #20 <test/T10.getList : ()Ljava/util/List;>
 4 astore_1
 5 ldc #69
 7 astore_2
 8 aload_1
 9 invokeinterface #26 <java/util/List.iterator : ()Ljava/util/Iterator;> count 1
14 astore_3
15 aload_3
16 invokeinterface #32 <java/util/Iterator.hasNext : ()Z> count 1
21 ifeq 60 (+39)
24 aload_3
25 invokeinterface #38 <java/util/Iterator.next : ()Ljava/lang/Object;> count 1
30 checkcast #42 <test/TestBean>
33 astore 4
35 aload_2
36 aload 4
38 invokevirtual #44 <test/TestBean.getName : ()Ljava/lang/String;>
41 aload 4
43 invokevirtual #50 <test/TestBean.getAge : ()I>
46 aload 4
48 invokevirtual #57 <test/TestBean.getAddress : ()Ljava/lang/String;>
51 invokedynamic #71 <makeConcatWithConstants, BootstrapMethods #0>
56 astore_2
57 goto 15 (-42)
60 aload_0
61 aload_2
62 invokevirtual #65 <test/T10.writeToFile : (Ljava/lang/String;)V>
65 return

1. JDK 14、17 版本的字节码并没有显式创建 StringBuilder 对象，而是通过 invokedynamic 调用 StringConcatFactory 的 makeConcatWithConstants 方法来直接创建 String 对象，减少了对象创建的数量

2. JDK 14、17 版本的字节码中，拼接操作通过 invokedynamic 调用 makeConcatWithConstants 方法完成，这种方法可以更高效地创建 String 对象，减少对象创建次数。

看来核心在于makeConcatWithConstants 方法，经过查阅资料以及询问AI：

在JDK 17中，StringConcatFactory 是一个内部类，它提供了一系列静态方法来创建字符串，这些方法旨在优化字符串拼接操作。其中最常用的是 makeConcatWithConstants 方法，它接受一系列参数并返回一个字符串。这个方法的设计是为了避免在字符串拼接过程中创建不必要的 StringBuilder 或 String 对象。

减少对象创建的方式

  1. 利用常量池：makeConcatWithConstants 方法会检查常量池中是否已经存在所需的字符串。如果存在，则直接使用已有的字符串，从而避免创建新的字符串对象。
  2. 延迟计算：当拼接操作涉及常量和变量时，makeConcatWithConstants 方法会尽量推迟变量的计算，直到真正需要它们的时候。这意味着如果某些变量未被更改，那么它们的计算结果可以直接从常量池中取出，而不是重新计算。
  3. 内联常量：如果拼接操作中涉及的常量是简单的字符串，makeConcatWithConstants 方法会尝试将这些常量内联到生成的代码中，从而避免创建额外的字符串对象。
  4. 使用字符串池：当生成的字符串是不可变的，并且在常量池中不存在时，makeConcatWithConstants 方法会将生成的字符串放入字符串池中。这意味着如果相同的字符串被多次生成，它们将共享同一个字符串池中的实例，而不是创建多个独立的字符串对象。

示例

我们来看一个具体的例子，假设有一个简单的字符串拼接操作：

String s = "Hello, " + name + "!";

这里的 name 是一个变量，而 "Hello, " 和 "!" 是常量字符串。在JDK 17中，这段代码会被编译器优化成调用 StringConcatFactory.makeConcatWithConstants 方法的指令。

字节码分析

在JDK 17中，上述代码的字节码看起来类似于这样：

invokedynamic #71 <makeConcatWithConstants, BootstrapMethods #0>

这里的 invokedynamic 指令指向 StringConcatFactory 的 makeConcatWithConstants 方法。这个方法会做以下事情：

  1. 检查常量池：它会检查常量池中是否已经有 "Hello, " 和 "!" 字符串。如果有，直接使用；如果没有，创建并将它们添加到常量池中。
  2. 生成字符串：它会根据 name 的值生成最终的字符串。如果 name 的值在多次拼接中保持不变，那么生成的字符串可以被重用。
  3. 字符串池化：最终生成的字符串会被放入字符串池中，这意味着如果同样的字符串被多次生成，它们将共享同一个实例。

总结

StringConcatFactory 的 makeConcatWithConstants 方法通过利用常量池、延迟计算、内联常量和字符串池化等技术，有效地减少了字符串拼接过程中不必要的对象创建，从而提高了性能。在JDK 17中，这种方法被广泛应用于字符串拼接操作，特别是在拼接操作包含常量字符串的情况下。

VsunGoK
关注
专栏目录
String、StringBuffer、StringBuilder的区别
weixin_41438466的博客
09-01 452
最近在准备面试，心中有好些疑问，搜索了一些关于String，StringBuffer，StringBuilder的东西，现在整理一下。 关于这三个类在字符串处理中的位置不言而喻，那么他们到底有什么优缺点，到底什么时候该用谁呢？下面我们从以下几点说明一下 三者在执行速度方面的比较：StringBuilder > StringBuffer > String String &l...
java中 String和StringBuffer的区别实例详解
08-30
Java中String和StringBuffer的区别实例详解 Java中String和StringBuffer都是用来存储字符串的对象，但是它们之间有着很大的区别。下面我们来详细介绍Java中String和StringBuffer的区别实例详解。 首先，String是不...
StringBuilder和SpringBuffer的区别
qq_40102411的博客
09-04 564
​ StringBuilder不是线程安全的，这就意味着多个线程对StringBuilder进行访问的时候，可能造成数据不一致或异常。因为它适用于单线程的情况，如果我们确保使用环境在单线程的情况可以使用Stringbuilder​ StringBuilder是处理可变的字符串，主要用于处理可变字符串。它每次对字符串执行插入、追加、删除和修改操作等操作不会创建新的字符串对象，因此它在处理大量字符串拼接和修改的时候有很高的性能。
Java--String、StringBuilder及StringBuffer区别及性能对比_java string 和 stringbuilder的性能对比
2401_84538063的博客
05-15 561
我们在看视频学习的时候，不能光动眼动脑不动手，比较科学的学习方法是在理解之后运用它们，这时候练手项目就很适合了，只是里面的项目比较多，水平也是参差不齐，大家可以挑自己能做的项目去练练。这是我花了几天的时间去把Python所有方向的技术点做的整理，形成各个领域的知识点汇总，它的用处就在于，你可以按照上面的知识点去找对应的学习资源，保证自己学得较为全面。最近我才对这些路线做了一下新的更新，知识体系更全面了。
String,StringBuffer,StringBuder
xianshuaii的博客
09-11 104
String: 被final修饰，不可修改，不可被继承(无子类)； 内部是final char value[]； 为String赋值就是为内部数组赋值，数组的长度=value[].length()； StringBuffer: extends AbstractStringBuilder implements java.io.Serializable, CharSequence 可修改，所有方法都被synchronized修饰，线程安全 StringBuder: extends AbstractS..
Spring、SpringBuffer、SpringBuilder
weixin_43907316的博客
04-01 5813
Spring Springbuffer SpringBuilder 1.Spring 是不可变字符串，每对Spring进行造作后都会产生一个新的字符串对象。 2.SpringBuffer 可变字符串，可以对字符串进行添加等操作，那么我们可变不可变都有了为什么还要有一个SpringBuilder，因为SpringBuffer是线程安全的，支持多并发，所以我们在多线程中使用SpringBuffer。 3.SpringBuilder 可变字符串，可以对字符串进行添加等操作，因为SpringBuilder是不安全的
String和StringBuilder
hello_world123456789的博客
05-03 841
Q: StringBuilder由来,有了String类为什么还要来一个StringBuilder?String是一个内容固定的字符串;StringBuilder是一个可变的字符串.String是的内容是存储于方法区的常量池,如果通过String类对字符串进行拼接操作,每次拼接都会构建一个新的String对象,既耗时又浪费空间,StringBuilder就可以解决这个问题.1.String常用AP...
java 中String和StringBuffer与StringBuilder的区别及使用方法
08-29
Java 中 String 和 StringBuffer 与 StringBuilder 的区别及使用方法 Java 中 String、StringBuffer 和 StringBuilder 是三个常用的字符串操作类，每个类都有其特点和使用场景。在开发过程中，正确选择合适的字符串...
Java 中 String，StringBuffer 和 StringBuilder 的区别及用法
08-31
"Java 中 String、StringBuffer 和 StringBuilder 的区别及用法" Java 中 String、StringBuffer 和 StringBuilder 是三个常用的字符串操作类，了解它们之间的区别对 Java 开发者来说非常重要。本文将详细介绍这三者...
浅析Java中String与StringBuffer拼接的区别
08-30
在Java编程语言中，String和StringBuffer类都用于处理字符串，但它们在处理字符串拼接时有着显著的区别。本文将详细解析这两个类在拼接字符串时的行为差异。 首先，我们来了解一下String类。String对象在Java中是不...
Java String 和StringBuffer的详解及区别
08-30
Java String 和StringBuffer 的详解及区别 Java String 和StringBuffer 是 Java 语言中两个基本的字符串类，它们都是用于存储和操作字符串的，但是它们之间有着很大的区别。 String 类 String 类表示内容不可改变...
String类和StringBuilder中常用知识和“+“号和append方法的区别
m0_73955675的博客
09-14 504
使用“+”运算符和使用StringBuilder类的append方法的区别在于它们对字符串的处理方式不同1。当你使用“+”运算符连接两个字符串时，它会调用String.Concat方法，每次都返回一个新的字符串对象1。而StringBuilder类的append方法则是将指定的字符串附加到原始字符串中，而不会返回新的字符串对象。 在效率方面，如果你只是连接两个小字符串，例如string s = "a" + "b";那么使用“+”运算符可能会更快1。然而，当你需要在循环中连接多个字符串时，使用StringBu
StringBuilder详解
量子小白的博客
01-07 1182
Java中String、StringBuffer、StringBuilder主要区别如下： String String类是不可变类，String对象一旦被创建，该对象中的字符序列不可改变，直至这个对象被销毁。 String a = "123"; a = "456"; // 打印出来的a为456 System.out.println(a) 当再次给a赋值时，生成一个新的实例对象，并且指向新的字符串，之前旧的实例对象仍存在，如果不再被引用则会被回收。 StringBuffer StringBu.
Spring
最新发布
LHR2575050945的博客
06-14 824
★4.IOC容器构建流程？★1.Spring和和的区别?①值可变性Spring中的值是final修饰的,不可变,当试图修改这个不可变值时等于创建一个新的对象。和则是可变的②Spring:值不可改(安全)自带锁(安全)值可改,无锁(不安全)③Spring:每次修改创建新对象(效率最慢)值可改但自带锁(效率高于Spring但低于SpringBuilder)值可改,无锁(效率最快)2.
String、StringBuffer、StringBuiler深入分析，看这一篇就够了_stringbuffer 和 stringbudile
2401_84281729的博客
04-28 848
首先看一下 String 类的类图，它实现了 CharSequence 接口，也就是说 String 是 CharSequence 类型.它的底层是被 final 修饰的字符数组，意味着一旦 String 被定义之后就不能够改变。在日常我们做字符串拼接时，其实是一个创建新对象和回收旧对象的过程。当定义字符串 str 时并将值“a”赋给它，当执行第二段代码时，即实现 str 拼接“b”时，此时 JAVA 虚拟机创建了一个新对象 str，将拼接成的字符串“ab”赋给新 str。
String, StringBuilder, StringBuffer深入解析
feigeswjtu的专栏
05-07 238
网上太多讲解String, StringBuilder, StringBuffer的区别了，但是大多数都浅尝而止，大多数只是提到String是字符串常量，因为它是常量，所以也是线程安全的，StringBuilder和StringBuffer的区别是后者是线程安全的，还有很多细节没有介绍到，尽自己之能补充一下。 先上一张类结构图。 可变性 总所周知，String类是一个不可变类也就是final 符...
StringBuilder与StringBUffer扩容机制
qq_52897007的博客
03-17 950
扩容的逻辑就是创建一个新的 char 数组，将现有容量扩大一倍再加上2，如果还是不够大则直接等于需要的容量大小。扩容完成之后，将原数组的内容复制到新数组，最后将指针指向新的 char 数组。
String、StringBuffer、StringBuider的作用和区别
qq_42716988的博客
12-02 567
1.了解一下StringBuffer和StringBudier是什么？ 字符串缓冲区 2.工作原理：与预先在内存中申请一块空间，以容纳字符序列，如果预留的空间不够用，则进行自动扩容，以容纳更多的字符序列。 3.String和Stringbuffer、StringBuider的区别？ String是不可变的字符序列，存储在字符串常量池中 StringBuffer底层是一个char数组，但是该char...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值