Java基础学习总结(65)——Java中的String,StringBuilder和StringBuffer比较

时间:2024-07-18 23:04:20

字符串,就是一系列字符的集合。

Java里面提供了String,StringBuffer和StringBuilder三个类来封装字符串,其中StringBuilder类是到jdk 1.5才新增的。字符串操作可以说是几乎每门编程语言中所必不可少的,你真的理解其内幕吗?

下面让我们开始探秘之旅吧!

1、既然都是用来封装字符串的,那为什么还要3个类来封装呢?

2、它们三者之间到底有何区别?

3、它们三者之间的使用场景分别是什么?

4、它们三者之间从内存角度来看又是怎么来实现的呢?

5、它们三者之间的性能效率是怎么排列的?

下面就让我们逐一破解这几个谜团吧!

一、概述

字符串是由若干个字符线性排列组成的,所以我们可以把字符串当作数组(Array)来看待。众所周知,数组就是内存里线性排列的有序地址空间块。既然是线性排列,有序的一组地址块,那么在分配数组空间时就必须指定空间大小也就是数组大小,这也是大多数编程语言里规定在定义数组时要指定数组大小的原因( 某些编程语言中可变数组的实现另当别论 )。换言之,
数组就分为可变数组和不可变数组。可变数组能够动态插入和删除,而不可变数组一旦分配好空间后则不能进行动态插入或删除操作。

二、从实际应用可能的场景中分析String,StringBuilder,StringBuffer产生的背景

在实际应用当中我们可能会对字符串经常做如下几种操作:插入,删除,修改,拼接,截取,查到,替换……其中,“插入”和“删除”操作就涉及到对 原字符串的长度 进行修改( 其实,“拼接”和“截取”也分为可以理解为插入和删除操作 )。

然而,在jdk 1.0中就出现的 String类封装的字符串是不可变的 ,即不能在原字符串上进行 插入 和删除 操作,String的API是通过新建临时变量的方式来实现字符串的插入和删除操作。因为是新建临时变量,所以
当你调用String类的API对字符串进行插入和删除操作时原来的字符串是不会有任何改变的,返回给你的是一个新的字符串对象 。关于这一点,我们将在后面通过分析源码的方式来证实!既然String类封装的是不可变数组,那么对应的就应该有一个类来封装可变数组。没错! StringBuffer类封装的就是可变数组,并且还是线程安全的。 所以,在非多线程环境下效率相对较低。正如大家所想的一样,JDK里也提供了非多线程环境下使用的可变字符串的封装类,它就是在jdk 1.5里面才姗姗来迟的StringBuilder类, StringBuilder类是非线程安全的可变字符串封装类 ,也是我们今天要讨论的成员之一。

到此,我们基本上就已经回答了在文章开始处提出的第1,2,3个问题。接下来,我们再从源码的角度来更深入讨论。

三、从源码角度进一步探讨其内部实现方式

1、String类的关键源码分析如下:

public final class String
implements java.io.Serializable, Comparable<String>, CharSequence {
/** The value is used for character storage. */
private final char value[];//final类型char数组
//省略其他代码……
……
}

从上述的代码片段中我们可以看到,String类在类开始处就定义了一个final 类型的char数组value。也就是说通过 String类定义的字符串中的所有字符都是存储在这个final
类型的char数组中的。

下面我们来看一下String类对字符串的截取操作,关键源码如下:

public String substring(int beginIndex) {
if (beginIndex < 0) {
throw new StringIndexOutOfBoundsException(beginIndex);
}
int subLen = value.length - beginIndex;
if (subLen < 0) {
throw new StringIndexOutOfBoundsException(subLen);
}
//当对原来的字符串进行截取的时候(beginIndex >0),返回的结果是新建的对象
return (beginIndex == 0) ? this : new String(value, beginIndex, subLen);
}

当我们对字符串从第beginIndex(beginIndex >0) 个字符开始进行截取时,返回的结果是重新new出来的对象。所以,在对String类型的字符串进行大量“插入”和“删除”操作时会产生大量的临时变量。

2、StringBuffer和StringBuilder类关键源码分析:

在进行这两个类的源码分析前,我们先来分析下一个抽象类AbstractStringBuilder,因为,StringBuffer和StringBuilder都继承自这个抽象类,即AbstractStringBuilder类是StringBuffer和StringBuilder的共同父类。AbstractStringBuilder类的关键代码片段如下:

abstract class AbstractStringBuilder implements Appendable, CharSequence {
/**
* The value is used for character storage.
*/
char[] value;//一个char类型的数组,非final类型,这一点与String类不同 /**
* This no-arg constructor is necessary for serialization of subclasses.
*/
AbstractStringBuilder() {
} /**
* Creates an AbstractStringBuilder of the specified capacity.
*/
AbstractStringBuilder(int capacity) {
value = new char[capacity];//构建了长度为capacity大小的数组
} //其他代码省略……
……
}

StringBuffer类的关键代码如下:

public final class StringBuffer
extends AbstractStringBuilder
implements java.io.Serializable, CharSequence
{
/**
* Constructs a string buffer with no characters in it and an
* initial capacity of 16 characters.
*/
public StringBuffer() {
super(16);//创建一个默认大小为16的char型数组
} /**
* Constructs a string buffer with no characters in it and
* the specified initial capacity.
*
* @param capacity the initial capacity.
* @exception NegativeArraySizeException if the {@code capacity}
* argument is less than {@code 0}.
*/
public StringBuffer(int capacity) {
super(capacity);//自定义创建大小为capacity的char型数组
}
//省略其他代码……
……

StringBuilder类的构造函数与StringBuffer类的构造函数实现方式相同,此处就不贴代码了。

下面来看看StringBuilder类的append方法和insert方法的代码,因StringBuilder和StringBuffer的方法实现基本上一致,不同的是StringBuffer类的方法前多了个synchronized关键字,即StringBuffer是线程安全的。所以接下来我们就只分析StringBuilder类的代码了。StringBuilder类的append方法,insert方法都是Override
父类AbstractStringBuilder的方法,所以我们直接来分析AbstractStringBuilder类的相关方法。

public AbstractStringBuilder append(String str) {
if (str == null)
return appendNull();
int len = str.length();
//调用下面的ensureCapacityInternal方法
ensureCapacityInternal(count + len);
str.getChars(0, len, value, count);
count += len;
return this;
} private void ensureCapacityInternal(int minimumCapacity) {
// overflow-conscious code
if (minimumCapacity - value.length > 0)
//调用下面的expandCapacity方法实现“扩容”特性
expandCapacity(minimumCapacity);
} /**
* This implements the expansion semantics of ensureCapacity with no
* size check or synchronization.
*/
void expandCapacity(int minimumCapacity) {
//“扩展”的数组长度是按“扩展”前数组长度的2倍再加上2 byte的规则来扩展
int newCapacity = value.length * 2 + 2;
if (newCapacity - minimumCapacity < 0)
newCapacity = minimumCapacity;
if (newCapacity < 0) {
if (minimumCapacity < 0) // overflow
throw new OutOfMemoryError();
newCapacity = Integer.MAX_VALUE;
}
//将value变量指向Arrays返回的新的char[]对象,从而达到“扩容”的特性
value = Arrays.copyOf(value, newCapacity);
}

从上述代码分析得出,StringBuilder和StringBuffer的append方法“扩容”特性本质上是通过调用Arrays类的copyOf方法来实现的。接下来我们顺藤摸瓜,再分析下Arrays.copyOf(value,
newCapacity)这个方法吧。代码如下:

public static char[] copyOf(char[] original, int newLength) {
//创建长度为newLength的char数组,也就是“扩容”后的char 数组,并作为返回值
char[] copy = new char[newLength];
System.arraycopy(original, 0, copy, 0,
Math.min(original.length, newLength));
return copy;//返回“扩容”后的数组变量
}

其中,insert方法也是调用了expandCapacity方法来实现“扩容”特性的,此处就不在赘述了。

接下来,分析下delete(int start, int end)方法,代码如下:

public AbstractStringBuilder delete(int start, int end) {
if (start < 0)
throw new StringIndexOutOfBoundsException(start);
if (end > count)
end = count;
if (start > end)
throw new StringIndexOutOfBoundsException();
int len = end - start;
if (len > 0) {
//调用native方法arraycopy对value数组进行复制操作,然后重新赋值count变量达到“删除”特性
System.arraycopy(value, start+len, value, start, count-end);
count -= len;
}
return this;
}

从源码可以看出delete方法的“删除”特性是调用native方法arraycopy对value数组进行复制操作,然后重新赋值count变量实现的

最后,来看下substring方法,源码如下 :

public String substring(int start, int end) {
if (start < 0)
throw new StringIndexOutOfBoundsException(start);
if (end > count)
throw new StringIndexOutOfBoundsException(end);
if (start > end)
throw new StringIndexOutOfBoundsException(end - start);
//根据start,end参数创建String对象并返回
return new String(value, start, end - start);
}

四、总结:

1、String类型的字符串对象是不可变的,一旦String对象创建后,包含在这个对象中的字符系列是不可以改变的,直到这个对象被销毁。

2、StringBuilder和StringBuffer类型的字符串是可变的,不同的是StringBuffer类型的是线程安全的,而StringBuilder不是线程安全的

3、如果是多线程环境下涉及到共享变量的插入和删除操作,StringBuffer则是首选。如果是非多线程操作并且有大量的字符串拼接,插入,删除操作则StringBuilder是首选。毕竟String类是通过创建临时变量来实现字符串拼接的,耗内存还效率不高,怎么说StringBuilder是通过JNI方式实现终极操作的。

4、StringBuilder和StringBuffer的“可变”特性总结如下:

(1)append,insert,delete方法最根本上都是调用System.arraycopy()这个方法来达到目的

(2)substring(int, int)方法是通过重新new String(value, start, end - start)的方式来达到目的。因此,在执行substring操作时,StringBuilder和String基本上没什么区别。