Java 中的 String、StringBuilder、StringBuffer 的区别

目录

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

1、是什么？

• 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() 方法则在指定的点添加字符。

2、区别是？

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

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。

3、小结

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

4、加餐

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 等，实际上每一个基本类型都有他的包装类）和数组。

结尾

本文到这里就结束了，感谢看到最后的朋友，都看到最后了，点个赞再走啊，若有不对之处还请多多指正。关注我带你解锁更多精彩内容