一、String
大家常常会说使用“+”号连接String 字符串比StringBuffer慢，String类对象为不可变对象，一旦你改动了String对象的值，隐性又一次创建了一个新的对象,那接下来我们具体分析一下为什么使用“+”号速度会慢，为什么String
对象是不可变对象：
1、final修饰类、引用变量、基本变量
（1）、假设一个类被final修饰则这个类是不能被继承的。没有子类。
String类是一个final类，仅仅能说明这个类不能被继承也就没有子类。
（2）、假设一个引用变量被final修饰，则引用变量的值是不能改动。而不是说被引用对象
（3）、2中说的引用变量的值的问题，假设大家看了深入理解jvm这本书的话可能对这句话有印象：因为reference类型在java虚拟机规范中仅仅规定了一个指向对象的引用，并没有规定这个引用应该通过何种方式去定位，訪问堆中的对象的详细位置。详细实现因不同的虚拟机而不同，有句柄地址和对象地址两种
（4）、句柄方式实现也就是在javaheap（堆内存）中分配了一个句柄池这个句柄池中存放着详细对象的地址，而引用变量中存放的是句柄池中某个句柄的地址，这样的方式要查找两次地址所以速度有点慢。
（5）、对象地址方式实现，引用变量中存放的就是javaheap(堆内存)中对象的地址。
（6）、假设final修饰的是基本类型的变量则这个变量的值不能能改动，假设final修饰的是引用变量则这个引用变量的值不能改变也就是4,5 中所说的句柄的地址或对象的地址不能改变而他们所引用的对象的内容是能够改变的。
2、String 类使用"+" 来连接字符的整个过程描写叙述
（1）、大家常常会说不要使用"+" 来连接字符串这样效率不高（相对于 StringBuilder、StringBuffer）那为什么那，看看以下：
String str= "a"; str=str+"b"; str=str+"c";
实现过程：
String str= "a";创建一个String对象，str 引用到这个对象。
在创建一个长度为str.length() 的StringBuffer 对象
StringBuffer strb=new StringBuffer（str）;
调用StringBuffer的append（）方法将”b“加入进去,strb.append（"b"）;
调用strb 的toString()方法创建String对象。之前对象失去引用而str又一次引用到这个新对 象。
相同在创建StringBuffer对象 调用append（）方法将”c“加入进去,调用toString() 方法 创建String对象
再将strb引用到 新创建的String对象。之前对象失去引用之后存放在常量池中。等待垃圾回收。
看到上面使用“+”连接字符串的过程。就明确了为什么要使用StringBuffer 来连接字符而不是使用String 的“+”来连接。
（2)、知道了使用”+“连接的过程，我们再来看看上面提到的使用”+“号为什么会创建新的对象，也就是说String对象是不可变对象。
这里有个概念就是对象不可变。而String 的对象就是一个不可变对象。那什么叫对象不可变那： 当一个对象创建完毕之后，不能再改动他的状态，不能改变状态是指不能改变对象内的成员变量。包含基本数据类型的值不能改变。引用类型的变量不能指向其它对象。引用类型指向的对象的状态也不能改变。
对象一旦创建就没办法改动期全部属性，所以要改动不可变对象的值就仅仅能又一次创建对象。
3、String 对象不可变 源代码分析
(1)、上面说了String 对象为不可变对象。为什么String 对象不可变，String对象的状态不能改变，接下来我们看看String 类的源代码：
jdk 1.7 的源代码
public final class String
implements java.io.Serializable, Comparable<String>, CharSequence {
/** The value is used for character storage. */
// 数组的被final修饰，所以数据引用变量的值不能变
private final char value[];
/** Cache the hash code for the string */
// 缓存String对象的哈希值
private int hash; // Default to 0
String 类中仅仅有两个成员变量一个是value 一个是hash，这个hash和我们讨论的问题没关系，通过注解我们知道他是缓存String对象的hash值
value 是一个被final修饰的数组对象，所以仅仅能说他不能再引用到其它对象而不能说明他所引用的对象的内容不能改变。
但我们在往下看源代码就会发现String 类没有给这两个成员变量提供不论什么的方法所以我们也没办法改动所引用对象的内容，所以String 对象一旦被创建，这个变量被初始化后就不能再改动了，所以说String 对象是不可变对象。
(2)、String 对象不是提供了像replace()等方法能够改动内容的吗，事实上这种方法内部创建了一个新String 对象 在把这个新对象又一次赋值给了引用变量。看看源代码你就相信了他是在内部重现创建了String 对象
public String replace(char oldChar, char newChar) {
if (oldChar != newChar) {
int len = value.length;
int i = -1;
char[] val = value; /* avoid getfield opcode */
while (++i < len) {
if (val[i] == oldChar) {
break;
}
}
if (i < len) {
char buf[] = new char[len];
for (int j = 0; j < i; j++) {
buf[j] = val[j];
}
while (i < len) {
char c = val[i];
buf[i] = (c == oldChar) ?
newChar : c;
i++;
}
// 创建新对象
return new String(buf, true);
}
}
return this;
}
总结：
1、String 类是一个final 修饰的类所以这个类是不能继承的。也就没有子类。
2、String 类的成员变量都是final类型的而且没有提供不论什么方法能够来改动引用变量所引用的对象的内容，所以一旦这个对象被创建而且成员变量初始化后这个对象就不能再改变了，所以说String 对象是一个不可变对象。
3、使用“+”连接字符串的过程产生了非常多String 对象和StringBuffer 对象所以效率相比直接使用StringBuffer 对象的append（） 方法来连接字符效率低非常多。
4、引用变量是存在java虚拟机栈内存中的。它里面存放的不是对象。而是对象的地址或句柄地址。
5、对象是存在java heap(堆内存)中的值
6、引用变量的值改变指的是栈内存中的这个引用变量的值的改变是。对象地址的改变或句柄地址的改变。而对象的改变指的是存放在Java heap（堆内存）中的对象内容的改变和引用变量的地址和句柄没有关系。
二、StringBuffer
我们在上面说String对象是不可变的，而StringBuffer 对象是可变的，大家都说在能大体了解字符串的长度的情况下创建StringBuffer对象时 指定其容量，在上面的string中我们也知道使用“+”号的时候我们也是调用了append方法。
1、 为什么StringBuffer 对象可变， 为什么要尽量指定初始大小。append方法是怎么实现的 以下我们来看看这几个为什么
2、String 对象不可变是由于成员变量都被final修饰而且没有提供不论什么訪问被引用对象的方法所以不能改变。而StringBuffer是怎么样的那我们能够去看看源代码：
（1）、public final class StringBuffer extends AbstractStringBuilder
implements java.io.Serializable, CharSequence
{
/** use serialVersionUID from JDK 1.0.2 for interoperability */
static final long serialVersionUID = 3388685877147921107L;
/**
* Constructs a string buffer with no characters in it and an
* initial capacity of 16 characters.
*/
// 默觉得16个字符
public StringBuffer() {
super(16);
}
/**
* Constructs a string buffer with no characters in it and
* the specified initial capacity.
*
* @param capacity the initial capacity.
* @exception NegativeArraySizeException if the <code>capacity</code>
* argument is less than <code>0</code>.
*/
public StringBuffer(int capacity) {
super(capacity);
}
/**
* Constructs a string buffer initialized to the contents of the
* specified string. The initial capacity of the string buffer is
* <code>16</code> plus the length of the string argument.
*
* @param str the initial contents of the buffer.
* @exception NullPointerException if <code>str</code> is <code>null</code>
*/
public StringBuffer(String str) {
super(str.length() + 16);
append(str);
}
3、StringBuffer 类继承自AbstractStringBuilder 那在看看AbstractStringBuilder的源代码
abstract class AbstractStringBuilder implements Appendable, CharSequence {
/**
* The value is used for character storage.
*/
// 这里我们看到，这个数组没有被final 修饰。所以引用变量的值能够改变，
//能够引用到其它数组对象
char[] value;
/**
* The count is the number of characters used.
*/
// 记录字符的个数
int count;
/**
* This no-arg constructor is necessary for serialization of subclasses.
*/
AbstractStringBuilder() {
}
/**
* Creates an AbstractStringBuilder of the specified capacity.
*/
AbstractStringBuilder(int capacity) {
// 构造函数，创建数组对象
value = new char[capacity];
}
/**
* Returns the length (character count).
*
* @return the length of the sequence of characters currently
* represented by this object
*/
public int length() {
return count;
}
所以StringBuffer对象是可变的
3、假设知道字符串的长度则创建对象的时候尽量指定大小
（1）、在上面的源码中我们看到StringBuffer 的构造函数默认创建的大小为16个字符。
（2）、假设我们在创建对象的时候指定了大小则创建指定容量大小的数组对象
// 调用父类的构造函数，创建数组对象
public StringBuffer(int capacity) {
super(capacity);
}
/**
* Creates an AbstractStringBuilder of the specified capacity.
*/
AbstractStringBuilder(int capacity) {
//依照指定容量创建字符数组
value = new char[capacity];
}
（3）、假设在创建对象时构造函数的參数为字符串则 创建的数组的长度为字符长度+16字符
这种长度，然后再将这个字符串加入到字符数组中，加入的时候会推断原来字符数组中的个数加上这个字符串 的长度是否大于这个字符数组的大小假设大于则进行扩容假设没有则加入，源代码例如以下：
public StringBuffer(String str) {super(str.length() + 16);
append(str);
}
append 出如今了这里刚好一起来看看 append方法的实现
4、事实上append方法就做两件事，假设 count （字符数组中已有字符的个数）加加入的字符串的长度小于 value.length 也就是小于字符数组的容量则直接将要加入的字符复制到数组在改动count就能够了。
5、假设cout和加入的字符串的长度的和大于value.length 则会创建一个新字符数组 再将原有的字符复制到新字符数组。再将要加入的字符加入到字符数组中。再改变conut(字符数组中字符的个数)
整个加入过程的源代码例如以下：
public synchronized StringBuffer append(Object obj) {
super.append(String.valueOf(obj));
return this;
}
public AbstractStringBuilder append(Object obj) {
return append(String.valueOf(obj));
}
这种方法中调用了ensureCapacityInternal （）方法推断count(字符数组原有的字符个数)+str.length() 的长度是否大于value容量
/**
* This method has the same contract as ensureCapacity, but is
* never synchronized.
*/
private void ensureCapacityInternal(int minimumCapacity) {
// overflow-conscious code
if (minimumCapacity - value.length > 0)
expandCapacity(minimumCapacity);
}
假设count+str.length() 长度大于value的容量 则调用方法进行扩容
/**
* This implements the expansion semantics of ensureCapacity with no
* size check or synchronization.
*/
void expandCapacity(int minimumCapacity) {
int newCapacity = value.length * 2 + 2;
if (newCapacity - minimumCapacity < 0)
newCapacity = minimumCapacity;
if (newCapacity < 0) {
if (minimumCapacity < 0) // overflow
throw new OutOfMemoryError();
newCapacity = Integer.MAX_VALUE;
}
value = Arrays.copyOf(value, newCapacity);
}
Arrays.copyOf（value,newCapacity） 复制指定的数组，截取或用 null 字符填充（如有必要），以使副本具有指定的长度。
上面的getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin) 将字符从此字符串拷贝到目标字符数组dst中，第一个參数 第二个參数截取要加入字符串的长度，第三个为目标字符数组第四个为字符串要加入到数组的開始位置
到这里数组的赋值都结束了。改动count的值，整个append也就结束了。
总结：
1、StringBuffer 类被final 修饰所以不能继承没有子类
2、StringBuffer 对象是可变对象，由于父类的 value [] char 没有被final修饰所以能够进行引用的改变，并且还提供了方法能够改动被引用对象的内容即改动了数组内容。
3、在使用StringBuffer对象的时候尽量指定大小这样会降低扩容的次数，也就是会降低创建字符数组对象的次数和数据复制的次数，当然效率也会提升。
StringBuilder 和StringBuffer 非常像仅仅是不是线程安全的其它的非常像所以不罗嗦了。