JDK源码之StringBuffer与StringBuilder类分析
一 概述
- StringBuffer类被 final 所修饰，不能被继承,StringBuffer继承了AbstractStringBuilder类,
是一个可变的字符序列,并且类中方法都有synchronized修饰,实现了线程安全 - StringBuilder类也被final修饰,继承了AbstractStringBuilder类,与StringBuffer区别是没有实现线程安全,方法逻辑都是调用的父类方法逻辑
二 StringBuffer源码解析
大部分方法都调用super父类逻辑,所以这里只举个别例子, 父类解析地址: https://www.cnblogs.com/houzheng/p/12153734.html
/**
* 返回最后一次toString的缓存值，一旦StringBuffer被修改就清除这个缓存值,
* 用于toString方法的时候如果此值不为空,则直接使用返回,不必进行数组copy,以提高性能
*/
private transient String toStringCache;
/**
* 调用父类构造器进行byte数组初始化,默认长度初始化为16或者(32,jvm参数关闭压缩时)
*/
@HotSpotIntrinsicCandidate
public StringBuffer() {
super(16);
}
/**
* 指定byte数组长度初始化
*/
@HotSpotIntrinsicCandidate
public StringBuffer(int capacity) {
super(capacity);
}
/**
* 根据String参数初始化
*/
@HotSpotIntrinsicCandidate
public StringBuffer(String str) {
super(str.length() + 16); //先进行初始化
append(str); //添加str
}
/**
* StringBuffer中所有方法都有synchronized修饰,保证了线程安全
* 每次操作都是对原有的byte数组操作,然后返回当前实例,从而实现了可变序列
* 几乎所有方法都是调用父类的方法逻辑,再加上synchronized实现,比如下面的append
*/
@Override
@HotSpotIntrinsicCandidate
public synchronized StringBuffer append(String str) {
toStringCache = null; //清空缓存
super.append(str);
return this; //返回this实例
}
// 覆写的toString方法,每次都是new一个String对象,如果toStringCache不为空,则直接用toStringCache构造String对象,否则进行数组copy
@Override
@HotSpotIntrinsicCandidate
public synchronized String toString() {
if (toStringCache == null) {
return toStringCache =
isLatin1() ? StringLatin1.newString(value, 0, count)
: StringUTF16.newString(value, 0, count);
}
return new String(toStringCache);
}
/**
* 自定义序列化字段,即序列化只序列化数组里面的属性
* ObjectStreamField类型数组serialPersistentFields定义需要被自动序列化的字段，
* 而且一旦定义了这个属性，那么就不会识别原本默认的可序列化字段，例如非static和非transitent字段。
*/
private static final java.io.ObjectStreamField[] serialPersistentFields =
{
new java.io.ObjectStreamField("value", char[].class),
new java.io.ObjectStreamField("count", Integer.TYPE),
new java.io.ObjectStreamField("shared", Boolean.TYPE),
};
/**
* 自定义序列化:
* 在序列化过程中，如果被序列化的类中定义了writeObject 和 readObject 方法，虚拟机会试图调用对象类里的 writeObject 和 readObject 方法(利用反射实现)，
* 进行用户自定义的序列化和反序列化。
* 如果没有这样的方法，则默认调用是 ObjectOutputStream 的 defaultWriteObject 方法以及 ObjectInputStream 的 defaultReadObject 方法。
* 用户自定义的 writeObject 和 readObject 方法可以允许用户控制序列化的过程，比如可以在序列化的过程中动态改变序列化的数值。
*/
private synchronized void writeObject(java.io.ObjectOutputStream s)
throws java.io.IOException {
java.io.ObjectOutputStream.PutField fields = s.putFields();
char[] val = new char[capacity()];
if (isLatin1()) {
StringLatin1.getChars(value, 0, count, val, 0);
} else {
StringUTF16.getChars(value, 0, count, val, 0);
}
//自定义序列化三个字段
fields.put("value", val);
fields.put("count", count);
fields.put("shared", false);
s.writeFields();
}
private void readObject(java.io.ObjectInputStream s)
throws java.io.IOException, ClassNotFoundException {
java.io.ObjectInputStream.GetField fields = s.readFields();
//反序列化只获取value 和 count
char[] val = (char[])fields.get("value", null);
initBytes(val, 0, val.length);
count = fields.get("count", 0);
}
三 StringBuilder源码解析
StringBUilder与StringBuffer基本一样,只是自我实现没有保证线程安全以及自定义序列化字段的一些区别
// 默认byte数组初始化为16
public StringBuilder() {
super(16);
}
public StringBuilder(int capacity) {
super(capacity);
}
/**
* 被@HotSpotIntrinsicCandidate标注的方法，在HotSpot中都有一套高效的实现，该高效实现基于CPU指令，
* 运行时，HotSpot维护的高效实现会替代JDK的源码实现，从而获得更高的效率。
*/
@HotSpotIntrinsicCandidate
public StringBuilder(String str) {
super(str.length() + 16);
append(str);
}
@Override
@HotSpotIntrinsicCandidate
public StringBuilder append(String str) {
super.append(str); //调用父类方法
return this;
}
//自定义序列化直接序列化
private void writeObject(java.io.ObjectOutputStream s)
throws java.io.IOException {
s.defaultWriteObject();
s.writeInt(count);//序列化 count,实际占用长度
char[] val = new char[capacity()];
if (isLatin1()) {
StringLatin1.getChars(value, 0, count, val, 0);
} else {
StringUTF16.getChars(value, 0, count, val, 0);
}
s.writeObject(val); // 序列化 char数组
}
private void readObject(java.io.ObjectInputStream s)
throws java.io.IOException, ClassNotFoundException {
s.defaultReadObject();
count = s.readInt();
char[] val = (char[]) s.readObject();
initBytes(val, 0, val.length);
}
四 总结
- StringBuffer相比String来说,性能更高,因为不用每次去生成一个String实例,尤其是for循环中
- StringBuilder性能会更好,他与StringBuffer都是继承了一样的父类,区别是各自的实现不同,一个线程安全,一个非线程安全
- String适用于少量的字符串操作的情况
- StringBuilder适用于单线程下在字符缓冲区进行大量操作的情况
- StringBuffer适用多线程下在字符缓冲区进行大量操作的情况
