一、String类源码分析

1. 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;
 
    /** Cache the hash code for the string */
    private int hash; // Default to 0
 
    /** use serialVersionUID from JDK 1.0.2 for interoperability */
    private static final long serialVersionUID = -6849794470754667710L;
 
    ......
 
}

（1）String类是final关键字修饰的，即意味着String类不能被继承，并且它的成员方法都默认为final方法。因为在Java中，被final关键字修饰的类不允许被继承，且该类的所有成员方法都默认为final方法。final方法不可以被（该类的子类）覆盖（override）。
（2）String通过私有成员char value[ ]数组保存字符串。

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;

  从以上的substring、concat、replace三个方法可以看出，返回的字符串都是一个重新new的一个String对象，也就是说这些操作并不是在当前的字符串上进行修改的。总结为下面这句话：

对String对象的任何改变都影响不到原对象，相关的任何change操作都会生成新的对象。

二、String、StringBuilder、StringBuffer的区别

1.执行速度方面

  首先来看下面这段代码：

public class Main {
         
    public static void main(String[] args) {
        String string = "";
        for(int i=0;i<10000;i++){
            string += "hello";
        }
    }
}

  反编译的字节码如下：

  在上图字节码中，从第8行到第35行是源代码中循环语句string+= "hello"的执行过程，每次执行都会new一个StringBuilder对象，然后进行append操作，最后通过toString方法返回String对象：

StringBuilder str = new StringBuilder(string);
str.append("hello");
str.toString();

  StringBuilder类的toString方法如下：

public String toString() {  
       // Create a copy, don't share the array  
       return new String(value, 0, count);  
}  

  也需要new一个String的对象，因此循环1000次将造成巨大的内存浪费，且执行速度很慢。
  再看以下代码：

public class Main {
    public static void main(String[] args) {
        StringBuilder stringBuilder = new StringBuilder();
        for(int i=0;i<10000;i++){
            stringBuilder.append("hello");
        }
    }
}

  反编译字节码文件得到：

  字节码的13行到27行是源代码循环的执行过程，其中并没有任何new的操作，即append操作都是在原有对象的基础上进行的，因此循环1000次占用的内存资源要小得多，执行速度也更快。
  三者的执行效率StringBuilder>StringBuffer>String，当然这个是相对的，也有例外情况，比如以下代码：

String str="abc"+"de";
StringBuilder stringBuilder=new StringBuilder().append("abc").append("de");
System.out.println(str);
System.out.println(stringBuilder.toString());

  String的速度比StringBuilder的反应速度快很多，因为对于直接相加字符串，在编译器便确定了它的值，也就是说"abc"+"de"的字符串相加，在编译期间便被优化成了"abcde"。对于间接相加（即包含字符串引用），形如s1+s2+s3，效率要比直接相加低，因为在编译器不会对引用变量进行优化。

2.线程安全方面

  StringBuilder和StringBuffer类所拥有的成员属性和成员方法基本相同，区别是StringBuffer类的成员方法前面多了一个关键字synchronized，因此StringBuffer是线程安全的，StringBuilder是非线程安全的。下面摘了两段代码分别来自二者的insert方法的实现：

public StringBuilder insert(int index, char str[], int offset,
                              int len)
  {
      super.insert(index, str, offset, len);
      return this;
  }

public synchronized StringBuffer insert(int index, char str[], int offset,
                                            int len)
    {
        super.insert(index, str, offset, len);
        return this;
    }

3.适用情况

String：适用于少量字符串操作的情况
StringBuilder：适用于单线程下对大量字符串操作
StringBuffer：适用于多线程下对大量字符串操作