Java中String、StringBuffer和StringBuilder详解

1 String

String 类是代表不可变的字符序列，StringBuilder 类和 StringBuffer 类代表可变字符序列。
源码中字符串内容全部存储到 value[ ]数组中，而变量 value 是 final 类型的，也就是常量(即只能被赋值一次)。 这就是“不可变对象”的典型定义方式。

public class TestString1 {
	public static void main(String[ ] args) {
		String s1 = new String("abcdef");
		String s2 = s1.substring(2, 4);
		// 打印：ab199863
		System.out.println(Integer.toHexString(s1.hashCode()));
		// 打印：c61, 显然 s1 和 s2 不是同一个对象
		System.out.println(Integer.toHexString(s2.hashCode()));
	}
}

在遇到字符串常量之间的拼接时，编译器会做出优化，即在编译期间就会完成字符串的拼接。因此，在使用==进行 String 对象之间的比较时，我们需要特别注意。

public class TestString2 {
	public static void main(String[ ] args) {
		//编译器做了优化,直接在编译的时候将字符串进行拼接
		String str1 = "hello" + " java";//相当于 str1 = "hello java";
		String str2 = "hellojava";
		System.out.println(str1 == str2);//true
		String str3 = "hello";
		String str4 = " java";
		//编译的时候不知道变量中存储的是什么,所以没办法在编译的时候优化
		String str5 = str3 + str4;
		System.out.println(str2 == str5);//false
	}
}

String 使用的陷阱
String 一经初始化后，就不会再改变其内容了。对 String 字符串的操作实际上是对其副本（原始拷贝）的操作，原来的字符串一点都没有改变。
相反，StringBuilder 和 StringBuffer 类是对原字符串本身操作的，可以对字符串进行修改而不产生副本拷贝或者产生少量的副本。

public class Test {
	public static void main(String[ ] args) {
		/**使用 String 进行字符串的拼接*/
		String str8 = "";
		//本质上使用StringBuilder 拼接, 但是每次循环都会生成一个 StringBuilder 对象
		long num1 = Runtime.getRuntime().freeMemory();//获取系统剩余内存空间
		long time1 = System.currentTimeMillis();//获取系统的当前时间
		for (int i = 0; i < 5000; i++) {
			str8 = str8 + i;//相当于产生了 5000 个对象
		}
		long num2 = Runtime.getRuntime().freeMemory();
		long time2 = System.currentTimeMillis();
		System.out.println("String 占用内存 : " + (num1 - num2));
		System.out.println("String 占用时间 : " + (time2 - time1));
		/**使用 StringBuilder 进行字符串的拼接*/
		StringBuilder sb1 = new StringBuilder("");
		long num3 = Runtime.getRuntime().freeMemory();
		long time3 = System.currentTimeMillis();
		for (int i = 0; i < 5000; i++) {
			sb1.append(i);
		}
		long num4 = Runtime.getRuntime().freeMemory();
		long time4 = System.currentTimeMillis();
		System.out.println("StringBuilder 占用内存 : " + (num3 - num4));
		System.out.println("StringBuilder 占用时间 : " + (time4 - time3));
	}
}

2 StringBuffer和StringBuilder

StringBuffer 和 StringBuilder 非常类似，均代表可变的字符序列。这两个类都是抽象类 AbstractStringBuilder 的子类，方法几乎一模一样。
StringBufferJDK1.0 版本提供的类，线程安全，做线程同步检查， 效率较低。
StringBuilderJDK1.5 版本提供的类，线程不安全，不做线程同步检查，因此效率较高。 建议采用该类。

3 String、StringBuffer和StringBuilder区别

• 执行速度

  StringBuilder>StringBuffer>String

  String最慢的原因：String为字符串常量，而StringBuffer和StringBuilder为字符串变量。String一旦创建之后，该对象是不可更改的，而StringBuffer和StringBuilder是可以更改的。

  例如如下代码：

  1 String str="abc";
  2 System.out.println(str);
  3 str=str+"de";
  4 System.out.println(str);
  

  JVM处理上述代码详解：在执行第一行代码时，创建一个String类型的str对象并赋值abc,在执行第三行代码时，重新创建一个String类型的str对象，并把原来的str对象的值和“de”赋值给新的str对象，原来的str对象就会被GC回收。所以Java对String的操作实际上就是一个不断创建对象，并把原来的对象进行回收的过程，所以速度会比较慢。

  而StringBuilder和StringBuffer是变量，对该类型对象的操作就是直接更改该对象的值，而不进行创建对象和回收对象的操作。因而速度回比String快很多。

  特例：String的速度比StringBuilder的速度快很多的情形

  例如如下代码：

  1 String str="abc"+"de";
  2 StringBuilder stringBuilder=new StringBuilder().append("abc").append("de");
  3 System.out.println(str);
  4 System.out.println(stringBuilder.toString());
  

  详解：第一行代码就相当于String str = “abcde”;所以速度会很快。

  而如果写成如下格式：

  1 String str1="abc";
  2 String str2="de";
  3 String str=str1+str2;
  

  JVM就会像上面的第一种情形，不断地创建对象和回收对象，速度会变慢。

• 线程安全

  StringBuffer>StringBuilder

  详解：如果一个StringBuffer对象在字符串缓冲区被多个对象使用时，StringBuffer中很多方法可以带有Synchronized关键字，所以可以保证线程是安全的，但StringBuilder的方法却没有该关键字，所以不能保证该线程是安全的。

• 使用场景：

  • String：适用于少量字符串操作的情形
  • StringBuffer：适用多线程下在字符缓冲区进行大量操作的情形
  • StringBuilder：适用于单线程下在字符缓冲区进行大量操作的情形