JAVA基础（三）String类源码分析

我们知道String类是不可变、不可继承的类，那么String是如何通过代码保证不可变性？此外，在操作对String 进行添加时，StringBuffer和StringBuilder为何比‘+’更受推荐？

1 保证String不可变性

/*The {@code String} class represents character strings. All
 * string literals in Java programs, such as {@code "abc"}, are
 * implemented as instances of this class.
 * <p>
 * Strings are constant; their values cannot be changed after they
 * are created. String buffers support mutable strings.
 * Because String objects are immutable(不可变) they can be shared.
 * */

String类中有一个重要的属性

/** The value is used for character storage. */
private final char value[];

这个属性为final类型，一旦被赋值，将不可更改。其赋值在String()的构造方法中

/*
构造方法一
*/
public String() {
        this.value = "".value;
}
/*
构造方法二
*/
public String(String original) {
    this.value = original.value;
    this.hash = original.hash;
}
/*
构造方法三
*/
public String(char value[]) {
    this.value = Arrays.copyOf(value,value.length);
}

对String的常见操作的方法都是类似，如果你操作后的内容会和目前String中的内容不一致的话，那么都是重新创建一个新的String类并返回，否则返回原来的String对象，总之不会让你去修改内部的内容，下面通过subString()方法的源码来做到管中窥豹。

public String substring(int beginIndex) {
        if (beginIndex < 0) {
            throw new StringIndexOutOfBoundsException(beginIndex);
        }
        int subLen = value.length - beginIndex;
        if (subLen < 0) {
            throw new StringIndexOutOfBoundsException(subLen);
        }
        return (beginIndex == 0) ? this : new String(value, beginIndex, subLen);//如果index为0，表示从头算起，截取整个string对象，这样将会返回原对象，否则返回一个新的String对象
    }

再举一例，replace()方法。该方法用来替换某(几)个oldChar

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;//得到第一个oldChar所在位置i
                }
            }
            if (i < len) {
                char buf[] = new char[len];//新构建一个char数组，用来存放新对象的字符串
                for (int j = 0; j < i; j++) {
                    buf[j] = val[j];
                }
                while (i < len) {
                    char c = val[i];
                    buf[i] = (c == oldChar) ? newChar : c;//替换所有的oldChar
                    i++;
                }
                return new String(buf, true);
            }
        }
        //如果newChar和oldChar相同，直接返回原对象
        return this;
    }

2.String类型设置为不可变的好处

1. 可以实现多个变量引用JVM内存中的同一个字符串实例。见后文String Pool的介绍。
2. 安全性，String类的用途实在太广了，如果可以随意修改的，是不是很恐怖。
3. 性能，String大量运用在哈希的处理中，由于String的不可变性，可以只计算一次哈希值，然后缓存在内部，后续直接取就好了。如果String类是可变的话，在进行哈希处理的时候，需要进行大量的哈希值的重新计算。

2.1常量池String Pool

JVM的堆内存中专门给常量池腾出一块地方，用来放置经

String a = "abc";
String b = "acdcadcd";
String c = "abc";

定义的”abc”、”acdcadcd”这样的对象。同时，让String a、c这样的处于栈中的引用同时指向常亮池中的’abc’对象。但是，值得注意的是，通过new String(“abc”)创建的对象不在常量池中，而是作为普通对象放在普通堆中。

3.不推荐使用+连接字符串的原因

/*
* The Java language provides special support for the string
 * concatenation operator ( + ), and for conversion of
 * other objects to strings. String concatenation is implemented
 * through the {@code StringBuilder}(or {@code StringBuffer})
 * class and its {@code append} method.
 * */

从上面的注释得知，+连接运算符是通过StringBuilder(或者StringBuffer)的append()方法来进行连接操作的。每做一次加法运算，都需要new一个StringBuilder对象。

String a = 'a';
String b = 'b';
//需要new 5次StringBuilder对象
for (int i = 0; i < 5; i++) {
    a += b;
}

StringBuilder a= new StringBuilder("a");
//只用new 1次StringBuilder对象
for (int i = 0; i < 5; i++) {
    a.append('b');
}

4.StringBuilder和StringBuffer的区别

• StringBuilder线程不安全
• StringBuffer线程安全
  实际上两者都继承自AbstractStringBuilder，都实现了Serializable和CharSequence接口。StringBuffer为了实现线程安全，在每个操作string对象的方法上都添加了synchronized关键字。