stringbuffer stringbuilder区别_Java 中的 String、StringBuilder、StringBuffer 的区别

本文始发于我的 CSDN ：

Java 中的 String、StringBuilder、StringBuffer 的区别​blog.csdn.net

和微信公众号：

Java 中的 String、StringBuilder、StringBuffer 的区别​mp.weixin.qq.com

目录

• • • 一、是什么？
    • 二、区别是？
      • 1. 运行速度（执行速度）
      • 2. 线程安全
    • 三、小结
    • 四、加餐

一、是什么？

• String 不可变字符序列

String 是字符串常量，其对象一旦创建之后该对象是不可更改的， 因此在每次对 String 类型进行改变的时候其实都等同于生成了一个新的 String 对象，然后将指针指向新的 String 对象，所以经常改变内容的字符串最好不要用 String ，因为每次生成新对象都会开辟新的内存空间，当内存中无引用对象多了以后， JVM 的 GC 就会开始工作，那速度一定是相当慢的，对系统性能产生影响。
String 这个类很特殊，特殊在于 JVM 专门为它作了某些处理：在 JVM 中存在一个字符串常量池，其中存有很多 String 对象，并且可以被共享使用。当创建一个字符串常量时，例如 String str = “Chittyo”; 会首先在字符串常量池中查找是否存在相同的字符串定义，若已经定义，则直接引用其定义，此时不需要创建新的对象；若没有定义，则需要创建对象，然后把它加入到字符串常量池中，再将他的引用返回。由于字符串是不可变类，一旦创建好了就不可修改，因此字符串对象可以被共享而且不会引起程序的混乱。

• StringBuilder 可变字符序列、效率高、非线程安全

java.lang.StringBuilder 是 Java 5.0 新增的可变的字符序列。此类提供一个与 StringBuffer 兼容的 API，但不保证同步。该类被设计用作 StringBuffer 的一个简易替换，用在字符串缓冲区被单个线程使用的时候（这种情况很普遍）。如果可能，建议 优先采用该类，因为在大多数实现中，它比 StringBuffer 要快。两者的方法基本相同。

• StringBuffer 可变字符序列、效率低、线程安全

Java.lang.StringBuffer 是线程安全的可变字符序列。一个类似于 String 的字符串缓冲区。虽然在任意时间点上它都包含某种特定的字符序列，但通过某些方法调用可以改变该序列的长度和内容。可将字符串缓冲区安全地用于多个线程。可以在必要时对这些方法进行同步，因此任意特定实例上的所有操作就好像是以串行顺序发生的，该顺序与所涉及的每个线程进行的方法调用顺序一致。每个字符串生成器都有一定的容量，只要字符串生成器包含的字符序列的长度没有超出此容量，就无需分配新的内容缓冲区。如果内容缓冲区溢出，则此容量自动增大。
StringBuffer 上的主要操作是 append() 和 insert() 方法，可重载这些方法，以接受任意类型的数据。每个方法都能有效地将给定的数据转换成字符串，然后将该字符串的字符 追加 or 插入 到字符串缓冲区中。append() 方法始终将这些字符添加到缓冲区的末端；而 insert() 方法则在指定的点添加字符。

二、区别是？

主要存在以下两个方面的区别：运行速度、线程安全。

1. 运行速度（执行速度）

运行速度的快慢：StringBuilder > StringBuffer > String。

为什么 String 最慢呢？因为 String 为字符串常量，而 StringBuilder 和 StringBuffer 均为字符串变量，即 String 对象一旦创建之后该对象是不可更改的，但后两者的对象是变量，是可以更改的。
一言不合上代码，举个栗子：

String str = "Chitty";
System.out.println(str);
str = str + "o";
System.out.println(str);

运行这段代码，会先输出 “Chitty”，后输出 “Chittyo”。看着像是 str 这个对象被更改了，实则不然，假象而已。

JVM 对于这几行代码是这样处理的，（严谨起见，假设上述代码中的字符串都是第一次创建，在字符串常量池中找不到），首先在堆内存中新建了一块内存空间，分配给第一行创建的 String 对象 str，并把 “Chitty” 赋值给 str，然后在第三行中，JVM 在堆内存中又创建了两份内存空间，用来存放 “o” 和最终的 String 对象 str。所以，第一行的 str 实际上并没有被更改，即之前说的 String 对象一旦创建之后就不可更改了。而原来第一行的 str（“Chitty”） 以及 第三行中新建的 “o” 的内存空间，并不会即时就被 JVM 的垃圾回收机制（GC）给回收掉，GC 的时机是 JVM 在某个时候，才开始执行的，所以并一定会明显的由于新开辟内存空间，且回收内存，引起 String 速度变慢。严谨来说，在大量的 String 拼接操作出现的时候，JVM 由于开辟内存空间过多，导致内存紧张，基本实时进行 GC，这样才会引起速度变慢。Java 中对 String 对象进行的操作实际上是一个不断创建新的对象并且适时将旧的对象回收的一个过程，这不仅是对内存空间的极大浪费，也导致了执行速度缓慢。而 StringBuilder 和 StringBuffer 的对象是变量，能够被多次修改，且不产生新的对象，即不进行创建和回收的操作，所以速度要比 String 快很多。

换个栗子举一下：

String str = "Chitty" + "o";
StringBuilder stringBuilder = new StringBuilder().append("Chitty").append("o");
System.out.println(str);
System.out.println(stringBuilder.toString());

这样输出结果也是 “Chittyo” 和 “Chittyo”，但是 String 的速度却比 StringBuilder 的反应速度要快很多，这是因为第 1 行中的操作

String str = "Chitty" + "o";

和

String str = "Chittyo";

是完全一样的，所以会很快。如若写成下面这种形式，

String str1 = "Chitty";
String str2 = "o";
String str = str1 + str2;

那么，JVM 就会像上面说的那样，不断的创建、回收对象来进行这个操作了。速度就会很慢。

由于 StringBuilder 相较于 StringBuffer 有速度优势，所以多数情况下建议使用 StringBuilder 类。然而在应用程序要求线程安全的情况下，则必须使用 StringBuffer 类。 下面我们来看下线程安全方面的区别。

2. 线程安全

StringBuilder 是线程不安全的，而 StringBuffer 是线程安全的。
如果一个 StringBuffer 对象在字符串缓冲区被多个线程使用时，StringBuffer 中很多方法可以带有 synchronized 关键字，所以可以保证线程是安全的。但 StringBuilder 的方法则没有该关键字，所以不能保证线程安全，有可能会出现一些错误的操作。所以在多线程环境下操作用 StringBuffer，在单线程环境下操作，还是建议使用速度比较快的 StringBuilder。

三、小结

• 操作少量的字符串数据 用 String；
• 单线程下字符缓冲区中的大量操作 用 StringBuilder（推荐使用）；
• 多线程下字符缓冲区中的大量操作 用 StringBuffer。

四、加餐

String strA ＝ "Chittyo";
String strB ＝ "Chittyo";
String strC = new String("Chittyo");
String strD = new String("Chittyo");
System.out.println(strA == strB);
System.out.println(strC == strD);

Q：创建 String 对象的两种方式的区别是什么？
A：首先看一下打印结果：第五行打印 true ；第六行打印 false 。

分析：我们知道 Java 的 8 种基本数据类型（ int, long, short, double, float, byte, char, boolean）用 == 比较的是变量值，因为他们没有地址，只有值。而 String 是引用数据类型，== 比较的是两个引用变量的地址。

strC 和 strD 是 new 出来的两个完全不同的对象，引用变量的地址不同，仅仅是值相等。可类比记忆：两个人仅仅是名字相同。所以第六行打印 false 。
来看一下，创建新对象的过程：

① 执行 String strC = new String("Chittyo"); 时，JVM 直接创建一个新的对象并让 strC 指向该对象；
② 执行 String strD = new String("Chittyo"); 时，JVM 再次创建一个新的对象并让 strD 指向该对象；
③ 所以 strC 与 strD 指向不同的对象，即引用变量的地址不同。

那么 strA == strB 吗？strA、strB 并不是通过 new 的方式创建的，所以他们的地址取决于后面所赋的值。Java 中，普通字符串存储在字符串常量池中，字符串常量池目前位于堆内存中（ JDK 1.8，JVM 把字符串常量池移到了堆内存中）。
再来瞄一眼，直接赋值过程：

① 执行 String strA ＝ "Chittyo"; 后，JVM 在字符串常量池中开辟空间存放一个 “Chittyo” 字符串空间并让 strA 指向该对象。
② 执行 String strB ＝ "Chittyo"; 时，JVM 会先检查字符串常量池中是否已经存在了一内容为 "Chittyo" 的空间，如果存在就直接让 strB 指向该空间，否则就会在开辟一个新的空间存放该字符串。
③ 所以创建 strB 的时候，因为字符串常量池中已经有字符串 "Chittyo" ，所以直接让 strB 指向该空间。相当于： String strB = strA;

所以，从赋值方面来看，此时的 strA == strB 是成立的，比较的是字符串常量池里的值。（字符串常量池在堆内存中）

引用类型指向一个对象，指向对象的变量是引用变量。这些变量在声明时被指定为一个特定的类型。变量一旦声明后，类型就不能被改变了。对象、数组都是引用数据类型。所有引用类型的默认值都是 null。一个引用变量可以用来引用任何与之兼容的类型。

一般对于对象，比较值是否相等的时候，都是通过覆写 equals() 方法和 hashCode() 方法来比较的。String 类型比较不同对象内容是否相同，应该用 equals() ，因为 == 用于比较引用数据类型和基本数据类型时具有不同的功能。

== 用于基本数据类型的比较，判断引用是否指向堆内存的同一块地址。equals() 用于判断两个变量是否是被同一个对象引用，即堆中的内容是否相同，返回值为布尔类型。

String str1 = new String("Chittyo");
String str2 = new String("Chittyo");
String str3 = str1;
System.out.println(str1 == str2);     //false
System.out.println(str1.equals(str2));//true
System.out.println(str1 == str3);     //true
System.out.println(str1.equals(str3); //true

巧记：== 用来比较栈内存中的值，equals() 用来比较堆内存中的值。

JVM 把内存划分成两种：一种是栈内存，一种是堆内存。
　　① 在函数中定义的一些基本数据类型的变量和对象的引用变量（变量名）都在函数的栈内存中分配。
　　② 当在一段代码块定义一个变量时，Java 就在栈中为这个变量分配内存空间，当超过变量的作用域后，Java 会自动释放掉为该变量所分配的内存空间，该内存空间可以立即被另作他用。
　　③ 堆内存用来存放由 new 创建的对象（包括由基本类型包装起来的类：Integer、String、Double 等，实际上每个基本类型都有他的包装类）和数组。