String、StringBuffer、StringBuiler看这一篇就够了

已于 2023-03-03 12:56:09 修改
阅读量1.9k 收藏 39
点赞数 7
文章标签： java
于 2020-07-28 23:43:28 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_33479841/article/details/107642831
版权

1.概述

string、stringbuffer、stringbuiler一直是java面试中较为热点的问题，一般作为一个开场问题。那么这三者之间有什么区别，如何根据场景来选择使用，本文将基于三者的源码、性能、以及面试常问点来进行分析。

2.String、StringBuffer、StringBuiler底层源码

2.1 String类
首先看一下String类的类图，它实现了CharSequence接口，也就是说String是CharSequence类型，它的底层是被final修饰的字符数组，意味着一旦String被定义之后就不能够改变。在日常我们做字符串拼接时，其实是一个创建新对象和回收旧对象的过程。以下面代码为例：

String str = "a";
	str += "b";

当定义字符串str时并将值“a”赋给它，当执行第二段代码时，即实现str拼接“b”时，此时JAVA虚拟机创建了一个新对象str，将拼接成的字符串“ab”赋给新str，GC同时会回收旧的str对象，所以str并没有被更改，而是直接生成的新对象。若大量字符串拼接，利用上述+=操作将严重影响性能。
在这里插入图片描述

public final class String
    implements java.io.Serializable, Comparable<String>, CharSequence {
    /** The value is used for character storage. */
    private final char value[];
    //构造函数
     public String(String original) {
        this.value = original.value;
        this.hash = original.hash;
    }
    //构造函数
    public String(char value[]) {
        this.value = Arrays.copyOf(value, value.length);
    }
    //返回一个新的char[]
    public char[] toCharArray() {
        // Cannot use Arrays.copyOf because of class initialization order issues
        char result[] = new char[value.length];
        System.arraycopy(value, 0, result, 0, value.length);
        return result;
    }
 }

在上述String类的源码声明中，String类由final对象修饰，被final修饰的类不能被继承、方法不能被重写、属性不能被修改。String是一个典型的Immutable(不可变)类，所谓的不可变类是指这个类的实例一旦创建完成后，就不能改变其成员变量值。与不可变类相对的则是可变类（mutable），可变类创建实例后可以改变其成员变量值，开发中创建的大部分类都属于可变类。跟据上述String源码，分析String保证不可变的原因主要如下：

String类被final修饰，不可被继承； string内部所有成员都设置为私有变量，外部无法访问；
value被final修饰，所以变量的引用不可变，且不提供对外访问value的接口；
在获取value时，不是直接返回value的引用，而是直接通过System.arraycopy()方法来返回一个新的char数组；
char[]为引用类型仍可以通过引用修改实例对象，为此String(char value[])构造函数内部使用的copyOf而不是直接将value[]复制给内部变量。

接下来讲一下这样设计的优势：

1.支持hash映射和缓存，提升效率： 由于字符串不可变性，在其创建时就会缓存其hashCode值，不需要每次重新计算其hash值。这也是HashMap中键值一般会使用字符串的原因，对于字符串的处理速度要快于其它的键对象。

2.保证了线程安全： 由于其不变性，同一个字符串实例可以被多个线程共享。如果是可变对象，很容易被修改而造成不可预估的后果。

3.不可变对象提升了字符串常量池(String Pool)的效率和安全性： 字符串常量池是java堆内存中一个特殊的存储区域，当创建一个String对象，假如此字符串值已经存在于常量池中，则不会创建一个新的对象，而是引用已经存在的对象。在java中内存分为堆内存和栈内存，堆内存存放的是对象，栈内存存储对象的引用，对象是不可变动的，因此拷贝对象时只需要复制它的地址。复制地址(通常一个指针的大小)需要很小的内存，效率也很好。二对于其他引用同一个对象的其他变量也不会造成影响。

2.2 StringBuffer类
在这里插入图片描述
由上述类图可知，StringBuffer类继承自类AbstractStringBuilder，使用 value 和 count 分别表示存储的字符数组和字符串使用的计数，AbstractStringBuilder类封装了大量基础方法，包括数组扩容机制、拼接方法等。首先看一下数组初始容量：

/**
 * Constructs a string buffer with no characters in it and an
 * initial capacity of 16 characters.
 */
public StringBuffer() {
    super(16);
}
public StringBuffer(int capacity) {
    super(capacity);
}

StringBuffer初始化时默认长度大小为16，StringBuffer是线程安全的，可以查看其append方法（如下所示），由synchronized修饰，因此是线程安全的。

	
 @Override
    public synchronized StringBuffer append(Object obj) {
        toStringCache = null;
        super.append(String.valueOf(obj));
        return this;
    }

    @Override
    public synchronized StringBuffer append(String str) {
        toStringCache = null;
        super.append(str);
        return this;
    }

    public synchronized StringBuffer append(StringBuffer sb) {
        toStringCache = null;
        super.append(sb);
        return this;
    }

    @Override
    synchronized StringBuffer append(AbstractStringBuilder asb) {
        toStringCache = null;
        super.append(asb);
        return this;
    }

    @Override
    public synchronized StringBuffer append(CharSequence s) {
        toStringCache = null;
        super.append(s);
        return this;
    }

接下来看一下其扩容部分的源码，具体如下：

private void ensureCapacityInternal(int minimumCapacity) {
        // overflow-conscious code
        if (minimumCapacity - value.length > 0) {
            value = Arrays.copyOf(value,
                    newCapacity(minimumCapacity));
        }
    }
    
    private int newCapacity(int minCapacity) {
        // overflow-conscious code
        int newCapacity = (value.length << 1) + 2;
        if (newCapacity - minCapacity < 0) {
            newCapacity = minCapacity;
        }
        return (newCapacity <= 0 || MAX_ARRAY_SIZE - newCapacity < 0)
            ? hugeCapacity(minCapacity)
            : newCapacity;
    }

StringBuffer扩容方法继承了类AbstractStringBuilder，上述ensureCapacityInternal方法就是扩容方法，minimumCapacity 就是字符长度 + 要拼接的字符串长度，如果拼接后的字符串要比当前字符长度大的话，会进行数据的复制，真正扩容的方法是在 newCapacity 中，扩容后的字符串长度会是原字符串长度增加一倍 + 2，如果扩容后的长度还比拼接后的字符串长度小的话，那就直接扩容到它需要的长度 newCapacity = minCapacity，然后再进行数组的拷贝。因此，如果我们拼接的字符串长度是可以预计的，那么最好指定合适的capacity，避免多次扩容的开销。

2.3 StringBuiler类
在这里插入图片描述
由上述StringBuilder类图可知，StringBuilder与StringBuffer类似，均继承于AbstractStringBuilder，所以其初始空间和扩容机制均相同。区别在于它是被final修饰的，因此是不可被继承的；而且其append方法不是由synchronized修饰，因此不是线程安全的。同时它实现了Serializable 序列化接口，表示对象可以被序列化；还实现了CharSequence 字符序列接口，提供了几个对字符序列进行只读访问的方法，例如 length()、charAt()、subSequence()、toString() 方法等。

public final class StringBuilder
    extends AbstractStringBuilder
    implements java.io.Serializable, CharSequence {
    
	public StringBuilder() {
        super(16);
    }
	public StringBuilder(int capacity) {
        super(capacity);
    }
}

abstract class AbstractStringBuilder implements Appendable, CharSequence {
   
    char[] value;

    int count;

    AbstractStringBuilder() {
    }
    
    AbstractStringBuilder(int capacity) {
        value = new char[capacity];
    }
 }

3.String、StringBuffer、StringBuilder性能对比

3.1 测试代码如下：

public class Test {

    private static final Integer time = 100000;

    public static void main(String[] args) {
        testString();
        testStringBuffer();
        testStringBuilder();
    }

    public static void testString() {
        String str = "";
        long start = System.currentTimeMillis();
        for (int i = 0;i < time; i++) {
            str += "a";
        }
        long end = System.currentTimeMillis();
        System.out.println("string:"+(end - start));
    }

    public static void testStringBuffer() {
        StringBuffer stringBuffer = new StringBuffer();
        long start = System.currentTimeMillis();
        for (int i = 0;i < time; i++) {
            stringBuffer.append("a");
        }
        long end = System.currentTimeMillis();
        System.out.println("stringBuffer:"+(end - start));
    }

    public static void testStringBuilder() {
        StringBuilder stringBuilder = new StringBuilder();
        long start = System.currentTimeMillis();
        for (int i = 0;i < time; i++) {
            stringBuilder.append("a");
        }
        long end = System.currentTimeMillis();
        System.out.println("stringBuilder:"+(end - start));
    }
}

3.2 测试结果如下：
上述代码分别测试了在拼接次数为1000次、10000次、100000次和1000000次下，String、StringBuffer、StringBuilder的耗时，具体结果如下表所示：

单位：msStringStringBufferStringBuilder
次数：100030.10.1
次数：1000072.30.70.7
次数：1000003534.24.43.8
次数：1000000130400.413.211.2

结论：由上表可知，String在进行字符串拼接时，随着拼接次数的增多，耗时也呈指数式增加。相比较而言，StringBuffer和StringBuilder性能相对接近。
注意：上述测试环境基于win10操作系统，jdk 1.8，处理器：Intel® Core™ i7-9700 CPU @ 3.00GHz 3.00 GHz，RAM：16.0 GB。

4.深入理解String案例

1.判断下面程序输出结果

 		String str1 = "helloworld";
        String str2 = "hello" + "world";
        System.out.println(str1 == str2); //true

通过反汇编上述代码，得到结果如下：

public class com.eckey.lab.test.StringTest {
  public com.eckey.lab.test.StringTest();
    Code:
       0: aload_0
       1: invokespecial #1                  // Method java/lang/Object."<init>":()V
       4: return

  public static void main(java.lang.String[]);
    Code:
       0: ldc           #2                  // String helloworld(str1)
       2: astore_1
       3: ldc           #2                  // String helloworld(str2)
       5: astore_2
       6: getstatic     #3                  // Field java/lang/System.out:Ljava/io/PrintStream;
       9: aload_1
      10: aload_2
      11: if_acmpne     18
      14: iconst_1
      15: goto          19
      18: iconst_0
      19: invokevirtual #4                  // Method java/io/PrintStream.println:(Z)V
      22: return
}

通过反汇编代码可以看出，编译器对 String str2 = “hello” + “world"做了优化，str2被直接创建成了"helloworld”，而str1在创建时字符串helloworld被写入了常量池。str2在创建时会先从常量池中获取对应字符串，而常量池已经包含了该字符，因此结果为true。

2.判断下面程序输出结果

 		String str1 = "helloworld";
        String str2 = "hello";
        String str3 = str2 + "world";
        System.out.println(str1 == str3); //false

反汇编上述代码得到结果：

public class com.eckey.lab.test.StringTest {
  public com.eckey.lab.test.StringTest();
    Code:
       0: aload_0
       1: invokespecial #1                  // Method java/lang/Object."<init>":()V
       4: return

  public static void main(java.lang.String[]);
    Code:
       0: ldc           #2                  // String helloworld
       2: astore_1
       3: ldc           #3                  // String hello
       5: astore_2
       6: new           #4                  // class java/lang/StringBuilder
       9: dup
      10: invokespecial #5                  // Method java/lang/StringBuilder."<init>":()V
      13: aload_2
      14: invokevirtual #6                  // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
      17: ldc           #7                  // String world
      19: invokevirtual #6                  // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
      22: invokevirtual #8                  // Method java/lang/StringBuilder.toString:()Ljava/lang/String;
      25: astore_3
      26: getstatic     #9                  // Field java/lang/System.out:Ljava/io/PrintStream;
      29: aload_1
      30: aload_3
      31: if_acmpne     38
      34: iconst_1
      35: goto          39
      38: iconst_0
      39: invokevirtual #10                 // Method java/io/PrintStream.println:(Z)V
      42: return
}

通过上述反汇编代码可知，当执行String str3 = str2 + “world”;操作时，首先生成了一个StringBuilder，其次将其进行了初始化操作，然后调用了append方法，拼接了字符串“world”，最后调用了toString方法，将拼接后的字符串转成了一个新的String，这个过程生成了新的对象，因此str1和str3肯定不是一个对象，结果自然为false。

3.判断下面程序输出结果

 		String str1 = "helloworld";
        final String str2 = "hello";
        String str3 = str2 + "world";
        System.out.println(str1 == str3); //true

这个结果为true是不是感觉很意外？那我们直接上反汇编代码，一探究竟便知：

public class com.eckey.lab.test.StringTest {
  public com.eckey.lab.test.StringTest();
    Code:
       0: aload_0
       1: invokespecial #1                  // Method java/lang/Object."<init>":()V
       4: return

  public static void main(java.lang.String[]);
    Code:
       0: ldc           #2                  // String helloworld
       2: astore_1
       3: ldc           #3                  // String hello
       5: astore_2
       6: ldc           #2                  // String helloworld
       8: astore_3
       9: getstatic     #4                  // Field java/lang/System.out:Ljava/io/PrintStream;
      12: aload_1
      13: aload_3
      14: if_acmpne     21
      17: iconst_1
      18: goto          22
      21: iconst_0
      22: invokevirtual #5                  // Method java/io/PrintStream.println:(Z)V
      25: return
}

这个案例与上述2中案例唯一的区别在于变量str2声明前加了一个关键字final，导致在编译时，编译器直接将str3创建成了"helloworld"，是不是有很多问号？由于被final修饰，在编译阶段会存入调用类的常量池中，因此str2一开始就存在于常量池中，String str3 = str2 + "world"实际就变成了String str3 = “hello” + “world”，因为String str1 = “helloworld”;这条语句已经将字符串"helloworld"写入常量池，str3首先会获取常量池中的值，所以结果为true。

4.判断下面程序输出结果

public static void main(String[] args) {
        String str1 = "helloworld";
        final String str2 = returnStr();
        String str3 = str2 + "world";
        System.out.println(str1 == str3); //false
    }
    
    public static String returnStr() {
        return "hello";
    }

反编译代码如下：

public class com.eckey.lab.test.StringTest {
  public com.eckey.lab.test.StringTest();
    Code:
       0: aload_0
       1: invokespecial #1                  // Method java/lang/Object."<init>":()V
       4: return

  public static void main(java.lang.String[]);
    Code:
       0: ldc           #2                  // String helloworld
       2: astore_1
       3: invokestatic  #3                  // Method returnStr:()Ljava/lang/String;
       6: astore_2
       7: new           #4                  // class java/lang/StringBuilder
      10: dup
      11: invokespecial #5                  // Method java/lang/StringBuilder."<init>":()V
      14: aload_2
      15: invokevirtual #6                  // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
      18: ldc           #7                  // String world
      20: invokevirtual #6                  // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
      23: invokevirtual #8                  // Method java/lang/StringBuilder.toString:()Ljava/lang/String;
      26: astore_3
      27: getstatic     #9                  // Field java/lang/System.out:Ljava/io/PrintStream;
      30: aload_1
      31: aload_3
      32: if_acmpne     39
      35: iconst_1
      36: goto          40
      39: iconst_0
      40: invokevirtual #10                 // Method java/io/PrintStream.println:(Z)V
      43: return

  public static java.lang.String returnStr();
    Code:
       0: ldc           #11                 // String hello
       2: areturn
}

通过上述反汇编代码可知，当执行String str3 = str2 + “world”;操作时，首先生成了一个StringBuilder，其次将其进行了初始化操作，然后调用了append方法，拼接了字符串“world”，最后调用了toString方法，将拼接后的字符串转成了一个新的String，因此结果为false。

5.判断下面程序输出结果

  		String str1 = "hello";
        String str2 = new String("hello");
        System.out.println(str1 == str2); //false

在创建这个str2对象时因为使用了 new 关键字，所以肯定会在堆中创建一个对象。然后会在常量池中看有没有 hello这个字符串；如果没有此时还会在常量池中创建一个；如果有则不创建。所以可能是创建一个或者两个对象，但是一定存在两个对象，因此结果为false。

6.判断下面程序输出结果

  		String str1 = "hello";
        String str2 = new String("hello");
        System.out.println(str1 == str2.intern()); //true

String.intern()是一个Native方法,它的作用是:如果字符常量池中已经包含一个等于此String对象的字符串,则返回常量池中字符串的引用,否则,将新的字符串放入常量池,并返回新字符串的引用。在上述代码中，在创建str2对象时使用了new，因此肯定会在堆中创建一个对象。由于str1在创建时将字符串hello写入了常量池，因此str2会返回其引用，因此当str2调用intern()方法时，与str1指向的是常量池中同一个地址，则结果为true。

5.小结

1.String适用于字符串拼接较少、字符串变化较小的场合。
2.StringBuffer适用于字符串连接操作比较频繁，且要求线程安全（多线程环境下操作）。
3.StringBuilder适用于字符串连接操作比较频繁，且是单线程的情况。

6.参考文章

1.https://juejin.im/entry/59082ab5a0bb9f006510683a
2.https://juejin.im/entry/580467cfda2f60004fea4673
3.《深入理解JAVA虚拟机》

程可爱
关注
Java--String、StringBuilder及StringBuffer区别及性能对比
JustinQin
09-03 1万+
【学习背景】 主要是想通过OpenJDK提供的JMH工具测试下String、StringBuilder及StringBuffer字符串拼接的效率如何~ 关于JMH的介绍及具体使用，我的这篇博文中有介绍： Java–☀️面试官：LinkedList真的比ArrayList添加元素快？❤️‍本文通过Open JDK JMH带你揭开真相《⭐建议收藏⭐》 当然，除了主要验证三者的字符串拼接效率之外，还会对三者做一些区别分析及常见面试问题总结，希望加深自己对这三者的认知，分享出来，也希望能帮助到有需要的小伙伴~
【Java学习】Java字符串类String、StringBuffer/StringBuilder及其常用操作
chen_z_p的博客
10-18 1090
文章目录1 Java中的字符串1.1 String、StringBuffer和StringBuilder的区别1.1.1 String的不可变性1.1.2 可变字符串类型StingBuffer和StringBuilder1.1.3 String、StringBuffer和StringBuilder的选用2 String类的常用操作2.1 创建String对象2.2 获取长度：int length(...
小瓜牛漫谈 — String、StringBuffer、StringBuilder
weixin_30878361的博客
04-23 130
任何一个系统在开发的过程中, 相信都不会缺少对字符串的处理。 在 java 语言中, 用来处理字符串的的类常用的有 3 个:String、StringBuffer、StringBuilder。 它们的异同点: 1) 都是 final 类, 都不允许被继承; 2) String 长度是不可变的, StringBuffer、StringBuilder 长度是可变的; ...
StringBuffer与StringBuilder 2024-8-21 22-13
最新发布
2301_80011650的博客
08-21 733
和都是 Java 中用于操作可变字符串的工具类。它们的主要区别在于线程安全性和性能。是线程安全的，但性能相对较低；是非线程安全的，但在单线程环境下性能更高。在选择使用哪个类时，需要根据具体的应用场景来决定。如果是在多线程环境下操作字符串，应该使用；如果是在单线程环境下，为了获得更好的性能，可以选择使用。
String、StringBuffer、StringBuilder
zjh的博客
09-11 192
String、StringBuffer、StringBuilder 一直是 java 面试中较为热点的问题，一般作为一个开场问题。那么这三者之间有什么区别，如何根据场景来选择使用，本文将基于三者的源码、性能、以及面试常问点来进行分析。 一、String、StringBuffer、StringBuilder 底层源码 String类 看一下 String 类的类图，它实现了 CharSequence 接口，也就是说 String 是 CharSequence 类型. 它的底层是被 final 修饰的字符
String、StringBuffer、StringBuild
weixin_45617480的博客
07-20 296
String String类被final修饰，底层为charl类型数组，且数组也被final修饰，故数组也不可变，这也是为什么String类型不可变，若想要改变，只能创建新的数组，也正是因为如此，所以它是安全的，同时还有hashcode方法与equals方法，这也是为什么spring中的注入集合中为什么要以String类型为key的原因。 /** The value is used for cha...
String，StringBuffer，StringBuilder
WhataNerd的博客
10-14 555
String，StringBuffer，StringBuilder 这三者的区别是 Java 学习中的一个基础知识，也是在面试中经常会问到的一个知识点StringString 也许是 Java 中最常被用到的类了，关于它，有很多值得一提的地方首先，Java 中的 String 是一个 char 类型序列：char[] data = {'a', 'b', 'c'};// 等价于String str =
StringBuilder线程安全问题导致ArrayIndexOutOfBoundsException 数组下标越界错误
yangyingjieshiwo的专栏
04-15 1078
前一段时间网上看博客的时候看到StringBuilder线程安全的一篇文章。其中讲到了，StringBuilder可能会因为线程安全问题导致java.lang.ArrayIndexOutOfBoundsException 数组下标越界错误。我有点好奇，就拿着文章中的例子跑了下，结果真的产生了这个问题。我然后就想了下，总结了下原因。 下面是产生问题的代码: package demo; ...
java基础复习篇
m0_67247641的博客
11-01 474
Java泛型是JDK5中引入的一个新特性。使用泛型参数，可以增强代码的可读性、稳定性。编译器可以对泛型参数进行检测，并且通过泛型参数可以指定传入的对象类型。比如：ArrayList persons = new ArrayList()这行代码就指明了该ArrayList()这行代码就只能传入Person对象，如果传入其他类型的对象就会报错。并且，原生 List 返回类型是 Object，需要手动转换类型才能使用，使用泛型后编译器自动转换。
java基础(详细全覆盖篇)
weixin_45388641的博客
08-21 322
一：java概述： 1991 年Sun公司的James Gosling等人开始开发名称为 Oak 的语言，希望用于控制嵌入在有线电视交换盒、PDA等的微处理器； 1994年将Oak语言更名为Java； Java的三种技术架构: JAVAEE：Java Platform Enterprise Edition，开发企业环境下的应用程序，主要针对web程序开发； JAVASE：Java Platform...
JAVA中String、StringBuffer和StringBuider类
weixin_47267628的博客
02-27 718
String String类的继承关系图： 基本介绍： String对象用于保存字符串，也就是一组字符序列 字符串常量对象是用双引号括起的字符序列。例如："你好"，"haikang"，"168"等 字符串的字符使用Unicode字符编码，一个字符（不区分字母还是汉字）占两个字节 String类较常用构造器： String s1 = new String(); String s2 = new String(String moriginal); String s3 = new Strin
String StringBuffer StringBuild
ajiaojie的专栏
08-04 462
转载：http://zhidao.baidu.com/link?url=N0WBDny5HqM_p61B3Q6DuvLe0_v1DLUlakRETvaMgy0Jx1ozedIvnIspe3DViPR0NSp8U8O9yMMzbdEC2vN9K_ 1. 在执行速度方面的比较：StringBuilder > StringBuffer 2. StringBuffer与StringBuild
String,StringBuild和StringBuffer
weixin_43286124的博客
07-02 172
相同点：储存和操作字符串 不同点： 这三个类之间的区别主要是在两个方面，即 运行速度 和 线程安全 这两方面。 1. 运行速度(执行速度)快慢为：StringBuilder > StringBuffer > String String最慢的原因：String类是final类型的，为字符串常量，当直接创建一个字符串“abc”时，是最快的；s=“a”+“b”+“c”;就会慢很多，不断创建新的对象并且将旧的对象回收，需要一个过程，所以执行速度很慢； StringBuilder和StringBuff
String,StringBuffer,StringBuild的区别
难不难的博客
07-02 465
String和StringBuild是异步的 StringBuffer是同步的，线程安全的 String是不可变的，是final的 String a="abc"; a=a+"cde"; 字符串a指向一块存储有abc的内存，拼接以后会指向另一块内存，因为String是不可变的 StringBuffer buffer=new StringBuffer("abc"); buffer.app
转：String,StringBuffer与StringBuilder的区别??
lumingming1987的博客
05-22 154
String 字符串常量StringBuffer 字符串变量（线程安全）StringBuilder 字符串变量（非线程安全） 简要的说， String 类型和 StringBuffer 类型的主要性能区别其实在于 String 是不可变的对象, 因此在每次对 String 类型进行改变的时候其实都等同于生成了一个新的 String 对象，然后将指针指向新的 String 对象，所以经常改变内容的...
Java基础之String,StringBuffer与StringBuilder的区别及应用场景
A_big_fish的博客
07-11 419
1 概述 String 字符串常量；  StringBuffer 字符串变量（线程安全），是一个容器，最终会通过toString方法变成字符串；  StringBuilder 字符串变量（非线程安全）。 2 String与StringBuffer区别 2.1 在修改时对象自身是否可变（主要区别） （1） String在修改时不会改变对象自身  在每次对 String
Java中String、StringBuffer、StringBuilder性能对比分析
每次对String对象进行修改（如拼接）都会创建一个新的String对象，这可能导致大量的内存分配和垃圾回收，影响性能。 2. StringBuffer类： - StringBuffer是线程安全的字符串缓冲区。它允许在现有字符串基础上进行...
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值