String、StringBuffer、StringBuilder源码分析

利用反编译具体看看"+"的过程

1 public class Test

2 {

3     public static void main(String[] args)

4     {

5         int i=10;

6         String s="abc";

7         System.out.println (s+i);

8     }

9 }

可以看到的确是创建了StringBuilder类，然后调用了两次append方法，并且调用了toString方法。

查看AbstractStringBuilder源码可知：

s+i的过程可等价为s+String.valueOf(i),也可等价为new StringBuilder("abc").append(String.valueOf(i)).toString()

一直都很好奇，为什么String类要做成不可变的？以及它是怎么实现的？

对象不可变定义
不可变对象是指对象的状态在被初始化以后，在整个对象的生命周期内，不可改变。
如何不可变
通常情况下，在java中通过以下步骤实现不可变

对于属性不提供设值方法
所有的属性定义为private final
类声明为final不允许继承
Return deep cloned objects with copied content for all mutable fields in class

注意：不用final关键字也可以实现对象不可变，使用final只是显示的声明，提示开发者和编译器为不可变。

Java中典型的不可变类为String类
为什么String被设计为不可变？

安全首要原因是安全，不仅仅体现在你的应用中，而且在JDK中，Java的类装载机制通过传递的参数（通常是类名）加载类，这些类名在类路径下，想象一下，假设String是可变的，一些人通过自定义类装载机制分分钟黑掉应用。如果没有了安全，Java不会走到今天
性能 string不可变的设计出于性能考虑，当然背后的原理是string pool，当然string pool不可能使string类不可变，不可变的string更好的提高性能。
线程安全 当多线程访问时，不可变对象是线程安全的，不需要什么高深的逻辑解释，如果对象不可变，线程也不能改变它。

参考：http://blog.csdn.net/topwqp/article/details/46380331

String类使用"+"来连接字符的整个过程描述

1）、大家经常会说不要使用"+" 来连接字符串这样效率不高（相对于 StringBuilder、StringBuffer）那为什么那，看看下面：

String str= "a"; str=str+"b"; str=str+"c";

实现过程：

一、String str= "a";创建一个String对象，str 引用到这个对象。

二、再创建一个长度为str.length() 的StringBuffer 对象。

三、StringBuffer strb=new StringBuffer（str）。

四、调用StringBuffer的append（）方法将”b“添加进去,strb.append（"b"）。

五、调用strb 的toString()方法创建String对象，之前对象失去引用而str重新引用到这个新对象。

六、同样在创建StringBuffer对象调用append（）方法将”c“添加进去,调用toString() 方法创建String对象。

七、再将strb引用到新创建的String对象。之前对象失去引用之后存放在常量池中，等待垃圾回收。

看到上面使用“+”连接字符串的过程，就明白了为什么要使用StringBuffer 来连接字符而不是使用String 的“+”来连接。

（2)、知道了使用”+“连接的过程，我们再来看看上面提到的使用”+“号为什么会创建新的对象，也就是说String对象是不可变对象。这里有个概念就是对象不可变，而String 的对象就是一个不可变对象。那什么叫对象不可变那：当一个对象创建完成之后，不能再修改他的状态，不能改变状态是指不能改变对象内的成员变量，包括基本数据类型的值不能改变。引用类型的变量不能指向其他对象，引用类型指向的对象的状态也不能改变。对象一旦创建就没办法修改期所有属性，所以要修改不可变对象的值就只能重新创建对象。

String对象不可变源码分析

(1)、上面说了String 对象为不可变对象，为什么String 对象不可变，String对象的状态不能改变，接下来我们看看String 类的源码：

jdk 1.7 的源码

public final class String
    implements java.io.Serializable, Comparable<String>, CharSequence {
    /** The value is used for character storage. */
    // 数组的被final修饰，所以数据引用变量的值不能变

private final char value[];
/** Cache the hash code for the string */

// 缓存String对象的哈希值

private int hash; // Default to 0

我们会发现String 的底层是使用字符数组来实现的。

String 类中只有两个成员变量一个是value 一个是hash，这个hash和我们讨论的问题没关系，通过注解我们知道他是缓存String对象的hash值

value 是一个被final修饰的数组对象，所以只能说他不能再引用到其他对象而不能说明他所引用的对象的内容不能改变。但我们在往下看源码就会发现String 类没有给这两个成员变量提供任何的方法所以我们也没办法修改所引用对象的内容，所以String 对象一旦被创建，这个变量被初始化后就不能再修改了，所以说String 对象是不可变对象。

(2)、String 对象不是提供了像replace()等方法可以修改内容的吗，其实这个方法内部创建了一个新String 对象在把这个新对象重新赋值给了引用变量，看看源码你就相信了他是在内部重现创建了String 对象

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

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

// 创建新对象

return new String(buf, true);
            }
        }
        return this;
    }

总结：

1、String 类是一个final 修饰的类所以这个类是不能继承的，也就没有子类。

2、String 类的成员变量都是final类型的并且没有提供任何方法可以来修改引用变量所引用的对象的内容，所以一旦这个对象被创建并且成员变量初始化后这个对象就不能再改变了，所以说String 对象是一个不可变对象。

3、使用“+”连接字符串的过程产生了很多String 对象和StringBuffer 对象所以效率相比直接使用StringBuffer 对象的append（）方法来连接字符效率低很多。

4、引用变量是存在java虚拟机栈内存中的，它里面存放的不是对象，而是对象的地址或句柄地址。

5、对象是存在java heap(堆内存)中的值

6、引用变量的值改变指的是栈内存中的这个引用变量的值的改变是，对象地址的改变或句柄地址的改变，而对象的改变指的是存放在Java heap（堆内存）中的对象内容的改变和引用变量的地址和句柄没有关系。

StringBuffer

我们在上面说String对象是不可变的，而StringBuffer 对象是可变的，大家都说在能大体了解字符串的长度的情况下创建StringBuffer对象时指定其容量，在上面的string中我们也知道使用“+”号的时候我们也是调用了append方法。

1、为什么StringBuffer 对象可变，为什么要尽量指定初始大小，append方法是怎么实现的下面我们来看看这几个为什么

2、String 对象不可变是因为成员变量都被final修饰并且没有提供任何访问被引用对象的方法所以不能改变，而StringBuffer是怎么样的那我们可以去看看源码：

（1）、public final class StringBuffer extends AbstractStringBuilder
implements java.io.Serializable, CharSequence
{

/** use serialVersionUID from JDK 1.0.2 for interoperability */
static final long serialVersionUID = 3388685877147921107L;

/**
     * Constructs a string buffer with no characters in it and an
     * initial capacity of 16 characters.
     */

// 默认为16个字符
    public StringBuffer() {
        super(16);
    }

/**
     * 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</code>
     *               argument is less than <code>0</code>.
     */
    public StringBuffer(int capacity) {
        super(capacity);
    }

/**
     * Constructs a string buffer initialized to the contents of the
     * specified string. The initial capacity of the string buffer is
     * <code>16</code> plus the length of the string argument.
     *
     * @param   str   the initial contents of the buffer.
     * @exception NullPointerException if <code>str</code> is <code>null</code>
     */
    public StringBuffer(String str) {
        super(str.length() + 16);
        append(str);
    }

3、StringBuffer 类继承自AbstractStringBuilder 那在看看AbstractStringBuilder的源码

abstract class AbstractStringBuilder implements Appendable, CharSequence {
    /**
     * The value is used for character storage.
     */

// 这里我们看到，这个数组没有被final 修饰，所以引用变量的值可以改变，

//可以引用到其他数组对象

char[] value;

/**
     * The count is the number of characters used.
     */
   // 记录字符的个数

int count;

/**
     * 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];
}

/**
     * Returns the length (character count).
     *
     * @return the length of the sequence of characters currently
     *          represented by this object
     */
    public int length() {
        return count;
    }

从这些源码我们看到他的数组和String 的不一样，因为成员变量value数组没有被final修饰所以可以修改他的引用变量的值，即可以引用到新的数组对象。所以StringBuffer对象是可变的

3、如果知道字符串的长度则创建对象的时候尽量指定大小

（1）、在上面的源代码中我们看到StringBuffer 的构造函数默认创建的大小为16个字符。

（2）、如果我们在创建对象的时候指定了大小则创建指定容量大小的数组对象

// 调用父类的构造函数，创建数组对象

public StringBuffer(int capacity) {
super(capacity);
}

/**
     * Creates an AbstractStringBuilder of the specified capacity.
     */
    AbstractStringBuilder(int capacity) {
     //按照指定容量创建字符数组

value = new char[capacity];
}

（3）、如果在创建对象时构造函数的参数为字符串则创建的数组的长度为字符长度+16字符

这样的长度，然后再将这个字符串添加到字符数组中，添加的时候会判断原来字符数组中的个数加上这个字符串的长度是否大于这个字符数组的大小如果大于则进行扩容如果没有则添加，源码如下：

public StringBuffer(String str) {
        super(str.length() + 16);
        append(str);
    }
append 出现在了这里刚好一起来看看 append方法的实现

4、其实append方法就做两件事，如果 count （字符数组中已有字符的个数）加添加的字符串的长度小于 value.length 也就是小于字符数组的容量则直接将要添加的字符拷贝到数组在修改count就可以了。

5、如果cout和添加的字符串的长度的和大于value.length 则会创建一个新字符数组再将原有的字符拷贝到新字符数组，再将要添加的字符添加到字符数组中，再改变conut(字符数组中字符的个数)

整个添加过程的源码如下：

public synchronized StringBuffer append(Object obj) {
        super.append(String.valueOf(obj));
        return this;
    }

调用父类的方法
public AbstractStringBuilder append(Object obj) {
return append(String.valueOf(obj));
}

这个方法中调用了ensureCapacityInternal （）方法判断count(字符数组原有的字符个数)+str.length() 的长度是否大于value容量
/**
     * This method has the same contract as ensureCapacity, but is
     * never synchronized.
     */
    private void ensureCapacityInternal(int minimumCapacity) {
        // overflow-conscious code
        if (minimumCapacity - value.length > 0)
            expandCapacity(minimumCapacity);
    }

如果count+str.length() 长度大于value的容量则调用方法进行扩容
/**
     * This implements the expansion semantics of ensureCapacity with no
     * size check or synchronization.
     */
    void expandCapacity(int minimumCapacity) {
        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.copyOf(value, newCapacity);
    }

Arrays.copyOf（value,newCapacity）复制指定的数组，截取或用 null 字符填充（如有必要），以使副本具有指定的长度。

上面的getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin) 将字符从此字符串复制到目标字符数组dst中，第一个参数第二个参数截取要添加字符串的长度，第三个为目标字符数组第四个为字符串要添加到数组的开始位置

到这里数组的赋值都结束了，修改count的值，整个append也就结束了。

总结：

1、StringBuffer 类被final 修饰所以不能继承没有子类

2、StringBuffer 对象是可变对象，因为父类的 value [] char 没有被final修饰所以可以进行引用的改变，而且还提供了方法可以修改被引用对象的内容即修改了数组内容。

3、在使用StringBuffer对象的时候尽量指定大小这样会减少扩容的次数，也就是会减少创建字符数组对象的次数和数据复制的次数，当然效率也会提升。

StringBuilder 和StringBuffer 很像只是不是线程安全的其他的很像所以不罗嗦了。

参考：http://blog.csdn.net/qh_java/article/details/46382265