String、StringBuffer、StringBuilder之间的区别

①运行/执行速度：

StringBuilder > StringBuffer > String

	String	StringBuffer	StringBuilder
执行速度	3	2	1
	字符串常量	字符串变量	字符串变量
线程安全	安全	安全	不安全
	不可变字符序列	可变字符序列	可变字符序列

String：适用于少量的字符串操作的情况；

StringBuffer：适用于多线程下在字符串缓冲区进行大量操作的情况；

StringBuilder：支持向其中添加新字符[无需创建新对象，append()方法追加]，适用于单线程下在字符串缓冲区进行大量操作的情况；

String不可变原因：

被final修饰。

例：

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

如果运行这段代码会发现先输出“abc”，然后又输出“abcde”，好像是str这个对象被更改了，其实，这只是一种假象罢了，JVM对于这几行代码是这样处理的，首先创建一个String对象str，并把“abc”赋值给str，然后在第三行中，其实JVM又创建了一个新的对象也名为str，然后再把原来的str的值和“de”加起来再赋值给新的str，而原来的str就会被JVM的垃圾回收机制（GC）给回收掉了，所以，str实际上并没有被更改，也就是前面说的String对象一旦创建之后就不可更改了。

所以说，Java中对String对象进行的操作实际上是一个不断创建新的对象并且将旧的对象回收的一个过程，所以执行速度很慢。

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());

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

String str="abcde";是完全一样的，所以会很快，而如果写成下面这种形式

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

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

常见面试题：

String str = new String ("abc") 创建了几个对象？

答：2个。[比较合理]

原因：

这段代码在执行过程中创建了一个String对象；在类加载的过程中，在运行时常量池中创建了一个“abc”对象；

问清面试官是这段代码在执行过程中创建了多少个对象？还是涉及到多少个对象？

下面这段代码的输出结果是什么？

public class test {
	public static void main(String[] args) {
		String a = "hello";
		String b = new String ("hello");
		String c = new String ("hello");
		String d = b.intern();
		System.out.println(a == b);//false
		System.out.println(b == c);//false
		System.out.println(b == d);//false
		System.out.println(a == d);//true
		//===========================================
		String a1 = "hello2";
		String b1 = "hello" + 2;
		System.out.println("第一个结果：" + (a1 == b1));//true
		/* 
		 * 在程序编译期，JVM就将常量字符串的"+"连接优化为连接后的值，拿"hello" + 2来说，
		 * 经编译器优化后在class中就已经是a1。在编译期其字符串常量的值就确定下来，故上面程序最终的结果都为true。
		 * */
		//===========================================
		String a2 = "hello2";
		String b2 = "hello";
		String c2 = b2 +2;
		System.out.println("第二个结果：" + (a2 == c2));//false
		/*
		 * JVM对于字符串引用，由于在字符串的"+"连接中，有字符串引用b2存在，而引用b2的值在程序编译器是无法确认的，
		 * 即"hello" + 2无法被编译器优化，只有在程序运行期来动态分配并将连接后的新地址赋给b2.
		 * 所以结果也就为false。
		 * */
		//===========================================
		String a3 = "hello2";
		final String b3 = "hello";
		String c3 = b3 +2;
		System.out.println("第三个结果：" + (a3 == c3));//true
		/*
		 * 和上面不同的是，b3字符串加了final修饰，对于final修饰的变量，
		 * 它在编译时被解析为常量值的一个本地拷贝存储到自己的常量池中或嵌入到它的字节码流中。
		 * 所以此时的b3 +2和"hello" + 2效果是一样的。
		 * */
		//===========================================
		String a4 = "hello2";
		final String b4 = getHello();
		String c4 = b4 +2;
		System.out.println("第四个结果：" + (a4 == c4));//false
		/*
		 * JVM对于字符串引用b4，它的值在编译期无法确定，虽然将b4用final修饰，但由于其赋值是通过方法调用返回的，
		 * 只有在程序运行期调用方法后，才能确认它的值，
		 * 将方法的返回值和2来动态连接并分配地址为s2，故上面 程序的结果为false。
		 * */
	}

	private static String getHello() {
		return "hello";
	}

}

在String类中，intern()方法是一个本地方法，该方法将会在运行时常量池中查找是否存在内容相同的字符串。若存在，则返回指向该字符串的引用；若不存在，则会将该字符串入池，并返回一个指向该字符串的引用。

图解：

延伸：

Java中堆、栈、常量池的关系及应用

栈：存放基本数据类型和对象的引用，但对象本身不存放在栈中，而是存放在堆中；

堆：存放用new产生的对象/数据；

常量池：存放基本类型常量和字符串常量；

String、StringBuffer、StringBuilder之间的区别

延伸：

猜你喜欢