字符串、StringBuffer 和 StringBuilder

Question

比较 String、StringBuffer 和 StringBuilder 的实时情况是什么？

Answer 1

可变性差异：

字符串是不可变的。如果您尝试更改它们的值，则会创建另一个对象，而 StringBuffer 和 StringBuilder 是可变的，因此它们可以更改其值。

线程安全差异：

StringBuffer 和 StringBuilder 之间的差异在于 StringBuffer 是线程安全的。因此，当应用程序只需要在单线程中运行时，最好使用StringBuilder。 StringBuilder 比 StringBuffer 更高效。

情况：

• 如果您的字符串不会更改，请使用 String 类，因为 String 对象是不可变的。
• 如果您的字符串可以更改（例如：字符串构造中的大量逻辑和操作）并且只能从单个线程访问，那么使用 StringBuilder 就足够了。
• 如果您的字符串可以更改，并且可以从多个线程访问，请使用 StringBuffer，因为 StringBuffer 是同步的，因此您具有线程安全性。

Answer 2

• 您使用 String 当不可变结构合适时；从 String 获取新的字符序列可能会带来不可接受的性能损失，无论是 CPU 时间还是内存（获取子字符串是 CPU 高效的，因为数据没有被复制，但这意味着可能需要大量的数据）数据可能仍保持分配状态）。
• 您使用 StringBuilder 当您需要创建可变字符序列时，通常将多个字符序列连接在一起。
• 您使用 StringBuffer 在相同的情况下，您将使用 StringBuilder，但是当对底层字符串的更改必须同步时（因为多个线程正在读取/修改字符串缓冲区）。

请参阅此处的示例。

Answer 3

基础知识：

String 是一个不可变类；它无法改变。
StringBuilder是一个可变类，可以附加、替换或删除字符并最终转换为 String
StringBuffer 是 StringBuilder 的原始同步版本。

在只有一个线程访问对象的所有情况下，您应该更喜欢 StringBuilder。

详细信息：

另请注意，StringBuilder/Buffers 并不是魔法。他们只是使用数组作为支持对象，并且每当数组变满时就必须重新分配该数组。确保创建的 StringBuilder/Buffer 对象最初足够大，这样就不必在每次调用 .append() 时不断调整它们的大小。

调整大小可能会变得非常退化。每次需要扩展时，它基本上都会将支持数组的大小调整为其当前大小的两倍。当 StringBuilder/Buffer 类开始变大时，这可能会导致大量 RAM 被分配但未被使用。

在 Java 中，String x = "A" + "B"; 在幕后使用 StringBuilder。因此，对于简单的情况，声明自己的情况没有任何好处。但是，如果您要构建很大的 String 对象，例如小于 4k，则声明 StringBuilder sb = StringBuilder(4096); 比串联或使用 < a href="http://docs.oracle.com/javase/8/docs/api/java/lang/StringBuilder.html#StringBuilder--" rel="nofollow noreferrer">默认构造函数 16 个字符。如果您的 String 将小于 10k，那么为了安全起见，请使用构造函数将其初始化为 10k。但如果它初始化为 10k，那么您写入的字符超过 10k，它将被重新分配并复制到 20k 数组。所以初始化高比初始化低好。

在自动调整大小的情况下，在第 17 个字符处，支持数组被重新分配并复制到 32 个字符，在第 33 个字符处，这种情况再次发生，您需要重新分配数组并将其复制到 64 个字符。您可以看到这如何退化为大量重新分配和复制，这正是您首先要避免使用StringBuilder/Buffer的情况。

这是来自 AbstractStringBuilder 的 JDK 6 源代码：

   void expandCapacity(int minimumCapacity) {
    int newCapacity = (value.length + 1) * 2;
        if (newCapacity < 0) {
            newCapacity = Integer.MAX_VALUE;
        } else if (minimumCapacity > newCapacity) {
        newCapacity = minimumCapacity;
    }
        value = Arrays.copyOf(value, newCapacity);
    }

如果您不知道如何立即初始化，则最佳实践是初始化 StringBuilder/Buffer ，其大小比您认为需要的大一点。 String 将会很大，但你可以猜到。一次分配比您需要的稍多的内存将比大量重新分配和复制更好。

还要注意用 String 初始化 StringBuilder/Buffer，因为这只会分配 String + 16 个字符的大小，在大多数情况下，这只会开始退化重新分配，您试图避免的复制周期。以下直接来自 Java 6 源代码。

public StringBuilder(String str) {
    super(str.length() + 16);
    append(str);
    }

如果您偶然得到了一个不是您创建的 StringBuilder/Buffer 实例，并且无法控制所调用的构造函数，则有一种方法可以避免退化的重新分配和复制行为。调用 .ensureCapacity( ) 以及您想要确保生成的 String 适合的大小。

替代方案：

请注意，如果您确实进行繁重字符串构建和操作，那么有一个更加注重性能的替代方案，称为绳索。

另一种选择是通过子类化 ArrayList 来创建 StringList 实现，并添加计数器来跟踪每个 .append() 上的字符数。 code> 和列表的其他突变操作，然后重写 .toString() 以创建所需大小的 StringBuilder 并循环列表并构建输出，您甚至可以将 StringBuilder 设为实例变量并“缓存”.toString() 的结果，并且只需在发生更改时重新生成它。

另外，在构建固定格式输出时，不要忘记 String.format() ，编译器可以对其进行优化，使其变得更好。

Answer 4

您可能指的是串联。

真实示例：您想要从许多其他字符串中创建一个新字符串。

例如，要发送消息：

String 版本：

    String s = "Dear " + user.name + "<br>" +
    " I saw your profile and got interested in you.<br>" +
    " I'm  " + user.age + "yrs. old too"

StringBuilder 版本：

    String s = new StringBuilder().append.("Dear ").append(user.name).append("<br>")
              .append(" I saw your profile and got interested in you.<br>")
              .append(" I'm  ").append(user.age).append("yrs. old too")
              .toString()

或

    String s = new StringBuilder(100).appe..... etc. ...
    // The difference is a size of 100 will be allocated 
    // upfront as fuzzy lollipop points out.

StringBuffer 版本看起来像 StringBuilder但效果有所不同。

关于

StringBuffer 与StringBuilder

前者是同步的，后者不是。

因此，如果您在单个线程中多次调用它（这是 90% 的情况），StringBuilder 的运行速度将快得多，因为它不会停下来查看如果它拥有线程锁。

因此，建议使用 StringBuilder （当然，除非您有多个线程同时访问它，但这种情况很少见）。

String 连接（使用 + 运算符）可能会被编译器优化以在下面使用 StringBuilder，因此，不再需要担心。在 Java 的早期，每个人都说应该不惜一切代价避免这种情况，因为每次连接都会创建一个新的 String 对象。现代编译器不再这样做，但使用 StringBuilder 仍然是一个很好的做法，以防万一您使用“旧”编译器。

对于那些好奇的人来说，这就是编译器对此类所做的操作：

class StringConcatenation {
    int x;
    String literal = "Value is" + x;
    String builder = new StringBuilder().append("Value is").append(x).toString();
}

javap -c StringConcatenation

输出：

Compiled from "StringConcatenation.java"
class StringConcatenation extends java.lang.Object{
int x;

java.lang.String literal;

java.lang.String builder;

StringConcatenation();
  Code:
   0:    aload_0
   1:    invokespecial    #1; //Method java/lang/Object."<init>":()V
   4:    aload_0
   5:    new    #2; //class java/lang/StringBuilder
   8:    dup
   9:    invokespecial    #3; //Method java/lang/StringBuilder."<init>":()V
   12:    ldc    #4; //String Value is
   14:    invokevirtual    #5; //Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
   17:    aload_0
   18:    getfield    #6; //Field x:I
   21:    invokevirtual    #7; //Method java/lang/StringBuilder.append:(I)Ljava/lang/StringBuilder;
   24:    invokevirtual    #8; //Method java/lang/StringBuilder.toString:()Ljava/lang/String;
   27:    putfield    #9; //Field literal:Ljava/lang/String;
   30:    aload_0
   31:    new    #2; //class java/lang/StringBuilder
   34:    dup
   35:    invokespecial    #3; //Method java/lang/StringBuilder."<init>":()V
   38:    ldc    #4; //String Value is
   40:    invokevirtual    #5; //Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
   43:    aload_0
   44:    getfield    #6; //Field x:I
   47:    invokevirtual    #7; //Method java/lang/StringBuilder.append:(I)Ljava/lang/StringBuilder;
   50:    invokevirtual    #8; //Method java/lang/StringBuilder.toString:()Ljava/lang/String;
   53:    putfield    #10; //Field builder:Ljava/lang/String;
   56:    return

}

第 5 - 27 行用于名为“literal”的字符串

第 31-53 行用于名为“builder”的字符串。

没有任何区别；对两个字符串执行完全相同的代码。

Answer 5

字符串

String类表示字符串。 Java 程序中的所有字符串文字，例如 "abc" 都是作为此类的实例实现的。

字符串对象一旦创建就不可变，我们无法更改。 （字符串是常量）

• 如果使用构造函数或方法创建字符串，那么这些字符串将存储在堆内存以及SringConstantPool。但在保存到池中之前，它会调用 intern() 方法，使用 equals 方法检查池中具有相同内容的对象可用性。 如果字符串复制在池中可用，则返回引用。否则，String 对象将被添加到池中并返回引用。

  • Java 语言为字符串连接运算符 (+) 以及将其他对象转换为字符串提供了特殊支持。字符串连接是通过StringBuilder（或StringBuffer）类及其append方法实现的。

  String heapSCP = new String("Yash");
  heapSCP.concat(".");
  heapSCP = heapSCP + "M";
  堆SCP = 堆SCP + 777;
  
  // 例如：字符串源代码 
  公共字符串连接（字符串str）{
      int otherLen = str.length();
      if (otherLen == 0) {
          返回这个；
      }
      int len = 值.长度;
      char buf[] = Arrays.copyOf(value, len + otherLen);
      str.getChars(buf, len);
      返回新字符串（buf，true）；
  }
  

• 字符串文字存储在StringConstantPool中。

  String onlyPool = "Yash";
  

---

StringBuilder 和 StringBuffer 是可变的字符序列。这意味着人们可以改变这些对象的值。 StringBuffer 与 StringBuilder 具有相同的方法，但 StringBuffer 中的每个方法都是同步的，因此它是线程安全的。

• StringBuffer 和 StringBuilder 数据只能使用 new 运算符创建。因此，它们存储在堆内存中。

• StringBuilder 的实例对于多线程使用是不安全的。如果需要这样的同步，那么建议使用StringBuffer。

  StringBuffer threadSafe = new StringBuffer("Yash");
  threadSafe.append(".M");
  threadSafe.toString();
  
  StringBuilder nonSync = new StringBuilder("Yash");
  nonSync.append(".M");
  nonSync.toString();
  

• StringBuffer 和 StringBuilder 有一个特殊的方法，例如：
  replace(int start, int end, String str) 和 reverse()。

  <块引用>

  注意：StringBuffer 和 SringBuilder 是可变的，因为它们提供了Appendable Interface 的实现。

---

什么时候用哪个。

• 如果您不打算每次都更改该值，那么最好使用String Class。作为泛型的一部分，如果您想要排序 Comparable或比较值，那么请转到对于字符串类。

  //ClassCastException: java.lang.StringBuffer 无法转换为 java.lang.Comparable
  设置 set = new TreeSet();
  set.add( 线程安全 );
  System.out.println("设置："+设置);
  

• 如果您要每次修改值，请选择比 StringBuffer 更快的 StringBuilder。如果多个线程正在修改该值，请选择 StringBuffer。

Answer 6

-----------------------------------------------------------------
               String                StringBuffer   StringBuilder
-----------------------------------------------------------------
Storage area | Constant string pool  Heap           Heap
Modifiable   | No (immutable)        Yes (mutable)  Yes (mutable)
Thread Safe  | Yes                   Yes            No
Performance  | Fast                  Very slow      Fast
-----------------------------------------------------------------

Answer 7

另外，StringBuffer 是线程安全的，而 StringBuilder 则不是。

因此，在实时情况下，当不同线程访问它时，StringBuilder 可能会产生不确定的结果。

Answer 8

请注意，如果您使用的是 Java 5 或更高版本，则应使用 StringBuilder 而不是 StringBuffer。来自 API 文档：

从 JDK 5 版本开始，此类已补充了一个专为单线程使用而设计的等效类 StringBuilder。通常应优先使用 StringBuilder 类，因为它支持所有相同的操作，但速度更快，因为它不执行同步。

实际上，您几乎永远不会同时在多个线程中使用它，因此 StringBuffer 所做的同步几乎总是不必要的开销。

Answer 9

就我个人而言，我认为 StringBuffer 没有任何实际用途。我什么时候想要通过操作字符序列在多个线程之间进行通信？这听起来一点用也没有，但也许我还没有看到曙光:)

Answer 10

String 与其他两个类的区别在于 String 是不可变的，而其他两个是可变的类。

但是为什么我们有两个用于相同目的的类？

原因是 StringBuffer 是线程安全的，而 StringBuilder 不是。
StringBuilder 是 StringBuffer` API 中的一个新类，它是在 中引入的JDK 5，如果您使用单线程，则始终建议您使用环境，因为它更快。

有关完整的详细信息，您可以阅读 http://www.codingeek.com/java/stringbuilder-and-stringbuffer-a-way-to-create-mutable-strings-in-java/

Answer 11

在 Java 中，String 是不可变的。不可变意味着一旦创建了字符串，我们就无法更改它的值。

StringBuffer 是可变的。一旦创建了 StringBuffer 对象，我们只需将内容追加到对象的值中，而不是创建一个新对象。

StringBuilder与StringBuffer类似，但它不是线程安全的。 StingBuilder 的方法不是同步的，但与其他 String 相比，Stringbuilder 运行速度最快。

您可以通过实现来了解 String、StringBuilder 和 StringBuffer 之间的区别他们。

Answer 12

下面是一个小代码片段，说明了如何在异步环境中中断 StringBuilder：

public static void main(String[] args) throws InterruptedException {
    StringBuilder builder = new StringBuilder();

    ExecutorService executorService = Executors.newFixedThreadPool(50);
    for (int i = 0; i < 1000 * 1000; i++) {
        executorService.submit(new AppendRunnable(builder));
    }

    executorService.shutdown();
    executorService.awaitTermination(1, TimeUnit.MINUTES);

    Stream.of(builder.toString().split(System.lineSeparator()))
        .filter(line -> !line.equals("I just appended this!"))
        .forEach(System.out::println);
}

record AppendRunnable(StringBuilder stringBuilder) implements Runnable {

    @Override
    public void run() {
        stringBuilder.append("I just appended this!\n");
    }
}

本质上，我们将字符串附加到构建器，并且我们期望所有字符串都等于“我刚刚附加了这个！”。但事实并非如此；其中一些以空字符为前缀，因为构建器的内部字符缓冲区未同步并且错误地调整了大小。在这种情况下使用 StringBuffer 可以解决这个问题。更详细的信息位于此处。