String、StringBuilder、StringBuffer区别

String:

概念：大哥，出生于JDK1.0时代，是不可变字符序列

String在Java中是一个最终类，而非基本数据类型。String是值传入，不是引用传入。

由于是不可变字符序列，所以每次对String类型进行改变的时候其实都等同于生成了一个新的String对象，所以如果经常改变内容的字符串最好不要用String,因为每次生成对象都会系统性能产生影响，特别是当内存中无引用对象多了以后，JVM的GC就会开始工作，那速度就很慢了！！！

StringBuffer：

概念：二哥，出生于JDK1.0时代，是线程安全的可变字符序列

线程安全性：StringBuffer允许多线程进行字符操作，因为在源代码中StringBuffer的很多方法都被关键字synchronized修饰，加了锁，故线程安全性较高，但效率较低

由于是可变字符序列，所以每次结果都对StringBuffer对象本身进行操作，而不是生成新的对象，在改变对象引用。

StringBuffer的修改：它的主要操作是append()和insert()方法，通过append()方法将字符添加到缓冲区的末端，insert()方法在指定的点添加字符。

StringBuilder：

概念：小弟，出生于JDK1.5时代，是非线程安全的可变字符序列。

此类提供一个与StringBuffer兼容的API，但不保证同步。被设计用作StringBuffer的一个简易替换，用在字符串缓冲区被单个线程使用的时候（这种情况很普遍）。

建议优先使用该类，因为在大多数实现中，它比StringBuffer要快，两者的方法基本相同。

线程安全性：效率较高，但安全性较低，可能出现多线程并发问题

注：JVM运行程序主要的时间消耗是在创建对象和回收对象上

效率比较：

String的修改原理：对String的修改其实是new了一个StringBuilder对象并调用append()方法，然后调用toString()返回一个新的String

StringBuffer:它是在StringBuilder的基础上加锁，加锁是一个重量级操作，需要调用操作系统内核来实现，比较耗时

故一般情况：String<StringBuffer<StringBuilder;除了以下情况：

String s1="This is only a"+"simple"+"test";

这段代码中因为三个字符串都是字面量常量，在JVM底层会优化处理将其拼接成一个字符串放在常量池里，创建一个String对象s1存储“This is only a simple test"字符串，效率很高;

String s1="This is only a";
String s2="simple";
String s3="test";
String s4=s1+s2+s3;

这段代码产生三个对象，但只有一个String对象

由于编译器的优化，最终代码为通过StringBuilder完成：

 StringBuilder builder = new StringBuilder();
 builder.append(s1); 
 builder.append(s2);
 builder.append(s3);
 String s4 = builder.toString();

我们先看看StringBuilder的构造器

 public StringBuilder() {
     super(16);
 }

AbstractStringBuilder(int capacity) {
        value = new char[capacity];
}

可见，分配了一个16自己长度的char数组

 我们看看append的整个过程(注意，源代码我从各个类进行了整合，他们实际上不在一个类里面的)

public StringBuilder append(String str) {    
    super.append(str);    
    return this;  
} 
public AbstractStringBuilder append(String str) {   
     if (str == null)     
         str = "null";   
     int len = str.length();   
     if (len == 0)     
         return this;  
     int newCount = count + len;    
    if (newCount > value.length)     
         expandCapacity(newCount);   
    str.getChars(0, len, value, count);    
    count = newCount;   
    return this;  
}  
public void getChars(int srcBegin, int srcEnd, char dst[], int dstBegin) {    
    if (srcBegin < 0) {     
         throw new StringIndexOutOfBoundsException(srcBegin);   
     }   
    if (srcEnd > count) {     
         throw new StringIndexOutOfBoundsException(srcEnd);    
    }    
    if (srcBegin > srcEnd) {      
        throw new StringIndexOutOfBoundsException(srcEnd - srcBegin);    
    }    
    System.arraycopy(value, offset + srcBegin, dst, dstBegin, srcEnd srcBegin);  
}
                        

 

可见，我们的代码不会超过16个，所以不会出现扩展value的情况。
而append里面使用了arraycopy的复制方式，也没有产生新的对象。

 

最后，我们再看StringBuilder的 toString()方法：

public String toString() {
    // Create a copy, don't share the array
    return new String(value, 0, count);
}

这里通过前面的数组生成了一个新的String。

大家注意那个默认的16容量，如果题目出现了总长度超过16，则会出现如下的再次分配的情况

void expandCapacity(int minimumCapacity) {
    int newCapacity = (value.length + 1) * 2;
    if (newCapacity < 0) {
        newCapacity = Integer.MAX_VALUE;   
    } else if (minimumCapacity > newCapacity) {
        newCapacity = minimumCapacity;    
    }    
    value = Arrays.copyOf(value, newCapacity);  
}  
public static char[] copyOf(char[] original, int newLength) {
    char[] copy = new char[newLength];
    System.arraycopy(original, 0, copy, 0, Math.min(original.length, newLength));
    return copy;  

可见，expand容量时，增加为当前(长度+1)*2。
注意这里用了Arrays的方法，注意不是前面的 System.arraycopy方法哦。这里产生了一个新的copy的char数组，长度为新的长度

总结：三个对象分别为
1 StringBuilder
2 new char[capacity]
3 new String(value,0,count);