总是听大神说String是不可变量，StringBuilder是线程不安全，StringBuffer是线程安全，嘚吧嘚一大堆记不住了。。。那有想过为什么吗？今天来读读源码解析一下。

StringBuilder

//定义一个StringBuilder对象
StringBuilder strBuilder=new StringBuilder("a");
//用两个最常用的方法
strBuilder.append("b").toString();

解析，定义StringBuilder对象时，进入源码时间

public StringBuilder(String str) {
    //调用父类嘛 稍后给出关系图
    super(str.length() + 16);
    append(str);
}

//父类构造函数在这
AbstractStringBuilder(int capacity) {
        value = new char[capacity];
}
//value声明在这
char[] value;

由源码可以看出，==定义一个StringBuilder对象即定义了一个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();
        //数组扩容，扩长度*2+2
        ensureCapacityInternal(count + len);
        //字符复制到数组中
        //该方法的作用是将当前字符串从start到end-1位置上的字符复制到字符数组c中，并从c的offset处开始存放
        str.getChars(0, len, value, count);
        //count为数组实际长度
        count += len;
        return this;
    }

最后一个toString方法，综上很明显，StringBuilder.toString()就是将数组转成String,我们看看源码

public String toString() {
    return new String(value, 0, count);
}

的确是将数组转成String输出就好了，但是这个String构造方法没看懂啊。。。
接下来我们看看String,对了，StringBuffer没看呢。来，我们先看一下StringBuffer
构造函数StringBuilder完全一致
关键append()方法

public synchronized StringBuffer append(String str) {
        super.append(str);
        return this;
}
public synchronized String toString() {
        return new String(value, 0, count);
}

对咯，关键就多了一个==synchronized==，所以实现线程同步。

String

此时涉及到一个常量池的概念
String.intern();将数据加入常量池

Integer int_1 = 40;
Integer int_2 = Integer.valueOf(40);
Integer int_3 = new Integer(40);

public static Integer valueOf(int i) {
        assert IntegerCache.high >= 127;
        if (i >= IntegerCache.low && i <= IntegerCache.high)
            return IntegerCache.cache[i + (-IntegerCache.low)];
        return new Integer(i);
    }
private static class IntegerCache {
        static final int low = -128;
        static final int high;
        static final Integer cache[];

        static {
            // high value may be configured by property
            int h = 127;
            String integerCacheHighPropValue =
                sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high");
            if (integerCacheHighPropValue != null) {
                int i = parseInt(integerCacheHighPropValue);
                i = Math.max(i, 127);
                // Maximum array size is Integer.MAX_VALUE
                h = Math.min(i, Integer.MAX_VALUE - (-low) -1);
            }
            high = h;

            cache = new Integer[(high - low) + 1];
            int j = low;
            for(int k = 0; k < cache.length; k++)
                cache[k] = new Integer(j++);
        }

        private IntegerCache() {}
    }