Java学习——String，StringBuffer和StringBuilder

Java学习——String，StringBuffer和StringBuilder

摘要：本文主要介绍了String字符串在内存中的存储情况，以及StringBuffer和StringBuilder的区别。

部分内容来自以下博客：

https://www.cnblogs.com/xrq730/p/4841518.html

https://www.cnblogs.com/xiaoxi/p/6036701.html

https://blog.csdn.net/k393393/article/details/79078670

String类

不可变性

String类是final类，也即意味着String类不能被继承，并且它的成员方法都默认为final方法。在Java中，被final修饰的类是不允许被继承的，并且该类中的成员方法都默认为final方法。

String类其实是通过char数组来保存字符串的。

所有对String类的操作都不是在原有的字符串上进行的，而是重新生成了一个新的字符串对象。也就是说进行这些操作后，最原始的字符串并没有被改变。

String对象一旦被创建就是固定不变的了，对String对象的任何改变都不影响到原对象，相关的任何改变都会生成新的对象。

下面代码中对String的改动并不会影响到原有的String字符串：

 public static void change(String str) {
     str = str + "def";
 }

 public static void main(String[] args) {
     String a = "abc";
     String b = new String("abc");
     change(a);
     change(b);
     System.out.println("a >>> " + a);
     System.out.println("b >>> " + b);
 }

运行结果：

 a >>> abc
 b >>> abc

字符串常量池

我们知道字符串的分配和其他对象分配一样，是需要消耗高昂的时间和空间的，而且字符串我们使用的非常多。JVM为了提高性能和减少内存的开销，在实例化字符串的时候进行了一些优化：使用字符串常量池。

每当我们创建字符串常量时，JVM会首先检查字符串常量池。如果该字符串已经存在常量池中，那么就直接返回常量池中的实例引用。如果字符串不存在常量池中，就会实例化该字符串并且将其放到常量池中，同时返回对该实例的引用。

由于String字符串的不可变性我们可以十分肯定常量池中一定不存在两个相同的字符串（这点对理解上面至关重要）。

来看两行代码：

 String a = "abc";
 String b = new String("abc");

第一行创建的字符串常量a保存的是指向常量池里abc的地址，这是在编译时就能确定的。

第二个创建的字符串常量b保存的是指向堆内存里abc的地址，而因为字符串都是保存在常量池里的，所以堆内存里保存的也是一个指向常量池的abc的地址。因为在编译时是不确定的，所以b保存的地址值是在运行时确定的。

例子1：

 public void test1() {
     String a = "abc";
     String b = "abc";
     String c = new String("abc");
     String d = new String("abc");
     System.out.println(a == b);// true
     System.out.println(a == c);// false
     System.out.println(c == d);// false
 }

分析：

a和b保存的都是指向常量池里“abc”的引用地址，在编译期间就已经确定了，所以a和b判断返回true。

用new创建的字符串不是常量，不能在编译期就确定，所以字符串不放入常量池中，它们有自己的地址空间。c和d保存的是两个堆内存的引用地址，是两个不同的地址空间，所以a和c、c和d判断都是false。

例子2：

 public void test2() {
     String a = "abc";
     String b = "def";
     String c = a + b;
     String d = "abc" + "def";
     String e = "abc" + new String("def");
     String f = "abcdef";
     System.out.println(c == d);// false
     System.out.println(c == f);// false
     System.out.println(d == f);// true
     System.out.println(e == f);// false
 }

分析：

因为a、b、d、f保存的都是指向常量池的引用，它们在编译期就被确定了，所以d和f判断返回true。

因为d和f均是在运行时才确定的，保存的都是堆内存中的引用地址，所以c和d、c和f、e和f判断返回都是false。

例子3：

 public void test3() {
     final String a = "abc";
     String b = "def";
     String c = "abcdef";
     String d = a + b;
     String e = a + "def";
     System.out.println(c == d);// false
     System.out.println(c == e);// true
 }

分析：

因为a被final修饰了，对于final修饰的变量，它在编译时被解析为常量值的一个本地拷贝存储到自己的常量池中或嵌入到它的字节码流中，所以e的操作在编译期间就可以确定了，所以c和e判断为true。

因为b没有被final修饰，所以d还是不能在编译期间确定，所以d保存的还是堆内存里的地址，所以c和d判断返回false。

字符串的拼接操作

编译器每次碰到“+”的时候，会new一个StringBuilder出来，接着调用append()方法，再调用toString()方法，生成新字符串。那么，这意味着，如果代码中有很多的“+”，就会每个“+”生成一次StringBuilder，这种方式对内存是一种浪费，效率很不好。

字符串对常量的拼接操作和对字面量的拼接是有区别的。

 public void test() {
     String a = "abc";
     String b = "def";
     String c = "abcdef";
     String d = "abc" + "def";
     String e = a + b;
     System.out.println(c == d);// true
     System.out.println(c == e);// false
 }

字符串字面量拼接操作是在Java编译器编译期间就执行了，也就是说编译器编译时，直接把“abc”和“def”进行拼接，得到“abcdef”常量，并且直接将这个常量放入字符串池中。

这样做实际上是一种优化，将3个字面量合成一个，避免了创建多余的字符串对象。而字符串引用的拼接运算是在Java运行期间执行的，它会在堆内存中重新创建一个拼接后的字符串对象。

对于直接相加字符串，效率很高，因为在编译器便确定了它的值。对于间接相加（即包含字符串引用），效率要比直接相加低，因为在编译器不会对引用变量进行优化。

关于String.intern()

intern()方法使用：一个初始为空的字符串池，它由类String独自维护。当调用 intern()方法时，如果池已经包含一个等于此String对象的字符串（用equals()方法确定），则返回池中的字符串。否则，将此String对象添加到池中，并返回此String对象的引用。

它遵循以下规则：对于任意两个字符串a和b，当且仅当a.equals(b)为true时，a.intern()==b.intern()才为true。

存在于class文件中的常量池，在运行期间被JVM装载，并且可以扩充，String的intern()方法就是扩充常量池的一个方法。当一个String实例str调用intern()方法时，查找常量池中是否有相同unicode的字符串常量。如果有，则返回其引用。如果没有，则在常量池中增加一个unicode等于str的字符串并返回它的引用。

 public void test(){
     String a = "abc";
     String b = new String("abc");
     String c = new String("abc");
     System.out.println(a == b);// false
     b.intern();
     c = c.intern();
     System.out.println(a == b);// flase
     System.out.println(a == b.intern());// true
     System.out.println(a == c);// true
 }

StringBuilder

构造方法

public StringBuilder()：创建一个长度为默认16的char类型的数组。

public StringBuilder(int capacity)：创建一个指定长度的char类型的数组。

常用方法

public StringBuilder append(String str)：追加内容。

public StringBuilder delete(int start, int end)：删除指定位置的内容。

public StringBuilder replace(int start, int end, String str)：把指定位置的字符串替换为传入的字符串。

public StringBuilder insert(int offset, String str)：在指定位置插入传入的字符串。

StringBuffer

构造方法

public StringBuffer()：创建一个长度为默认16的char类型的数组。

public StringBuffer(int capacity)：创建一个指定长度的char类型的数组。

常用方法

public synchronized StringBuffer append(String str)：追加内容。

public synchronized StringBuffer delete(int start, int end)：删除指定位置的内容。

public synchronized StringBuffer replace(int start, int end, String str)：把指定位置的字符串替换为传入的字符串。

public synchronized StringBuffer insert(int offset, String str)：在指定位置插入传入的字符串。

String、StringBuffer、StringBuilder三者的区别

可变与不可变

String是不可变字符串对象，StringBuilder和StringBuffer是可变字符串对象（其内部的字符数组长度可变）。

是否多线程安全

String中的对象是不可变的，也就可以理解为常量，显然线程安全。StringBuffer与StringBuilder中的方法和功能完全是等价的，只是StringBuffer中的方法大都采用了synchronized关键字进行修饰，因此是线程安全的，而StringBuilder没有这个修饰，可以被认为是非线程安全的。

执行效率

StringBuilder > StringBuffer > String

当然这个是相对的，不一定在所有情况下都是这样。比如 String str = "hello" + "world"; 的效率就比 StringBuilder builder = new StringBuilder().append("hello").append("world"); 要高。

因此，这三个类是各有利弊，应当根据不同的情况来进行选择使用：

当字符串相加操作或者改动较少的情况下，建议使用String这种形式；

当字符串相加操作较多的情况下，建议使用StringBuilder，如果采用了多线程，则使用StringBuffer。