源代码是万物之源。——黑客帝国
先看下String的源代码：
public final class String
implements java.io.Serializable, Comparable<String>, CharSequence {
/** The value is used for character storage. */
private final char value[];//char数组也就是String的值
/** Cache the hash code for the string */
private int hash; // Default to 0
/** use serialVersionUID from JDK 1.0.2 for interoperability */
private static final long serialVersionUID = -6849794470754667710L;
}
所以其实String就是一个char[]。唯一需要注意的点应该就是final修饰符，也就意味着value是常量不可更改。这个和之前object-c中的设计很像，但不知道在这里是不是为了线程安全。从后面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;
}
/* avoid getfield opcode */
关于这个注释，查了一下。得到的答案是将变量复制到局部变量中，这样在下面的循环操作中就可以不用反复的从堆中取数据了。（栈中的访问速度更快，那是不是操作次数比较多的变量都可以用这种方法去增加速度呢？）
但是在这个文件夹中我没有找到+号的重载函数（当然java本身不允许重载运算符），经过百度发现这个加号的重载是在编译阶段实现的。
//以下两者是等价的
s = i + ""
s = String.valueOf(i);
//以下两者也是等价的
= "abc" + i;
= new StringBuilder("abc").append(i).toString();
再看下StringBuilder的源代码：
/**
* The value is used for character storage.
*/
char[] value;
/**
* The count is the number of characters used.
*/
int count;
/**
* This no-arg constructor is necessary for serialization of subclasses.
*/
AbstractStringBuilder() {
}
可变的char[]，以及长度。
/**
* Constructs a string builder with no characters in it and an
* initial capacity of 16 characters.
*/
public StringBuilder() {
super(16);
}
这里对于为什么要在初始化的时候预留一个16个大小的数组还不太明白。
public AbstractStringBuilder append(String str) {
if (str == null)
return appendNull();
int len = str.length();
ensureCapacityInternal(count + len);
str.getChars(0, len, value, count);
count += len;
return this;
}
public void getChars(int srcBegin, int srcEnd, char dst[], int dstBegin) {
if (srcBegin < 0) {
throw new StringIndexOutOfBoundsException(srcBegin);
}
if (srcEnd > value.length) {
throw new StringIndexOutOfBoundsException(srcEnd);
}
if (srcBegin > srcEnd) {
throw new StringIndexOutOfBoundsException(srcEnd - srcBegin);
}
System.arraycopy(value, srcBegin, dst, dstBegin, srcEnd - srcBegin);
}
这里就不贴所有的代码了，主要就是如果是对象则会调用string的valueof()转成String，如果是String就是调用getchars()，再对char[]添加赋值。
所以其性能差异即在少做了一步string和StringBuilder的转化。
而String s = "abc";这样的操作会在常量字符区生成一个"abc"常量，也会增加开销。
java，StringBuilder预留16位
public AbstractStringBuilder append(String str) {
if (str == null)
return appendNull();
int len = str.length();
ensureCapacityInternal(count + len);//在添加String时确定内部空间足够
str.getChars(0, len, value, count);
count += len;
return this;
}
private void ensureCapacityInternal(int minimumCapacity) {
// overflow-conscious code
if (minimumCapacity - value.length > 0)//如果超过了预留的空间大小，则选择扩容。
expandCapacity(minimumCapacity);
}
void expandCapacity(int minimumCapacity) {
int newCapacity = value.length * 2 + 2;//将其扩充为2倍的大小加2；
if (newCapacity - minimumCapacity < 0)
newCapacity = minimumCapacity;//如果还不够大小，则将空间扩充为两个字符串大小之和
if (newCapacity < 0) {
if (minimumCapacity < 0) // overflow
throw new OutOfMemoryError();
newCapacity = Integer.MAX_VALUE;//如果字符串之和小于int最大值，但是两倍太大会导致overflow，则将其设置为int最大值
}
value = Arrays.copyOf(value, newCapacity);
}
这样做最大的好处应该是在扩展小的字符串时不用每次都申请空间，只有在原有空间已满的时候再进行扩容，典型的空间换时间。
