Java的String类，StringBuffer类以及Stri

Java中处理字符串常用的类精讲

你将学到
1. 理解String，StringBuffer以及StringBuilder类
2. String类与StringBuffer以及StringBuilder的区别
3. String类与StringBuffer以及StringBuilder的使用策略

1. String类

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

1.1、声明一个String类的变量。注意，类创建的变量叫引用。

//1. 第一种方式，s是String类的变量，叫引用。"abc"是String数据类型的常量。
String s = "abc";
//2. 第二种方式，使用new关键字实例化
String s = new String("abc");

当使用第一种方式声明变量时，“abc”会使用字符串常量池来提高效率

1.2、 我们给出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。
1.2、我们再给出部分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的操作会生成一个新的字符串而不是在原有的字符串上进行修改，也就是说进行这些操作后，最原始的字符串并没有被改变。如：“+”运算符在String类，表示：字符串连接

String s = "abc"+"123";//结果s为"abc123"

2. StringBuffer以及StringBuilder类

和 String 类不同的是，StringBuffer 和 StringBuilder 类的对象能够被多次的修改，并且不产生新的未使用对象。

2.1、 StringBuffer 上的主要操作是 append 和 insert 方法，可重载这些方法，以接受任意类型的数据。append 方法始终将这些字符添加到缓冲区的末端；而 insert 方法则在指定的点添加字符。如，

public class TryEnTest{
  public static void main(String args[]){
    StringBuffer testBuffer = new StringBuffer("Test：");
    testBuffer.append("w.");
    testBuffer.append(".tryenough.com");
    testBuffer.insert(1,"www");
      //输出：Test：www.tryenough.com
    System.out.printlntstsBuffer);
  }
}

2.2、 StringBuilder是1.5新增的，此类提供一个与 StringBuffer 兼容的 API，但不保证同步。该类被设计用作 StringBuffer 的一个简易替换，用在字符串缓冲区被单个线程使用的时候（这种情况很普遍）。但在大多数实现中，它比 StringBuffer 要快。两者的方法基本相同，但StringBuffer类的成员方法前面用synchronized修饰，也就是说StringBuffer是线程安全的。

3. String类与StringBuffer以及StringBuilder的区别

理解了String类与StringBuffer以及StringBuilder类后，我们总结一下三者的主要区别。

• String：不可变字符串；
• StringBuffer：可变字符串、效率低、线程安全；
• StringBuilder：可变字符序列、效率高、线程不安全；
• 一般情况下String、StringBuilder、StringBuffer三者的执行效率：StringBuilder > StringBuffer > String

4. String类与StringBuffer以及StringBuilder类的使用策略

三者在使用上的基本原则是：如果要操作少量的数据，用String ；单线程操作大量数据，用StringBuilder ；多线程操作大量数据，用StringBuffer。

1. 使用 ”+”进行频繁的拼接时，基于性能的考虑，不要使用String类，应该使用StringBuffer或StringBuilder类
2. StringBuilder 相较于 StringBuffer 有速度优势，所以多数情况下建议使StringBuilder 类StringBuilder，如一般使用在方法内部来完成类似”+”功能，因其线程不安全，所以用完以后可以丢弃。StringBuffer主要用在全局变量中
3. 要程序要求线程安全，则必须使用StringBuffer类