一、常量池（Constant pool）
Java代码被编译成class文件时，会生成一个常量池（Constant pool）的数据结构，用以保存字面常量和符号引用（类名、方法名、接口名和字段名等）。
public class test { public static void main(String[] args) { String test = "test"; } }
很简单的一段代码，通过命令 javap -verbose 查看class文件中 Constant pool 实现：
通过反编译出来的字节码可以看出字符串 "test" 在常量池中的定义方式：
二、字符串初始化
字符串可以通过两种方式进行初始化：字面常量和String对象。
字面常量
public class test { public static void main(String[] args) { String a = "java"; String b = "java"; String c = "ja" + "va"; } }
通过 "javap -c" 命令查看字节码指令实现
其中ldc指令将int、float和String类型的常量值从常量池中推送到栈顶，所以a和b都指向常量池的"java"字符串。
通过指令实现可以发现：变量a、b和c都指向常量池的 "java" 字符串，表达式 "ja" + "va" 在编译期间会把结果值"java"直接赋值给c。
String 对象
public class test { public static void main(String[] args) { String a = "java"; String c = new String("java"); } }
这种情况下，a == c 成立么？字节码实现如下：
其中3 ~ 9行指令对应代码 String c = new String("java"); 实现：
A.第3行new指令，在Java堆上为String对象申请内存；
B.第7行ldc指令，尝试从常量池中获取"Java"字符串，如果常量池不存在，则在常量池中新建“Java”字符串，并返回。
C.第9行invokespecial指令，调用构造方法，初始化String对象。
其中String对象中使用char数组存储字符串，变量a指向常量池的"java"字符串，变量c指向Java堆的String对象，且该对象的char数组指向常量池的"java"字符串，所以很显然 a != c。
如下图所示
通过 "字面量 + String对象" 进行赋值会发生什么？
public class test { public static void main(String[] args) { String a = "hello "; String b = "world"; String c = a + b; String d = "hello world"; } }
这种情况下，c == d成立么？字节码实现如下：
String c = a + b; 实现：A.第6行new指令，在Java堆上为StringBuilder对象申请内存；
B.第10行invokespecial指令，调用构造方法，初始化StringBuilder对象；
C.第14、18行invokespecial指令，调用append方法，添加a和b字符串；
D.第21行invokespecial指令，调用toString方法，生成String对象。
public class test { public static void main(String[] args) { final String a = "hello "; final String b = "world"; String c = a + b; String d = "hello world"; } }
指令实现如下：
三、String
String：字符串常量，字符串长度不可变。Java中String是immutable（不可变的）。
String类的包含如下定义：
/** The value is used for character storage. */ private final char value[]; /** The offset is the first index of the storage that is used. */ private final int offset; /** The count is the number of characters in the String. */ private final int count;
用于存放字符的数组被声明为final的，因此只能赋值一次，不可再更改。
示例：
public class test { public static void main(String[] args) { String str="abc"; System.out.println(str); str=str+"de"; System.out.println(str); } }
这段代码，先输出abc，后输出abcde。感觉好像str这个对象被更改了，其实，这只是一种假象罢了。
JVM对于这几行代码是这样处理的：
首先创建一个String对象str，并把"abc"赋值给str，然后再第五行中，其实JVM又创建了一个新的对象也叫str，然后再把原来的str的值和"de"加起来赋值给新的str，而原来的str就会被JVM的垃圾回收机制（GC）给回收掉了。
所以，str实际上并没有任何更改，也就是说前面的String对象一旦创建之后就不可更改了。
所以，Java中对String对象进行的操作实际上是一个不断创建新的对象并且将旧的对象回收的一个过程，所以执行速度很慢。
四、StringBuffer（JDK 1.0）
StringBuffer：字符串变量（Synchronized，即线程安全）。如果要频繁对字符串内容进行修改，出于效率考虑最好使用StringBuffer，如果想转成String类型，可以调用StringBuffer的toString()方法。
Java.lang.StringBuffer线程安全的可变字符序列。在任意时间点上它都包含某种特定的字符序列，但通过某些方法调用可以改变该序列的长度和内容。可将字符串缓冲区安全地用于多个线程。
和 String 类不同的是，StringBuffer 类的对象能够被多次的修改，并且不产生新的未使用对象。
public class test { public static void main(String[] args) { StringBuffer sb = new StringBuffer("Blog: "); sb.append("www"); sb.append(".cnblogs"); sb.append(".com"); sb.append("/lixiansheng"); System.out.println(sb); } }
五、StringBuilder（JDK 5.0）
StringBuilder：字符串变量（非线程安全）。在内部，StringBuilder对象被当作是一个包含字符序列的变长数组。
java.lang.StringBuilder是一个可变的字符序列，是JDK5.0新增的。此类提供一个与 StringBuffer 兼容的 API，但不保证同步。该类被设计用作 StringBuffer 的一个简易替换，用在字符串缓冲区被单个线程使用的时候（这种情况很普遍）。
其构造方法如下：
| 构造方法 | 描述 |
| StringBuilder() | 创建一个容量为16的StringBuilder对象（16个空元素） |
| StringBuilder(CharSequence cs) | 创建一个包含cs的StringBuilder对象，末尾附加16个空元素 |
| StringBuilder(int initCapacity) | 创建一个容量为initCapacity的StringBuilder对象 |
| StringBuilder(String s) | 创建一个包含s的StringBuilder对象，末尾附加16个空元素 |
在大部分情况下，StringBuilder > StringBuffer。这主要是由于前者不需要考虑线程安全。
六、三者区别
String 类型和StringBuffer的主要性能区别：
String是不可变的对象, 因此在每次对String 类型进行改变的时候，都会生成一个新的 String 对象，然后将指针指向新的 String 对象，所以经常改变内容的字符串最好不要用 String ，因为每次生成对象都会对系统性能产生影响，特别当内存中无引用对象多了以后， JVM 的 GC 就会开始工作，性能就会降低。
使用 StringBuffer 类时，每次都会对 StringBuffer 对象本身进行操作，而不是生成新的对象并改变对象引用。所以多数情况下推荐使用 StringBuffer ，特别是字符串对象经常改变的情况下。
在某些特别情况下， String 对象的字符串拼接其实是被 Java Compiler 编译成了 StringBuffer 对象的拼接，所以这些时候 String 对象的速度并不会比 StringBuffer 对象慢，例如：
String s1 = “This is only a” + “ simple” + “ test”; StringBuffer Sb = new StringBuilder(“This is only a”).append(“ simple”).append(“ test”);
生成 String s1对象的速度并不比 StringBuffer慢。其实在Java Compiler里，自动做了如下转换：
Java Compiler直接把上述第一条语句编译为：
String s1 = “This is only a simple test”;
所以速度很快。但要注意的是，如果拼接的字符串来自另外的String对象的话，Java Compiler就不会自动转换了，速度也就没那么快了，例如：
String s2 = “This is only a”; String s3 = “ simple”; String s4 = “ test”; String s1 = s2 + s3 + s4;
这时候，Java Compiler会规规矩矩的按照原来的方式去做，String的concatenation（即+）操作利用了StringBuilder（或StringBuffer）的append方法实现，此时，对于上述情况，若s2，s3，s4采用String定义，拼接时需要额外创建一个StringBuffer（或StringBuilder），之后将StringBuffer转换为String；若采用StringBuffer（或StringBuilder），则不需额外创建StringBuffer。
七、使用策略
（1）基本原则：如果要操作少量的数据，用String ；单线程操作大量数据，用StringBuilder ；多线程操作大量数据，用StringBuffer。
（2）不要使用String类的"+"来进行频繁的拼接，因为那样的性能极差的，应该使用StringBuffer或StringBuilder类，这在Java的优化上是一条比较重要的原则。例如：
（3）为了获得更好的性能，在构造 StringBuffer 或 StringBuilder 时应尽可能指定它们的容量。当然，如果你操作的字符串长度（length）不超过 16 个字符就不用了，当不指定容量（capacity）时默认构造一个容量为16的对象。不指定容量会显著降低性能。
（4）StringBuilder一般使用在方法内部来完成类似"+"功能，因为是线程不安全的，所以用完以后可以丢弃。StringBuffer主要用在全局变量中。
（5）相同情况下使用 StringBuilder 相比使用 StringBuffer 仅能获得 10%~15% 左右的性能提升，但却要冒多线程不安全的风险。而在现实的模块化编程中，负责某一模块的程序员不一定能清晰地判断该模块是否会放入多线程的环境中运行，因此：除非确定系统的瓶颈是在 StringBuffer 上，并且确定你的模块不会运行在多线程模式下，才可以采用StringBuilder；否则还是用StringBuffer。