String、StringBuilder和StringBuffe

• String是不可变的类，其封装了一个final的实例域，其所有的行为不会修改这个final的实例域，如果要修改这个域，方法会返回一个新对象。

//这是String的源码，可以看出这个方法如果存在修改final
//域的情况，就会返回一个新对象，如果不需要修改这个域，直接返回this
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;
    }

• 字面量即字符串常量，在代码中出现的所有用""双引号包括的字符串都是字符常量，编译器在编译时会收集类中所有的字符常量放到类的常量池中，运行时引用指向的实际上是常量池中的字符串。

String s1 = "hello";
String s2 = "hello";
String s3 = "he" + "llo";
String s4 = "he";
String s5 = s4 + "llo";
//这个会打印true，因为s1和s2都指向了常量池中的"hello"
System.out.println(s1 == s2);
//这个也会打印true，因为编译器会做优化将"he" + "llo"合并为"hello"
System.out.println(s1 == s3);
//编译器不会对s4 + "llo"进行优化，所以s5会在堆上分配，所以会打印false
System.out.println(s1 == s5);

• String.intern()方法。上面讲到编译器在编译时会收集类中所有的字符常量放到类的常量池中，也就是说编译之后常量池中的所有字符串常量已经确定了。但是intern()方法会扩冲常量池中的字符串常量。存在于.class文件中的常量池，在运行期被JVM装载，并且可以扩充。String的intern()方法就是扩充常量池的一个方法；当一个String实例str调用intern()方法时，Java查找常量池中是否有相同Unicode的字符串常量，如果有，则返回其的引用，如果没有，则在常量池中增加一个Unicode等于str的字符串并返回它的引用

String s1 = "hello";
String s2 = new String("hello");
//false s1指向常量池，s2指向堆
System.out.println(s1 == s2);
//true s2.intern()返回常量池的引用
System.out.println(s1 == s2.intern());

优点：

1. intern()使得每个字符串都是字符串池中字符串的引用，而字符串池中的所有字符串都是唯一的，可以节省内存；
2. 通过引用来比较字符串的速度更快（==比equal(object）速度快）。

缺点：

1. 为了确保字符串池中的字符串都是唯一的，需要做大量工作；
2. 必须确保对所有的字符串都用了intern（）方法，这样对他们比较时才能都用==,而且这种想法必须让团队中的所有成员知道；
3. intern（）后的字符串都存储在PermGen空间这个空间相对较小，因此会导致OutOfMemoryror ，即便此时空闲栈空间还很充足。

• StringBuffer，线程安全的可变字符序列。在任意时间点上它都包含某种特定的字符序列，但通过某些方法调用可以改变该序列的长度和内容。可将StringBuffer安全地用于多个线程。

• StringBuilder，字符串变量（非线程安全）。在内部，StringBuilder对象被当作是一个包含字符序列的变长数组。此类提供一个与 StringBuffer 兼容的 API，但不保证同步。所以需要在线程封闭的环境中使用该类。效率较高，因为不需要每次都获取锁。

三者比较：

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

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

在某些特别情况下， String 对象的字符串拼接其实是被 Java Compiler 编译成了 StringBuffer 对象的拼接，所以这些时候 String 对象的速度并不会比 StringBuffer 对象慢，例如：

String s1 = “This is only a” + “ simple” + “ test”;
StringBuffer Sb = new StringBuilder(“This is only a”).append(“ simple”).append(“ test”);

生成 String s1对象的速度并不比 StringBuffer慢。其实在Java Compiler里，自动做了如下转换：
Java Compiler直接把上述第一条语句编译为：

String s1 = “This is only a simple test”;

所以速度很快。但要注意的是，如果拼接的字符串来自另外的String对象的话，Java Compiler就不会自动转换了，速度也就没那么快了，例如：

String s2 = “This is only a”;
String s3 = “ simple”;
String s4 = “ test”;
String s1 = s2 + s3 + s4;

这时候，Java Compiler会规规矩矩的按照原来的方式去做，String的concatenation（即+）操作利用了StringBuilder（或StringBuffer）的append方法实现，此时，对于上述情况，若s2，s3，s4采用String定义，拼接时需要额外创建一个StringBuffer（或StringBuilder），之后将StringBuffer转换为String；若采用StringBuffer（或StringBuilder），则不需额外创建StringBuffer。

使用策略:

1. 基本原则：如果要操作少量的数据，用String ；单线程操作大量数据，用StringBuilder ；多线程操作大量数据，用StringBuffer。

2. 不要使用String类的"+"来进行频繁的拼接，因为那样的性能极差的，应该使用StringBuffer或StringBuilder类，这在Java的优化上是一条比较重要的原则。例如：

String result = "";
for (String s : hugeArray) {
    result = result + s;
}
 
// 使用StringBuilder
StringBuilder sb = new StringBuilder();
for (String s : hugeArray) {
    sb.append(s);
}
String result = sb.toString();

当出现上面的情况时，显然我们要采用第二种方法，因为第一种方法，每次循环都会创建一个String result用于保存结果，除此之外二者基本相同（对于jdk1.5及之后版本）。

3. 为了获得更好的性能，在构造 StringBuffer 或 StringBuilder 时应尽可能指定它们的容量。当然，如果你操作的字符串长度（length）不超过 16 个字符就不用了，当不指定容量（capacity）时默认构造一个容量为16的对象。不指定容量会显著降低性能。

4. StringBuilder一般使用在方法内部来完成类似"+"功能，因为是线程不安全的，所以用完以后可以丢弃。StringBuffer主要用在全局变量中。

5. 相同情况下使用 StringBuilder 相比使用 StringBuffer 仅能获得 10%~15% 左右的性能提升，但却要冒多线程不安全的风险。而在现实的模块化编程中，负责某一模块的程序员不一定能清晰地判断该模块是否会放入多线程的环境中运行，因此：除非确定系统的瓶颈是在 StringBuffer 上，并且确定你的模块不会运行在多线程模式下，才可以采用StringBuilder；否则还是用StringBuffer。

参考：

https://www.cnblogs.com/Qian123/p/5707154.html

https://blog.csdn.net/kingzone_2008/article/details/9220691