前言

        由于发现 String、StringBuilder>StringBuilder、StringBuffer>StringBuffer 面试的时候会经常问到，这里就顺便总结一下：本文重点会以这三个字符串类的性能、线程安全、存储结构这三个方面进行分析

---

 ✨上期回顾：Java 哈希表

---

 ✨目录

前言

String%20%E4%BB%8B%E7%BB%8D-toc" style="margin-left:0px;"> String 介绍

String%20%E7%9A%84%E4%B8%8D%E5%8F%AF%E5%8F%98%E6%80%A7-toc" style="margin-left:40px;">String 的不可变性

String%20%E5%9C%A8%E5%AD%97%E7%AC%A6%E4%B8%B2%E5%B8%B8%E9%87%8F%E6%B1%A0%E4%B8%AD%E7%9A%84%E8%A1%A8%E7%A4%BA-toc" style="margin-left:40px;">String 在字符串常量池中的表示

字符串常量池没有该字符串：

字符串常量池有该字符串：

总结

StringBuilder>StringBuilder%20%E4%B8%8E%20StringBuffer>StringBuffer-toc" style="margin-left:0px;">StringBuilder>StringBuilder 与 StringBuffer>StringBuffer

 效率的比较

线程安全的比较

模拟面试

String%20%E4%BB%8B%E7%BB%8D" style="text-align:center;"> String 介绍

String%20%E7%9A%84%E4%B8%8D%E5%8F%AF%E5%8F%98%E6%80%A7">String 的不可变性

        跳转到 String 的实现就会发现：

String 类 不能被继承：该类被 final 修饰

String 类是不可变的：value[ ] 被 final 修饰，表明 value[ ] 自身的值不能改变

String 类可以序列化，可以和其他 String 比较其大小：实现了 Comparable 接口

   通过下述代码，你就会发现 String 类中每一个看起来会修改 String 值的方法，实际上都是创建了一个全新的 String 对象包含修改后的字符串内容。而最初的 String 对象则丝毫未动 

class Test{
    static String Func(String s){
        return s.toUpperCase();
    }

    public static void main(String[] args) {
        String str = "hello world";
        System.out.println(str);
        String ret = Func(str);
        System.out.println(ret);
        System.out.println(str);
    }
}

//

输出结果：
hello world
HELLO WORLD
hello world

         当把 str 传给 Func 方法时，实际传递的是引用的一个拷贝。其实，每当把 String 对象作为方法的参数时，都会复制一份引用，而该引用所指的对象其实一直待在单一的物理位置上，从未动过

String%20%E5%9C%A8%E5%AD%97%E7%AC%A6%E4%B8%B2%E5%B8%B8%E9%87%8F%E6%B1%A0%E4%B8%AD%E7%9A%84%E8%A1%A8%E7%A4%BA">String 在字符串常量池中的表示

        先从一段代码开始吧，以下这行代码总共创建了几个对象呢？

String str = new String("Hello");

        我想很多人看到会不暇思索的回答：“这不是一个吗？”，其实并不然它创建了两个对象：

字符串常量池没有该字符串：

        如果字符串常量池中没有 Hello 这个字符，先在字符串常量池中创建一个 ‘Hello’ 的字符串对象，然后再在堆中创建一个 ‘Hello’ 的字符串对象，然后将堆中这个 ‘Hello’ 的字符串对象地址返回赋值给变量 str。因此需要创建两个对象。

---

字符串常量池有该字符串：

        String str = new String("Hello World");
        String ret = new String("Hello World");

        Java 虚拟机会先在字符串常量池中查找有没有 ‘Hello’ 这个字符串对象，如果有，就不会在字符串常量池中创建 ‘Hello’ 这个对象了，直接在堆中创建一个‘Hello’ 的字符串对象，然后将堆中这个 ‘Hello’ 的对象地址返回赋值给变量 str。因此只需要创建一个对象。

（注意：ret 所指向的字符是 Hello，不是HHllo，画到最后没存档回不去了，将就着看吧）

        为什么要先在字符串常量池中创建对象，然后再在堆上创建呢？

        由于字符串的使用频率实在是太高了，所以 Java 虚拟机为了提高性能和减少内存开销，在创建字符串对象的时候进行了一些优化，特意为字符串开辟了一块空间 -- 也就是字符串常量池

        通常情况下我们会采用双引号的方式来创建字符串对象，而不是通过 new 关键字的方式，因为 new 会强制创建对象会对资源造成浪费。

        如果我们采用双引号创建对象，如下图所示：

String str1 = "Hello";

String str2 = "World";

        Java 虚拟机会先在字符串常量池中查找是否存在该字符串，如果存在则不创建任何对象直接返回常量池中的对象引用；如果不存在，则在常量池中创建该字符串，并返回对象引用。这样做的好处是避免了重复创建多个相同的字符串对象，减少了内存的开销。

        接下来我们来研究一个经典的面试问题：

    public static void main(String[] args) {
            String a = "abc";
            String b = new String("abc");
            String c = new String("abc");
            String d = b.intern();
            System.out.println(a == b);
            System.out.println(b == c);
            System.out.println(a == d);
        }

     请问上述程序打印的结构是什么？

// 打印结构为：
false
false
true

        通过 String a = "abc" 这样创建一个字符串对象时，JVM会首先在字符串常量池中寻找这个字符串，我们发现 "abc" 不存在，则在常量池中创建该字符串并将 a 指向它。

---

        通过 String b = new String("abc") 这样创建字符串时，情况就不一样了，同样先在字符串常量池中寻找这个字符串，我们发现 "abc" 存在。它会在堆区创建该字符串对象并使 b 指向它，同样调用 String c = new String("abc") 时，也会在堆区再创建一个 String 对象并使 c 指向它。由于我们字符串中 “==” 比较的是地址，而我们的 b、c 创建的是两个不同的对象所以返回 false。a、b 同理返回 false。

---

        当调用 String d = b.intern() 时，intern方法（该方法为 native 方法）会在字符串常量池中查找是否存在该字符串对象，如果存在，则将 d 指向该常量池中的字符串对象，如果不存在则在常量池中创建该字符串并指向它，所以 a == d 返回 true。

总结

使用双引号声明的字符串对象会保存在字符串常量池中

使用 new 关键字创建的字符串对象会先从字符串常量池中找，如果没找到就创建一个，然后再在堆中创建字符串对象；如果找到了，就直接在堆中创建字符串对象

在存在字符串常量池的前提下，使用 new 关键字但是不想创建对象，可以使用 intern 方法直接获取字符串常量池的引用

StringBuilder>StringBuilder%20%E4%B8%8E%20StringBuffer>StringBuffer" style="text-align:center;">StringBuilder>StringBuilder 与 StringBuffer>StringBuffer

 效率的比较

        通过以上内容，相信你已经对 String 有一定了解。由于字符串是不可变的，所以当遇到字符串的拼接（尤其是使用 + 号操作符）的时候，就需要考量性能的问题，你不能毫无顾虑地生产太多 String 对象，对珍贵的内存造成不必要的压力

        于是 Java 就设计了两个专门用来解决此问题的 StringBuilder>StringBuilder、StringBuffer>StringBuffer 类 ~

        可能有人会问 String 能做的事情干嘛还要用 StringBuilder>StringBuilder、StringBuffer>StringBuffer 呢？我们可以对一个字符进行多次拼接查看程序的运行效率，如下述代码：

    public static void main(String[] args) {
            String s = "";
            long st = System.currentTimeMillis();
            for(int i = 0; i < 100000; i++) {
                s += "a";
            }
            long ed = System.currentTimeMillis();
            System.out.println("String时间：" + (ed - st) + "毫秒");

            st = System.currentTimeMillis();
            StringBuilder>StringBuilder sb = new StringBuilder>StringBuilder();
            for(int i = 0; i < 100000; i++) {
                sb.append("a");
            }
            ed = System.currentTimeMillis();
            System.out.println("StringBuilder>StringBuilder时间：" + (ed - st) + "毫秒");

            st = System.currentTimeMillis();
            StringBuffer>StringBuffer sf = new StringBuffer>StringBuffer();
            for(int i = 0; i < 100000; i++) {
                sf.append("a");
            }
            ed = System.currentTimeMillis();
            System.out.println("StringBuffer>StringBuffer时间：" + (ed - st) + "毫秒");

        }

代码运行结果：

String时间：827毫秒
StringBuilder>StringBuilder时间：1毫秒
StringBuffer>StringBuffer时间：3毫秒

        可以看出，在大量对字符串进行连接操作的情况下，StringBuilder>StringBuilder、StringBuffer>StringBuffer 优势非常明显。因为 String 拼接会产生大量对象，而 StringBuilder>StringBuilder、StringBuffer>StringBuffer 无论是创建、拼接、修改、删除都是直接作用于原字符串，并不会产生多余的对象。其次 StringBuilder>StringBuilder 比 StringBuffer>StringBuffer 的效率稍微高一点也是有原因的：这就涉及到线程安全问题，待会再讲。

 

线程安全的比较

        我们可以来对比一下它们的底层源码，再来做分析：

//String
public final class String
    implements java.io.Serializable, Comparable<String>, CharSequence {
    private final char value[];
    ...
}


//StringBuilder>StringBuilder
public final class StringBuilder>StringBuilder
    extends AbstractStringBuilder>StringBuilder
    implements Serializable, CharSequence
{
    @Override
    public StringBuilder>StringBuilder append(Object obj) {}
    @IntrinsicCandidate
    public String toString() {...}
    ...
}


//StringBuffer>StringBuffer
public final class StringBuffer>StringBuffer
    extends AbstractStringBuilder>StringBuilder
    implements Serializable, CharSequence
{
    //方法有synchronized关键字
    @Override
    public synchronized StringBuffer>StringBuffer append(Object obj){...}
    @IntrinsicCandidate
    public synchronized String toString() {...}
    ...
}

//AbstractStringBuilder>StringBuilder 
abstract sealed class AbstractStringBuilder>StringBuilder implements Appendable, CharSequence permits StringBuilder>StringBuilder, StringBuffer>StringBuffer {
    byte[] value;
    ...
}

 

        <1> 我们可以看到在 String 中，value 是被 final 修饰的是不可变的；StringBuilder>StringBuilder、StringBuffer>StringBuffer 都继承于 AbstractStringBuilder>StringBuilder 这个类，而这个类中 的 value 是可变数组，所以我们进行拼接等操作时是直接作用于原字符串实现的，这就是效率高的由来。

 

        <2> 我们观察 StringBuilder>StringBuilder、StringBuffer>StringBuffer  的 toString、append 方法：由于 StringBuffer>StringBuffer 操作字符串的方法加了synchronized 进行了同步，所以每次操作字符串时都会加锁，所以线程安全、但是性能低。这就是 StringBuilder>StringBuilder 比 StringBuffer>StringBuffer 运行效率略高的原因。

总结：

String 类

不可变性：一旦创建，内容不可改变

线程安全：由于不可变性，String 对象天生线程安全

性能：频繁的字符串操作会导致大量的对象创建和内存消耗

StringBuilder>StringBuilder 类

可变性：内容可以被改变

非线程安全：适用于单线程环境

性能：比 String 更适合频繁的字符串操作，因为不会创建大量的中间对象

StringBuffer>StringBuffer 类

可变性：内容可以被改变

线程安全：所有方法都是同步的，适用于多线程环境

性能：由于同步机制，性能略低于 StringBuilder>StringBuilder

模拟面试

如果HR问你：String、StringBuffer>StringBuffer、StringBuilder>StringBuilder 的区别？（你会怎么回答）

答：关于String、StringBuffer>StringBuffer、StringBuilder>StringBuilder的区别，我有四个方面来说：

        第一个是可变性，String 内部的 value 是 final 修饰的，所以它是一个不可变的类，所以每次修改 String 的值的时候都会产生一个新的对象。而 StringBuffer>StringBuffer、StringBuilder>StringBuilder 是一个可变类，字符串的变更不会产生新的对象。

        第二个是线程的安全性，因为 String 是一个不可变的类，所以它是线程安全的；而 StringBuffer>StringBuffer 也是线程安全的，因为它的每个操作方法中都有一个 synchronized  一个同步关键字；StringBuilder>StringBuilder 不是线程安全的，所以在多线程环境下对字符串进行操作的时候我们应该使用 StringBuffer>StringBuffer 否者使用 StringBuilder>StringBuilder。

        第三个是性能方面，String 效率是最低的，因为其不可变性导致做字符串的拼接或者修改的时候，我们需要创建新的对象，以及分配内存；其次是 StringBuffer>StringBuffer  比 String 的效率更高一点，因为它的可变性意味值字符串可以直接被修改；最后性能最高的是 StringBuilder>StringBuilder ，因为 StringBuilder>StringBuilder 比 StringBuffer>StringBuffer 的性能要高，因为 StringBuffer>StringBuffer 加了同步锁意味着对性能产生了影响。

        第四个是存储方面，String 存储在字符串常量池中，而 StringBuffer>StringBuffer、StringBuilder>StringBuilder 则是存储在堆的内存空间。