再也不怕面试被考字符串---详解Java中的字符串

时间 2019-11-07

原文原文链接

字符串常量池详解

在深刻学习字符串类以前, 咱们先搞懂JVM是怎样处理新生字符串的. 当你知道字符串的初始化细节后, 再去写String s = "hello"或String s = new String("hello")等代码时, 就能作到心中有数.java

首先得搞懂字符串常量池的概念.
常量池是Java的一项技术, 八种基础数据类型除了float和double都实现了常量池技术. 这项技术从字面上是很好理解的: 把常常用到的数据存放在某块内存中, 避免频繁的数据建立与销毁, 实现数据共享, 提升系统性能.
字符串常量池是Java常量池技术的一种实现, 在近代的JDK版本中(1.7后), 字符串常量池被实如今Java堆内存中.
下面经过三行代码让你们对字符串常量池创建初步认识:

public static void main(String[] args) {
    String s1 = "hello";
    String s2 = new String("hello");
    System.out.println(s1 == s2);   //false
}
复制代码

咱们先来看看第一行代码String s1 = "hello";干了什么.

对于这种直接经过双引号""声明字符串的方式, 虚拟机首先会到字符串常量池中查找该字符串是否已经存在. 若是存在会直接返回该引用, 若是不存在则会在堆内存中建立该字符串对象, 而后到字符串常量池中注册该字符串.
在本案例中虚拟机首先会到字符串常量池中查找是否有存在"hello"字符串对应的引用. 发现没有后会在堆内存建立"hello"字符串对象(内存地址0x0001), 而后到字符串常量池中注册地址为0x0001的"hello"对象, 也就是添加指向0x0001的引用. 最后把字符串对象返回给s1.
舒适提示: 图中的字符串常量池中的数据是虚构的, 因为字符串常量池底层是用HashTable实现的, 存储的是键值对, 为了方便你们理解, 示意图简化了字符串常量池对照表, 并采用了一些虚拟的数值.

下面看String s2 = new String("hello");的示意图

当咱们使用new关键字建立字符串对象的时候, JVM将不会查询字符串常量池, 它将会直接在堆内存中建立一个字符串对象, 并返回给所属变量.
因此s1和s2指向的是两个彻底不一样的对象, 判断s1 == s2的时候会返回false.

若是上面的知识理解起来没有问题的话, 下面看些难点的.面试

public static void main(String[] args) {
    String s1 = new String("hello ") + new String("world");
    s1.intern();
    String s2 = "hello world";
    System.out.println(s1 == s2);   //true
}
复制代码

第一行代码String s1 = new String("hello ") + new String("world");的执行过程是这样子的:

依次在堆内存中建立"hello "和"world"两个字符串对象
而后把它们拼接起来 (底层使用StringBuilder实现, 后面会带你们读反编译代码)
在拼接完成后会产生新的"hello world"对象, 这时变量s1指向新对象"hello world".

执行完第一行代码后, 内存是这样子的:

第二行代码s1.intern();
String类的源码中有对intern()方法的详细介绍, 翻译过来的意思是: 当调用intern()方法时, 首先会去常量池中查找是否有该字符串对应的引用, 若是有就直接返回该字符串; 若是没有, 就会在常量池中注册该字符串的引用, 而后返回该字符串.
因为第一行代码采用的是new的方式建立字符串, 因此在字符串常量池中没有保存"hello world"对应的引用, 虚拟机会在常量池中进行注册, 注册完后的内存示意图以下:

第三行代码String s2 = "hello world";
这种直接经过双引号""声明字符串背后的运行机制咱们在第一个案例提到过, 这里正好复习一下.
首先虚拟机会去检查字符串常量池, 发现有指向"hello world"的引用. 而后把该引用所指向的字符串直接返回给所属变量.
执行完第三行代码后, 内存示意图以下:

如图所示, s1和s2指向的是相同的对象, 因此当判断s1 == s2时返回true.

最后咱们对字符串常量池进行总结: 当用new关键字建立字符串对象时, 不会查询字符串常量池; 当用双引号直接声明字符串对象时, 虚拟机将会查询字符串常量池. 说白了就是: 字符串常量池提供了字符串的复用功能, 除非咱们要显式建立新的字符串对象, 不然对同一个字符串虚拟机只会维护一份拷贝.

配合反编译代码验证字符串初始化操做.

相信看到这里, 再见到有关的面试题, 你已经无所畏惧了, 由于你已经懂得了背后原理.
在结束以前咱们不妨再作一道压轴题

public class Main {
    public static void main(String[] args) {
        String s1 = "hello ";
        String s2 = "world";
        String s3 = s1 + s2;
        String s4 = "hello world";
        System.out.println(s3 == s4);
    }
}
复制代码

这道压轴题是通过精心设计的, 它不但照应上面所讲的字符串常量池知识, 也引出了后面的话题.算法

若是看这篇文章是你第一次往底层探索字符串的经历, 那我估计你不能当即给出答案. 由于我第一次见这几行代码时也卡壳了.
首先第一行和第二行是常规的字符串对象声明, 咱们已经很熟悉了, 它们分别会在堆内存建立字符串对象, 并会在字符串常量池中进行注册.
影响咱们作出判断的是第三行代码String s3 = s1 + s2;, 咱们不知道s1 + s2在建立完新字符串"hello world"后是否会在字符串常量池进行注册. 说白了就是咱们不知道这行代码是以双引号""形式声明字符串, 仍是用new关键字建立字符串.
这时, 咱们应该去读一读这段代码的反编译代码. 若是你没有读过反编译代码, 不妨借此机会入门.
在命令行中输入javap -c 对应.class文件的绝对路径, 按回车后便可看到反编译文件的代码段.

C:\Users\liuyj>javap -c C:\Users\liuyj\IdeaProjects\Test\target\classes\forTest\Main.class
Compiled from "Main.java"
public class forTest.Main {
  public forTest.Main();
    Code:
       0: aload_0
       1: invokespecial #1 // Method java/lang/Object."<init>":()V
       4: return

  public static void main(java.lang.String[]);
    Code:
       0: ldc           #2 // String hello
       2: astore_1
       3: ldc           #3 // String world
       5: astore_2
       6: new           #4 // class java/lang/StringBuilder
       9: dup
      10: invokespecial #5 // Method java/lang/StringBuilder."<init>":()V
      13: aload_1
      14: invokevirtual #6 // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
      17: aload_2
      18: invokevirtual #6 // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
      21: invokevirtual #7 // Method java/lang/StringBuilder.toString:()Ljava/lang/String;
      24: astore_3
      25: ldc           #8 // String hello world
      27: astore        4
      29: getstatic     #9 // Field java/lang/System.out:Ljava/io/PrintStream;
      32: aload_3
      33: aload         4
      35: if_acmpne     42
      38: iconst_1
      39: goto          43
      42: iconst_0
      43: invokevirtual #10 // Method java/io/PrintStream.println:(Z)V
      46: return
}
复制代码

首先调用构造器完成Main类的初始化
0: ldc #2 // String hello
从常量池中获取"hello "字符串并推送至栈顶, 此时拿到了"hello "的引用
2: astore_1
将栈顶的字符串引用存入第二个本地变量s1, 也就是s1已经指向了"hello "
3: ldc #3 // String world
5: astore_2
重复开始的步骤, 此时变量s2指向"word"
6: new #4 // class java/lang/StringBuilder
刺激的东西来了: 这时建立了一个StringBuilder, 并把其引用值压到栈顶
9: dup
复制栈顶的值, 并继续压入栈定, 也就意味着栈从上到下有两份StringBuilder的引用, 未来要操做两次StringBuilder.
10: invokespecial #5 // Method java/lang/StringBuilder."<init>":()V
调用StringBuilder的一些初始化方法, 静态方法或父类方法, 完成初始化.
13: aload_1
把第二个本地变量也就是s1压入栈顶, 如今栈顶从上往下数两个数据依次是:s1变量和StringBuilder的引用
14: invokevirtual #6 // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
调用StringBuilder的append方法, 栈顶的两个数据在这里调用方法时就用上了.
接下来又调用了一次append方法(以前StringBuilder的引用拷贝两份就用途在此)
完成后, StringBuilder中已经拼接好了"hello world", 看到这里相信你们已经明白虚拟机是如何拼接字符串的了. 接下来就是关键环节

21: invokevirtual #7 // Method java/lang/StringBuilder.toString:()Ljava/lang/String;
24: astore_3
拼接完字符串后, 虚拟机调用StringBuilder的toString()方法得到字符串hello world, 并存放至s3.
激动人心的时刻来了, 咱们之因此不知道这道题的答案是由于不知道字符串拼接后是以new的形式仍是以双引号""的形式建立字符串对象.
下面是咱们追踪StringBuilder的toString()方法源码:

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

ok, 这道题解了, s3是经过new关键字得到字符串对象的.
回到题目, 也就是说字符串常量表中没有存储"hello world"的引用, 当s4以引号的形式声明字符串时, 因为在字符串常量池中查不到相应的引用, 因此会在堆内存中新建立一个字符串对象. 因此s3和s4指向的不是同一个字符串对象, 结果为false.

详解字符串操做类

明白了字符串常量池, 我相信关于字符串的建立你已经有十足的把握了. 可是这还不够, 做为一名合格的Java工程师, 咱们还必须对字符串的操做作到了如指掌. 注意! 不是说你不用查api能熟练操做字符串就了如指掌了, 而是说对String, StringBuilder, StringBuffer三大字符串操做类背后的实现了然于胸, 这样才能在开发的过程当中作出正确, 高效的选择.

String, StringBuilder, StringBuffer的底层实现

点进String的源码, 咱们能够看见String类是经过char类型数组实现的.

public final class String implements java.io.Serializable, Comparable<String>, CharSequence {
    /** The value is used for character storage. */
    private final char value[];
    ...
}    
复制代码

接着查看StringBuilder和StringBuffer的源码, 咱们发现这二者都继承自AbstractStringBuilder类, 经过查看该类的源码, 得知StringBuilder和StringBuffer两个类也是经过char类型数组实现的

abstract class AbstractStringBuilder implements Appendable, CharSequence {
    /** * The value is used for character storage. */
    char[] value;
    ...
}
复制代码

并且经过StringBuilder和StringBuffer继承自同一个父类这点, 咱们能够推断出它俩的方法都是差很少的. 经过查看源码也发现确实如此, 只不过StringBuffer在方法上添加了synchronized关键字, 证实它的方法绝大多数方法都是线程同步方法. 也就是说在多线程的环境下咱们应该使用StringBuffer以保证线程安全, 在单线程环境下咱们应使用StringBuilder以得到更高的效率.编程
既然如此, 咱们的比较也就落到了StringBuilder和String身上了.api

关于StringBuilder和String之间的讨论

经过查看StringBuilder和String的源码咱们会发现二者之间一个关键的区别: 对于String, 凡是涉及到返回参数类型为String类型的方法, 在返回的时候都会经过new关键字建立一个新的字符串对象; 而对于StringBuilder, 大多数方法都会返回StringBuilder对象自身.

/** * 下面截取几个String类的方法 */
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);
}

public String concat(String str) {
    int otherLen = str.length();
    if (otherLen == 0) {
        return this;
    }
    int len = value.length;
    char buf[] = Arrays.copyOf(value, len + otherLen);
    str.getChars(buf, len);
    return new String(buf, true);
}

/** * 下面截取几个StringBuilder类的方法 */
@Override
public StringBuilder append(String str) {
    super.append(str);
    return this;
}

@Override
public StringBuilder replace(int start, int end, String str) {
    super.replace(start, end, str);
    return this;
}
复制代码

就由于这点区别, 使得二者在操做字符串时在不一样的场景下会体现出不一样的效率.
下面仍是以拼接字符串为例比较一下二者的性能

public class Main {
    public static int time = 50000;

    public static void main(String[] args) {
        long start = System.currentTimeMillis();
        String s = "";
        for(int i = 0; i < time; i++){
            s += "test";
        }
        long end = System.currentTimeMillis();
        System.out.println("String类使用时间: " + (end - start) + "毫秒");

    }
}
//String类使用时间: 4781毫秒
复制代码

public class Main {
    public static int time = 50000;

    public static void main(String[] args) {
        long start = System.currentTimeMillis();
        StringBuilder sb = new StringBuilder();
        for(int i = 0; i < time; i++){
            sb.append("test");
        }
        long end = System.currentTimeMillis();
        System.out.println("StringBuilder类使用时间: " + (end - start) + "毫秒");

    }
}
//StringBuilder类使用时间: 5毫秒
复制代码

就拼接5万次字符串而言, StringBuilder的效率是String类的956倍.
咱们再次经过反编译代码看看形成二者性能差距的缘由, 先看String类. (为了方便阅读代码, 我删除了计时部分的代码, 并从新编译, 获得的main方法反编译代码以下)

public static void main(java.lang.String[]);
    Code:
       0: ldc           #2                  // String, 将""空字符串加载到栈顶
       2: astore_1                          //存放到s变量中
       3: iconst_0                          //把int型数0压栈
       4: istore_2                          //存到变量i中
       5: iload_2                           //把i的值压到栈顶(0)
       6: getstatic     #3                  // Field time:I 拿到静态变量time的值, 压到栈顶
       9: if_icmpge     38                  // 比较栈顶两个int值, for循环中的断定, 若是i比time小就继续执行, 不然跳转
       
//从这里开始, 就是for循环部分
      12: new           #4                  // class java/lang/StringBuilder
      15: dup
      16: invokespecial #5                  // Method java/lang/StringBuilder."<init>":()V
      19: aload_1
      20: invokevirtual #6                  // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
      23: ldc           #7                  // String test
      25: invokevirtual #6                  // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
      28: invokevirtual #8                  // Method java/lang/StringBuilder.toString:()Ljava/lang/String;
      31: astore_1                          //每拼接完一次, 就把新的字符串对象引用保存在第二个本地变量中
//到这里一次for循环结束
      32: iinc          2, 1                //变量i加1
      35: goto          5                   //继续循环
      38: return
复制代码

从反汇编代码中能够看到, 当用String类拼接字符串时, 每次都会生成一个StringBuilder对象, 而后调用两次append()方法把字符串拼接好, 最后经过StringBuilder的toString()方法new出一个新的字符串对象.数组
也就是说每次拼接都会new出两个对象, 并进行两次方法调用, 若是拼接的次数过多, 建立对象所带来的时延会下降系统效率, 同时会形成巨大的内存浪费. 并且当内存不够用时, 虚拟机会进行垃圾回收, 这也是一项至关耗时的操做, 会大大下降系统性能. 安全
下面是使用StringBuilder拼接字符串获得的反编译代码.bash

public static void main(java.lang.String[]);
    Code:
       0: new           #2                  // class java/lang/StringBuilder
       3: dup
       4: invokespecial #3                  // Method java/lang/StringBuilder."<init>":()V
       7: astore_1
       8: iconst_0
       9: istore_2
      10: iload_2
      11: getstatic     #4                  // Field time:I
      14: if_icmpge     30

//从这里开始执行for循环内的代码
      17: aload_1
      18: ldc           #5                  // String test
      20: invokevirtual #6                  // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
      23: pop
//到这里一次for循环结束      
      24: iinc          2, 1
      27: goto          10
      30: return
复制代码

能够看到StringBuilder拼接字符串就简单多了, 直接把要拼接的字符串放到栈顶进行append就完事了, 除了开始时建立了StringBuilder对象, 运行时期没有建立过其余任何对象, 每次循环只调用一次append方法. 因此从效率上看, 拼接大量字符串时, StringBuilder要比String类给力得多.

固然String类也不是没有优点的, 从操做字符串api的丰富度上来说, String是要多于StringBuilder的, 在平常操做中不少业务都须要用到String类的api.
在拼接字符串时, 若是是简单的拼接, 好比说String s = "hello " + "world";, String类的效率会更高一点.
但若是须要拼接大量字符串, StringBuilder无疑是更合适的选择.

讲到这里, Java中的字符串背后的原理就讲得差很少, 相信在了解虚拟机操做字符串的细节后, 你在使用字符串时会更加驾轻就熟. 字符串是编程中一个重要的话题, 本文围绕Java体系讲解的字符串知识只是字符串知识的冰山一角. 字符串操做的背后是数据结构和算法的应用, 如何可以以尽量低的时间复杂度去操做字符串, 又是一门大学问.