Java | 谈谈StringBuilder的使用和细节

关注

原创最新推荐文章于 2026-02-14 13:23:53 发布 408 阅读 AI 写同款· GEO 优化 ›

String、StringBuffer和StringBuilder的详解 1.值的可变性String内部的value值是final修饰的，所以，它是不可变类；因此，每次修改String的值，都会产生一个新的对象。StringBuffer和StringBuilder是可变类，它们在字符串变更的时候，不会产生新的对象。2.线程安全String是不可变类，所以它是线程安全的。StringBuilder不是线程安全的。StringBuffer是线程安全的，因为它的每个操作方法都加了synchronized同步关键字。单线程情况下，建议使用StringBuilder。阅读详情

前言

众所周知，在Java中String对象是不可变的。不可变性会导致一系列的效率问题，例如下面几行代码，为了生成最终的结果，I 首先会和love 连接生成一个I loveString对象，然后再和java.连接，再次生成一个新的String对象（这里先不讨论编译器会做优化）。

    String str = "I ";
    str += "love ";
    str += "java.";
    System.out.println(str); 
复制代码

可以发现，为了生成最终的结果，会产生一系列的需要垃圾回收的中间对象，当操作的次数增加，就会导致很严重的性能问题，而StringBuilder便是专门为解决这一问题而出现的，StringBuilder可以将我们的每次操作都只在原对象上进行操作，因此便解决了由于生成中间String对象而导致的性能问题。

基本使用

StringBuilder的基本使用方法如下，我们每次需要创建一个StringBuilder对象，当需要进行字符串拼接操作时，只需要使用append方法即可。

    StringBuilder sb = new StringBuilder();
    sb.append("I ");
    sb.append("love ");
    sb.append("java.");
    System.out.println(sb);
复制代码

然而其实以上两种操作，经过编译器的优化，在性能上一样的，我们可以通过javap指令来进行验证，前言中的代码我放在StringBuilderStudy这个类中，然后通过一下两步进行反编译来进行验证：

    javac StringBuilderStudy.java
    javap -c StringBuilderStudy
复制代码

然后得到以下字节码结果，部分无关内容省去：

public static void main(java.lang.String[]);
    Code:
       0: ldc           #2                  // String I
       2: astore_1
       3: new           #3                  // class java/lang/StringBuilder
       6: dup
       7: invokespecial #4                  // Method java/lang/StringBuilder."<init>":()V
      10: aload_1
      11: invokevirtual #5                  // Method java/lang/StringBuilder.append:/StringBuilder; 
      14: ldc           #6                  // String love
      16: invokevirtual #5                  // Method java/lang/StringBuilder.append:StringBuilder;
      19: invokevirtual #7                  // Method java/lang/StringBuilder.toString:()Ljava/lang/String;
      22: astore_1
      23: new           #3                  // class java/lang/StringBuilder
      26: dup
      27: invokespecial #4                  // Method java/lang/StringBuilder."<init>":()V
      30: aload_1
      31: invokevirtual #5                  // Method java/lang/StringBuilder.append:StringBuilder;
      34: ldc           #8                  // String java.
      36: invokevirtual #5                  // Method java/lang/StringBuilder.append:StringBuilder;
      39: invokevirtual #7                  // Method java/lang/StringBuilder.toString:()Ljava/lang/String;
      42: astore_1
      43: getstatic     #9                  // Field java/lang/System.out:Ljava/io/PrintStream;
      46: aload_1
      47: invokevirtual #10                 // Method java/io/PrintStream.println:(Ljava/lang/String;)V
      50: return
复制代码

仔细查看很容易发现，尽管我们使用的是普通的字符串拼接操作，但编译器会自动帮我们改成StringBuilder进行操作，最终调用toString方法，然后进行输出。然而，尽管编译器会帮我们做底层优化，我们在某些情况下仍然需要自己显示使用，最常见的一个情况就是在for循环当中，例如以下代码：

    String[] strArr = {"I ", "love ", "java."};
    String res = "";
    for (String str : strArr) {
        res += str;
    }
    System.out.println(res);
复制代码

我们首先先进行反编译查看生成的字节码（有部分省略）：

public static void main(java.lang.String[]);
    Code:
       0: iconst_3
       1: anewarray     #2                  // class java/lang/String
       4: dup
       5: iconst_0
       6: ldc           #3                  // String I
       8: aastore
       9: dup
      10: iconst_1
      11: ldc           #4                  // String love
      13: aastore
      14: dup
      15: iconst_2
      16: ldc           #5                  // String  java.
      18: aastore
      19: astore_1
      20: ldc           #6                  // String
      32: iload         5
      34: iload         4
      36: if_icmpge     71
      39: aload_3
      40: iload         5
      42: aaload
      43: astore        6
      45: new           #7                  // class java/lang/StringBuilder
      48: dup
      49: invokespecial #8                  // Method java/lang/StringBuilder."<init>":()V
      52: aload_2
      53: invokevirtual #9                  // Method java/lang/StringBuilder.append:StringBuilder;
      56: aload         6
      58: invokevirtual #9                  // Method java/lang/StringBuilder.append:/StringBuilder;
      61: invokevirtual #10                 // Method java/lang/StringBuilder.toString:()Ljava/lang/String;
      64: astore_2
      65: iinc          5, 1
      68: goto          32
      71: getstatic     #11                 // Field java/lang/System.out:Ljava/io/PrintStream;
      74: aload_2
      75: invokevirtual #12                 // Method java/io/PrintStream.println:(Ljava/lang/String;)V
      78: return
复制代码

稍微读一下，可以通过68行的goto 32知道，32行便是循环的入口点，而很容易发现在循环内部，在45行处有一个new操作，说明在每次循环中为了进行字符串的拼接操作都会生成一个新的StringBuilder对象，最后再调用toString方法。这也导致了每次循环都会产生一个中间对象需要垃圾回收，影响了性能，那如果我们自己使用呢，又会是怎样？先自己写出如下代码：

    String[] strArr = {"I ", "love ", "java."};
    StringBuilder sb = new StringBuilder();
    for (String str : strArr) {
        sb.append(str);
    }
    System.out.println(sb);
复制代码

然后查看反编译生成的字节码（有删减）：

public static void main(java.lang.String[]);
    Code:
       0: iconst_3
       1: anewarray     #2                  // class java/lang/String
       4: dup
       5: iconst_0
       6: ldc           #3                  // String I
       8: aastore
       9: dup
      10: iconst_1
      11: ldc           #4                  // String love
      13: aastore
      14: dup
      15: iconst_2
      16: ldc           #5                  // String  java.
      18: aastore
      19: astore_1
      20: new           #6                  // class java/lang/StringBuilder
      23: dup
      24: invokespecial #7                  // Method java/lang/StringBuilder."<init>":()V
      37: iload         5
      39: iload         4
      41: if_icmpge     63
      44: aload_3
      45: iload         5
      47: aaload
      48: astore        6
      50: aload_2
      51: aload         6
      53: invokevirtual #8                  // Method java/lang/StringBuilder.append:/StringBuilder;
      56: pop
      57: iinc          5, 1
      60: goto          37
      63: getstatic     #9                  // Field java/lang/System.out:Ljava/io/PrintStream;
      66: aload_2
      67: invokevirtual #10                 // Method java/io/PrintStream.println:(Ljava/lang/Object;)V
      70: return
复制代码

仔细查看便可以发现，在这里的循环入口为37行，而循环内部也没有了生成中间StringBuilder对象的代码，只有循环外20行处我们自己进行的一次new操作。因此，尽管编译器会帮助我们做底层的优化，但是当在循环中等一些地方使用字符串拼接操作时，还是需要自己亲自使用StringBuilder对象进行操作，而对于return "I " + "love " + "java.";这种情况则可以依靠编译器的优化，而不需要自己费力去操作了。

使用细节

我们有时可能会为了方便这样使用StringBuilder进行拼接：append("(" + name + ")")，然而这其实是一个不好的习惯，编译器并没办法识别这种情况，即自己将括号内的拼接操作转换为多次append操作，而是会生成一个中间StringBuilder对象执行拼接操作，然后再使用toString方法，因此正确的使用的方法应该是append("(").append(name).append(")")，这里不展示反编译后的字节码了，大家感兴趣可以自己试一下。

收录于