本文内容：
- 从源码了解String
- String的内部实现
- String.valueOf与Integer.toString的区别
- +运算符的重载
- +运算符的使用
- 在循环中使用+运算符
- Switch对String的支持（Java8）
- 字符串常量池
- 实战解析
- String、StringBuffer、StringBuilder的区别
从源码中了解String
在java中String是一个不可变对象。不可变类有一个缺点，对于每个不同的值，都需要生成一个新的对象。但同时又由于不可变类其域不可变，保证了其线程安全。
String的内部实现
public final class String
implements java.io.Serializable, Comparable<String>, CharSequence {
/** The value is used for character storage. */
private final char value[];
/** Cache the hash code for the string */
private int hash; // Default to 0
//省略String类中的方法...
}
String对字符串的存储经由内部一个final修饰的char数组，String内部提供会造成字符串修改的方法，无一例外的返回一个新的String对象。
String.valueOf与Interger.toString的区别
public static String valueOf(int i) {
return Integer.toString(i);
}
这两者没用任何区别，String.valueOf内部实现还是Integer.toString。其他基本类型同理。
+运算符的重载
+运算符的使用
String str1 = "a";
String str2 = str1 + "b";
以上代码在编译后
L0
LINENUMBER 5 L0
LDC "a" //创建一个内容为"a"的字符串对象，并将其引用存入常量池
ASTORE 1
L1
LINENUMBER 6 L1
NEW java/lang/StringBuilder
DUP
ALOAD 1
INVOKESTATIC java/lang/String.valueOf (Ljava/lang/Object;)Ljava/lang/String;
INVOKESPECIAL java/lang/StringBuilder.<init> (Ljava/lang/String;)V
LDC "b"
INVOKEVIRTUAL java/lang/StringBuilder.append (Ljava/lang/String;)Ljava/lang/StringBuilder;
INVOKEVIRTUAL java/lang/StringBuilder.toString ()Ljava/lang/String;
ASTORE 2
可以看出，当有字符串对象参与+运算，会new出一个StringBuilder对象，接着调用append方法来不断添加字符。在这个过程中只生成了一个对象。
在循环中使用+运算符
String a = "";
for(int i = 0;i < 10;i++) {
a += i;
}
L0
LINENUMBER 5 L0
LDC ""
ASTORE 1
L1
LINENUMBER 6 L1
ICONST_0
ISTORE 2
L2
GOTO L3
L4 //循环体内部的代码
LINENUMBER 7 L4
FRAME APPEND [java/lang/String I]
NEW java/lang/StringBuilder
DUP
ALOAD 1
INVOKESTATIC java/lang/String.valueOf (Ljava/lang/Object;)Ljava/lang/String;
INVOKESPECIAL java/lang/StringBuilder.<init> (Ljava/lang/String;)V
ILOAD 2
INVOKEVIRTUAL java/lang/StringBuilder.append (I)Ljava/lang/StringBuilder;
INVOKEVIRTUAL java/lang/StringBuilder.toString ()Ljava/lang/String;
ASTORE 1
重点看循环体内部的代码，可以看到每次进入循环后多会new一个StringBuilder对象，会造成过多的开销。这也是不推荐在循环中生成字符串使用+号的原因。
Switch对String的支持(java 8)
代码就直接从网上找的
public class switchDemoString {
public static void main(String[] args) {
String str = "world";
switch (str) {
case "hello":
System.out.println("hello");
break;
case "world":
System.out.println("world");
break;
default: break;
}
}
}
对编译后的文件进行反编译
public static void main(String args[]) {
String str = "world";
String s;
switch((s = str).hashCode()) {
case 99162322:
if(s.equals("hello"))
System.out.println("hello");
break;
case 113318802:
if(s.equals("world"))
System.out.println("world");
break;
default: break;
}
}
可以看出swtich本质上还是对int进行支持，但为了避免哈希值碰撞的问题，还会通过equals方法进行一次安全检查
字符串常量池
主要使用方法：
- 直接使用字面量（双引号）声明出的String对象会存入常量池。
- 不是字面量声明的String对象，可以使用String提供的intern方法。该方法会从字符串常量池中检查是否含有相同内容的对象，有则返回，没有则将该字符串对象加入常量池并返回。
字符串常量池中存放的都是对象的引用，在java中对象都存放在堆内存中。
当代码中出现字面量形式创建字符串时，JVM首先会检查字符串常量池中是否含有相同内容的字符串对象，如果有则返回该对象的引用。如果没有则创建新的字符串对象，然后将该对象的引用放入常量池，并返回该对象引用。
接下来分析这样一段代码
String a = "java";
String b = "java";
System.out.println((a == b));
true
声明并赋值变量a时，JVM首先检查常量池中是否有内容为java的对象存在（此处假设没有），那么会创建一个内容为java的对象，并存入常量池，然后返回该对象的引用。接着声明并赋值变量b，JVM在字符串常量池中发现有内容为java的对象存在，于是返回该对象的引用。
注：在JDK7版本中对常量池做了修改，所以JDK6与JDK7的代码运行结果可能有所不同。
- 将字符串常量池从Perm区移到了Java Heap区
实战解析
题目1
以下代码创建了几个对象
String a = new String("a")
该代码创建了两个对象，第一个为存在字符串常量池中的字符串对象，第二个在Java Heap中的String对象
题目2
String a = "hello2";
final String b = "hello";
String d = "hello";
String c = b + 2;
String e = d + 2;
System.out.println((a == c));
System.out.println((a == e));
true
false
当final变量是基本数据类型时，且其变量值在编译期间能确切知道，就会被当做编译时常量(constant variable)。其访问会按照Java语言对常量表达式的规定而做常量折叠。而"hello" + 2，编译成new StringBuilder("hello").append("2")，生产一个新的对象。
题目3
public static void main(String[] args) {
String a = "hello2";
final String b = getHello();
String c = b + 2;
System.out.println((a == c));
}
public static String getHello() {
return "hello";
}
false
由于在编译期间无法确切知道变量b的值，所以编译时没进行常量折叠，最终由于+运算符的重载生成新的String对象c。
题目4
final String a = "a";
final String b = "b";
String c = a + b;
System.out.println((c=="ab"));
true
String、StringBuffer、StringBuilder的区别
最后通过一张表格总结一下String、StringBuffer、StringBuilder的区别。其实很简单，从线程安全、可变性的两个维度做区分即可。
| 可变(mutable) | 不可变(Imutable) | |
|---|---|---|
| 线程安全 | StringBuffer | String |
| 线程不安全 | StringBuilder |
String由于是不可变对象，自然是线程安全的。StringBuffer内部通过synchronized锁实现了线程安全。而StringBuilder是线程不安全的。
