0
点赞
收藏
分享

微信扫一扫

Java 的 String, StringBuffer 和 StringBuilder


  • 理解String,StringBuffer 以及 StringBuilder
  • String, StringBuffer 和 StringBuilder 的区别
  • String, StringBuffer 和 StringBuilder 的使用策略

1. String 类

​String​​ 是一个类。它是一个引用数据类型。只是在使用上很像基本数据类型。​​String​​​ 类的全称:​​java.lang.String​​​。​​String​​ 类代表的是字符串。

String:字符串常量,字符串长度不可变。Java 中 String 是 immutable(不可变)的。

​String​​ 类的部分源码

public final class String
implements java.io.Serializable, Comparable<String>, CharSequence
{
/** The value is used for character storage. */
private final char value[];

/** The offset is the first index of the storage that is used. */
private final int offset;

/** The count is the number of characters in the String. */
private final int count;

......

}

从源码上可以看出,​​String​​​ 类是 ​​final​​​ 类,所以 ​​String​​​ 类不能被继承,并且它的成员方法默认为 ​​final​​​ 方法。在 ​​Java​​​ 中,在确定不想让该方法被覆盖时,会将方法设置为 ​​final​​。

再看 ​​String​​ 类的方法实现

public String substring(int beginIndex, int endIndex) {
if (beginIndex < 0) {
throw new StringIndexOutOfBoundsException(beginIndex);
}
if (endIndex > count) {
throw new StringIndexOutOfBoundsException(endIndex);
}
if (beginIndex > endIndex) {
throw new StringIndexOutOfBoundsException(endIndex - beginIndex);
}
return ((beginIndex == 0) && (endIndex == count)) ? this :
new String(offset + beginIndex, endIndex - beginIndex, value);
}

public String concat(String str) {
int otherLen = str.length();
if (otherLen == 0) {
return this;
}
char buf[] = new char[count + otherLen];
getChars(0, count, buf, 0);
str.getChars(0, otherLen, buf, count);
return new String(0, count + otherLen, buf);
}

public String replace(char oldChar, char newChar) {
if (oldChar != newChar) {
int len = count;
int i = -1;
char[] val = value; /* avoid getfield opcode */
int off = offset; /* avoid getfield opcode */

while (++i < len) {
if (val[off + i] == oldChar) {
break;
}
}
if (i < len) {
char buf[] = new char[len];
for (int j = 0 ; j < i ; j++) {
buf[j] = val[off+j];
}
while (i < len) {
char c = val[off + i];
buf[i] = (c == oldChar) ? newChar : c;
i++;
}
return new String(0, len, buf);
}
}
return this;
}

从上面的方法可以看出,对于 String 的操作会生成一个新的字符串而不是在原有的字符串上进行修改,也就是说进行这些操作后,最原始的字符串并没有被改变

2. StringBuffer(JDK1.0)

​StringBuffer​​:字符串变量(Synchronized,即线程安全)。如果要频繁对字符串内容进行修改,出于效率考虑最好使用 StringBuffer​​,如果想转成 ​​String​​​ 类型,可以调用 ​​StringBuffer​​​ 的 ​​toString()​​ 方法。

​Java.lang.StringBuffer​​ --> 线程安全的可变字符序列。在任意时间点上它都包含某种特定的字符序列,但通过某些方法调用可以改变该序列的长度和内容。可将字符串缓冲区安全地用于多个线程。

​StringBuffer​​​ 上的主要操作是 ​​append​​​ 和 ​​insert​​​ 方法,可重载这些方法,以接受任意类型的数据。每个方法都能有效地将给定的数据转换成字符串,然后将该字符串的字符追加或插入到字符串缓冲区中。​​append​​​ 方法始终将这些字符添加到缓冲区的末端;而 ​​insert​​ 方法则在指定的点添加字符。

3. StringBuilder(JDK5.0)

​StringBuilder​​:字符串变量(非线程安全)。在内部,​​StringBuilder​​ 对象被当作是一个包含字符序列的变长数组。

​java.lang.StringBuilder​​​ 是一个可变的字符序列,是JDK5.0新增的。此类提供一个与 ​​StringBuffer​​​ 兼容的 API,但不保证同步。该类被设计用作 ​​StringBuffer​​ 的一个简易替换,用在字符串缓冲区被单个线程使用的时候(这种情况很普遍)。

但在大多数实现中,它比 ​​StringBuffer​​​ 要快。两者的方法基本相同,但 ​​StringBuffer​​​ 类的成员方法前面用 ​​synchronized​​​ 修饰,也就是说 ​​StringBuffer​​ 是线程安全的。

三者区别

特点

  • ​String​​:不可变字符串
  • ​StringBuffer​​:可变字符串、效率低、线程安全;
  • ​StringBuilder​​:可变字符序列、效率高、线程不安全;
  • 一般情况下执行效率:​​StringBuilder​​​ >​​StringBuffer​​​ >​​String​

使用策略

三者在使用上的基本原则是:

  • 如果要操作少量的数据,用​​String​​ ;
  • 单线程操作大量数据,用​​StringBuilder​​ ;
  • 多线程操作大量数据,用​​StringBuffer​​。
  1. 使用 ”+”进行频繁的拼接时,基于性能的考虑,不要使用String类,应该使用StringBuffer或StringBuilder类
  2. ​StringBuilder​​​ 相较于​​StringBuffer​​​ 有速度优势,所以多数情况下建议使​​StringBuilder​​ 类, StringBuffer`主要用在全局变量中
  3. 要程序要求线程安全,则必须使用​​StringBuffer​​ 类

String 类型和StringBuffer的主要性能区别:String是不可变的对象, 因此在每次对String 类型进行改变的时候,都会生成一个新的 String 对象,然后将指针指向新的 String 对象,所以经常改变内容的字符串最好不要用 String ,因为每次生成对象都会对系统性能产生影响,特别当内存中无引用对象多了以后, JVM 的 GC 就会开始工作,性能就会降低。

使用 StringBuffer 类时,每次都会对 StringBuffer 对象本身进行操作,而不是生成新的对象并改变对象引用。所以多数情况下推荐使用 StringBuffer ,特别是字符串对象经常改变的情况下。

  1. 为了获得更好的性能,在构造 StringBuffer 或 StringBuilder 时应尽可能指定它们的容量。当然,如果你操作的字符串长度(length)不超过 16 个字符就不用了,当不指定容量(capacity)时默认构造一个容量为16的对象。不指定容量会显著降低性能。
  2. StringBuilder一般使用在方法内部来完成类似"+"功能,因为是线程不安全的,所以用完以后可以丢弃。StringBuffer主要用在全局变量中。
  3. 相同情况下使用 StringBuilder 相比使用 StringBuffer 仅能获得 10%~15% 左右的性能提升,但却要冒多线程不安全的风险。而在现实的模块化编程中,负责某一模块的程序员不一定能清晰地判断该模块是否会放入多线程的环境中运行,因此:除非确定系统的瓶颈是在 StringBuffer 上,并且确定你的模块不会运行在多线程模式下,才可以采用StringBuilder;否则还是用StringBuffer。

参考资料:

  • ​​http://docs.oracle.com/javase/tutorial/java/data/buffers.html​​
  • ​​http://docs.oracle.com/javase/specs/jls/se7/html/jls-4.html#jls-4.12.4​​
  • ​​https://tryenough.com/java06​​


举报

相关推荐

0 条评论