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);