Java中的String类是用来创建不可变的字符串,每次追加字符串都要创建新的String对象,而Java中对象的每次创建都需要开辟内存空间来存储,这无疑是一种低效率而又耗内存的方式。StringBuffer类、StringBuilder类都能创建可变的字符串,每次追加字符串不再有创建新字符串对象的问题了,另外,二者在线程安全方面还存在差异,通过StringBuffer类源码分析来一探究竟。
目录
源码分析
1、构造方法
2、操作字符串的API
3、重写的Object方法
源码分析
1、构造方法
/**
* StringBuffer的父类为AbstractStringBuilder,重写了许多父类的方法。
**/
public final class StringBuffer extends AbstractStringBuilder
implements java.io.Serializable, CharSequence{
/**
* StringBuffer构造器的三种形式 均是通过super()调用父类构造器定义的,本质是初始化一个字符数组:
* char[] value = new char[capacity]; 默认容量大小为16。
**/
// 无参
public StringBuffer() {super(16);}
// 传入字符串
public StringBuffer(String str) {
super(str.length() + 16);
append(str); //append()是个同步方法,看下面的操作字符串的API源码分析
}
// 传入字符序列
public StringBuffer(CharSequence seq) {
this(seq.length() + 16);
append(seq);
}
public StringBuffer(int capacity) {super(capacity);}
}
小结一下:
- StringBuffer类的构造器,本质上也是通过维护一个字符数组value[]来存储字符的,这里可以把该字符数组理解为是一个字符串缓存区,默认缓冲区容量大小为16;
2、操作字符串的API
说明:字符串的添加,删除,替换,查找,截取,替换,反转等操作。
public final class StringBuffer extends AbstractStringBuilder
implements java.io.Serializable, CharSequence{
private transient char[] toStringCache; // 看样子是没啥作用,可能会当作一种缓存使用
/**
* append()是一个同步方法,线程安全,作用是将内容追加到StringBuffer,可追加的类型有:
* boolean、char、int、long、float、double、char[]、CharSequence、Object、String、StringBuffer、AbstractStringBuilder等,
* StringBuffer类几乎都是重写父类ASB中的append(),而父类ASB几乎是重写Appendable接口中的append()方法。
* 然而无论追加的内容是哪种类型,父类在实现逻辑后返回的都是this当前对象,没有新的对象产生。
**/
@Override
public synchronized StringBuffer append(xxx x) { //xxx表示追加的类型
toStringCache = null;
super.append(x);
return this;
}
/**
* insert()也是一个含有线程同步的方法,作用也是将内容追加到StringBuffer,
* 它也是几乎重写了父类ASB中的insert(),父类具体实现了业务逻辑,insert()存在线程安全与非安全的两类方法,参数有所区别
* 可追加的类型有:String、char[]、char等等。
**/
@Override
public synchronized StringBuffer insert(int offset, xxx x) {
toStringCache = null;
super.insert(offset, x);
return this;
}
/**
* 非线程安全的insert()可追加的类型有:boolean、int、long、float、double、CharSequence等
**/
@Override
public StringBuffer insert(int offset, xxx x) {
// Note, synchronization achieved via invocation of StringBuffer insert(int, String)
// after conversion of i to String by super class method
// Ditto for toStringCache clearing
super.insert(offset, x);
return this;
}
/**
* deleteCharAt()删除单个字符、delete()删除字符串,均为同步方法
**/
@Override
public synchronized StringBuffer deleteCharAt(int index) {
toStringCache = null;
super.deleteCharAt(index);
return this;
}
@Override
public synchronized StringBuffer delete(int start, int end) {
toStringCache = null;
super.delete(start, end);
return this;
}
/**
* 截取字符串 或 字符序列,均为同步方法,均会产生新的String对象
**/
@Override
public synchronized String substring(int start) {
return substring(start, count);
}
@Override
public synchronized String substring(int start, int end) {
return super.substring(start, end); // 本质为父类ABS的:return new String(value, start, end - start);
}
@Override
public synchronized CharSequence subSequence(int start, int end) {
return super.substring(start, end);
}
/**
* 替换字符串,为同步方法,但不会产生新的String对象
**/
@Override
public synchronized StringBuffer replace(int start, int end, String str) {
toStringCache = null;
super.replace(start, end, str); //父类ABS:return this;
return this;
}
/**
* 从前往后查找字符串indexOf(),存在同步方法和非同步方法,底层调用String.indexOf()
**/
@Override
public int indexOf(String str) {
// Note, synchronization achieved via invocations of other StringBuffer methods
return super.indexOf(str);
}
@Override
public synchronized int indexOf(String str, int fromIndex) {
return super.indexOf(str, fromIndex);
}
/**
* 从后往前查找字符串lastIndexOf(),同步方法,底层调用String.lastIndexOf()
**/
@Override
public int lastIndexOf(String str) {
// Note, synchronization achieved via invocations of other StringBuffer methods
return lastIndexOf(str, count);
}
@Override
public synchronized int lastIndexOf(String str, int fromIndex) {
return super.lastIndexOf(str, fromIndex);
}
/**
* 字符串反转,同步方法,不会产生新的String对象
**/
@Override
public synchronized StringBuffer reverse() {
toStringCache = null;
super.reverse(); // 父类ABS:return this;
return this;
}
}
小结一下:
- StringBuffer类绝大多数的方法都是同步的,因此使用StringBuffer操作字符串是线程安全的;
- 之所以说StringBuffer类创建的是可变字符串,是通过append方法或insert方法实现的。追加的类型有很多种,追加的逻辑都是在其父类ABS内实现,而且父类返回的this对象指的就是字符数组vaule[],而构造器里维护的也是父类的字符数组vaule[],所以API操作的是一个对象,当然不会产生新的String对象。
3、重写的Object方法
说明:StringBuffer类没有重写equals()/hashCode() ,因此用equals()比较两个StringBuffer对象时,比较的是对象引用(即对象在内存中的地址)而非对象的内容。未重写equals(),和==没有区别。
public final class StringBuffer extends AbstractStringBuilder
implements java.io.Serializable, CharSequence{
// 重写了toString(),并未重写equals()/hashCode()
@Override
public synchronized String toString() {
if (toStringCache == null) {
toStringCache = Arrays.copyOfRange(value, 0, count);
}
return new String(toStringCache, true);
}
}
StringBuffer类的源码分析到此,与String类相比最大的不同在于以下几点:
- StringBuffer创建的是可变字符串,追加删除等操作不会产生新的String对象;
- StringBuffer类中的方法几乎都是synchronized的,多线程环境中操作字符串时线程是安全的;
- StringBuffer类没有重写equals()和hashCode(),进行StringBuffer对象比较时,和==结果一样,比较的是对象的内存地址。
这里并没有分析父类AbstractStringBuilder实现append()的逻辑,以及追加方法涉及到的扩容机制,准备把这个过程放在StringBuilder类源码分析中进行,StringBuilder类除了非同步的特点外,所有的API实现逻辑是和StringBuffer类一模一样的。