乐趣区

关于java:全网最详细最有深度超过1W字深度剖析JVM常量池

作者：

jiezi

在

面试题：String a = “ab”; String b = “a” + “b”; a == b 是否相等

面试考察点

考查目标：考查对JVM基础知识的了解，波及到常量池、JVM运行时数据区等。

考查范畴：工作2到5年。

背景常识

要答复这个问题，须要搞明确两个最根本的问题

  1. String a=“ab”，在JVM中产生了什么？
  2. String b=“a”+“b”，底层是如何实现？

JVM的运行时数据

首先，咱们一起来温习一下JVM的运行时数据区。

为了让大家有一个全局的视角，我从类加载，到JVM运行时数据区的整体构造画进去，如下图所示。

对于每一个区域的作用，在我之前的面试系列文章中有具体阐明，这里就不做复述了。

在上图中，咱们须要重点关注几个类容：

  1. 字符串常量池
  2. 封装类常量池
  3. 运行时常量池
  4. JIT编译器

这些内容都和本次面试题有十分大的关联关系，这里对于常量池局部的内容，先保留一个疑难，先追随我来学习一下JVM中的常量池。

JVM中都有哪些常量池

大家常常会听到各种常量池，然而又不晓得这些常量池到底存储在哪里，因而会有很多的疑难：JVM中到底有哪些常量池？

JVM中的常量池能够分成以下几类：

  1. Class文件常量池
  2. 全局字符串常量池
  3. 运行时常量池

Class文件常量池

每个Class文件的字节码中都有一个常量池，外面次要寄存编译器生成的各种字面量和符号援用。为了更直观的了解，咱们编写上面这个程序。

public class StringExample {
    private int value = 1;
    public final static int fs=101;

    public static void main(String[] args) {
        String a="ab";
        String b="a"+"b";
        String c=a+b;
    }
}

上述程序编译后，通过javap -v StringExample.class查看该类的字节码文件，截取局部内容如下。

Constant pool:
   #1 = Methodref          #9.#32         // java/lang/Object."<init>":()V
   #2 = Fieldref           #8.#33         // org/example/cl07/StringExample.value:I
   #3 = String             #34            // ab
   #4 = Class              #35            // java/lang/StringBuilder
   #5 = Methodref          #4.#32         // java/lang/StringBuilder."<init>":()V
   #6 = Methodref          #4.#36         // java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StrvalueingBuilder;
   #7 = Methodref          #4.#37         // java/lang/StringBuilder.toString:()Ljava/lang/String;
   #8 = Class              #38            // org/example/cl07/StringExample
   #9 = Class              #39            // java/lang/Object
  #10 = Utf8               value
  #11 = Utf8               I
  #12 = Utf8               fs
  #13 = Utf8               ConstantValue
  #14 = Integer            101
  #15 = Utf8               <init>
  #16 = Utf8               ()V
  #17 = Utf8               Code
  #18 = Utf8               LineNumberTable
  #19 = Utf8               LocalVariableTable
  #20 = Utf8               this
  #21 = Utf8               Lorg/example/cl07/StringExample;
  #22 = Utf8               main
  #23 = Utf8               ([Ljava/lang/String;)V
  #24 = Utf8               args
  #25 = Utf8               [Ljava/lang/String;
  #26 = Utf8               a
  #27 = Utf8               Ljava/lang/String;
  #28 = Utf8               b
  #29 = Utf8               c
  #30 = Utf8               SourceFile
  #31 = Utf8               StringExample.java
  #32 = NameAndType        #15:#16        // "<init>":()V
  #33 = NameAndType        #10:#11        // value:I
  #34 = Utf8               ab
  #35 = Utf8               java/lang/StringBuilder
  #36 = NameAndType        #40:#41        // append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
  #37 = NameAndType        #42:#43        // toString:()Ljava/lang/String;
  #38 = Utf8               org/example/cl07/StringExample
  #39 = Utf8               java/lang/Object
  #40 = Utf8               append
  #41 = Utf8               (Ljava/lang/String;)Ljava/lang/StringBuilder;
  #42 = Utf8               toString
  #43 = Utf8               ()Ljava/lang/String;

咱们关注一下Constant pool形容的局部，示意Class文件的常量池。在该常量池中次要寄存两类常量。

  1. 字面量。
  2. 符号援用。

字面量

  • 字面量，给根本类型变量赋值的形式就叫做字面量或者字面值。比方：String a=“b” ，这里“b”就是字符串字面量，同样类推还有整数字面值、浮点类型字面量、字符字面量。

    在上述代码中，字面量常量的字节码为:

    #3 = String             #34            // ab
#26 = Utf8               a
#34 = Utf8               ab

  • 用final润饰的成员变量、动态变量、实例变量、局部变量，比方：

      #11 = Utf8               I
  #12 = Utf8               fs
  #13 = Utf8               ConstantValue
  #14 = Integer            101

从下面的字节码来看，字面量和final润饰的属性是保留在常量池中，这些存在于常量池的字面量，指得是数据的值，比方ab，101。

对于根本数据类型，比方private int value=1，在常量池中只保留了他的字段描述符（I）和字段名称(value)，它的字面量不会存在与常量池。

  #10 = Utf8               value
  #11 = Utf8               I

另外，对于String c=a+b;，c这个属性的值也没有保留到常量池，因为在编译期间，a和b的值时不确定的。

#29 = Utf8               c
#35 = Utf8               java/lang/StringBuilder
#36 = NameAndType        #40:#41        // append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
#37 = NameAndType        #42:#43        // toString:()Ljava/lang/String;
#39 = Utf8               java/lang/Object
#40 = Utf8               append
#41 = Utf8               (Ljava/lang/String;)Ljava/lang/StringBuilder;

如果，咱们把代码批改成上面这种模式

public static void main(String[] args) {
  final String a="ab";
  final String b="a"+"b";
  String c=a+b;
}

从新生成字节码之后，能够看到字节码产生了变动，c这个属性的值abab也保留到了常量池中。

#26 = Utf8               c
#27 = Utf8               SourceFile
#28 = Utf8               StringExample.java
#29 = NameAndType        #12:#13        // "<init>":()V
#30 = NameAndType        #7:#8          // value:I
#31 = Utf8               ab
#32 = Utf8               abab

符号援用

符号援用次要设波及编译原理方面的概念，包含上面三类常量:

  1. 类和接口的全限定名(Full Qualified Name)，也就是Ljava/lang/String;，次要用于在运行时解析失去类的间接援用。

      #23 = Utf8               ([Ljava/lang/String;)V
  #25 = Utf8               [Ljava/lang/String;
  #27 = Utf8               Ljava/lang/String;

  2. 字段的名称和描述符(Descriptor)，字段也就是类或者接口中申明的变量，包含类级别变量(static)和实例级的变量。

    #1 = Methodref          #9.#32         // java/lang/Object."<init>":()V
#2 = Fieldref           #8.#33         // org/example/cl07/StringExample.value:I
#3 = String             #34            // ab
#4 = Class              #35            // java/lang/StringBuilder
#5 = Methodref          #4.#32         // java/lang/StringBuilder."<init>":()V
#6 = Methodref          #4.#36         // java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StrvalueingBuilder;
#7 = Methodref          #4.#37         // java/lang/StringBuilder.toString:()Ljava/lang/String;
#8 = Class              #38            // org/example/cl07/StringExample

#24 = Utf8               args
#26 = Utf8               a
#28 = Utf8               b
#29 = Utf8               c

  1. 办法的名称和描述符,办法的形容相似于JNI动静注册时的“办法签名”，也就是参数类型+返回值类型，比方上面的这种字节码，示意main办法和String返回类型。

      #19 = Utf8               main
  #20 = Utf8               ([Ljava/lang/String;)V

小结：在Class文件中，存在着一些不会发生变化的货色，比方一个类的名字、类的字段名字/所属数据类型、办法名称/返回类型/参数名、常量、字面量等。这些在JVM解释执行程序的时候十分重要，所以编译器将源代码编译成class文件之后，会用一部分字节分类存储这些不变的代码，而这些字节咱们就称为常量池。

运行时常量池

运行时常量池是每一个类或者接口的常量池（Constant Pool)的运行时的表现形式。

咱们晓得，一个类的加载过程，会通过：加载、连贯（验证、筹备、解析）、初始化的过程，而在类加载这个阶段，须要做以下几件事件：

  1. 通过一个类的全类限定名获取此类的二进制字节流。
  2. 在堆内存生成一个java.lang.Class对象,代表加载这个类,做为这个类的入口。
  3. 将class字节流的动态存储构造转化成办法区(元空间）的运行时数据结构。

而其中第三点，将class字节流代表的动态贮存构造转化为办法区的运行时数据结构这个过程，就蕴含了class文件常量池进入运行时常量池的过程。

所以，运行时常量池的作用是存储class文件常量池中的符号信息，在类的解析阶段会把这些符号援用转换成间接援用(实例对象的内存地址),翻译进去的间接援用也是存储在运行时常量池中。class文件常量池的大部分数据会被加载到运行时常量池。

运行时常量池保留在办法区（JDK1.8元空间）中，它是全局共享的，不同的类共用一个运行时常量池。

另外，运行时常量池具备动态性的特色，它的内容并不是全副起源与编译后的class文件，在运行时也能够通过代码生成常量并放入运行时常量池。比方String.intern()办法。

字符串常量池

字符串常量池，简略来说就是专门针对String类型设计的常量池。

字符串常量池的罕用创立形式有两种。

String a="Hello";
String b=new String("Mic");
  1. a这个变量，是在编译期间就曾经确定的，会进入到字符串常量池。
  2. b这个变量，是通过new关键字实例化，new是创立一个对象实例并初始化该实例，因而这个字符串对象是在运行时能力确定的，创立的实例在堆空间上。

字符串常量池存储在堆内存空间中，创立模式如下图所示。

当应用String a=“Hello”这种形式创立字符串对象时，JVM首先会先查看该字符串对象是否存在与字符串常量池中，如果存在，则间接返回常量池中该字符串的援用。否则，会在常量池中创立一个新的字符串，并返回常量池中该字符串的援用。（这种形式能够缩小同一个字符串被反复创立，节约内存，这也是享元模式的体现）。

如下图所示，如果再通过String c=“Hello”创立一个字符串，发现常量池曾经存在了Hello这个字符串，则间接把该字符串的援用返回即可。（String外面的享元模式设计）

当应用String b=new String(“Mic”)这种形式创立字符串对象时，因为String自身的不可变性（后续剖析），因而在JVM编译过程中，会把Mic放入到Class文件的常量池中，在类加载时，会在字符串常量池中创立Mic这个字符串。接着应用new关键字，在堆内存中创立一个String对象并指向常量池中Mic字符串的援用。

如下图所示，如果再通过new String(“Mic”)创立一个字符串对象，此时因为字符串常量池曾经存在Mic，所以只须要在堆内存中创立一个String对象即可。

简略总结一下：JVM之所以独自设计字符串常量池，是JVM为了进步性能以及缩小内存开销的一些优化：

  1. String对象作为Java语言中重要的数据类型，是内存中占据空间最大的一个对象。高效地应用字符串，能够晋升零碎的整体性能。
  2. 创立字符串常量时，首先查看字符串常量池是否存在该字符串，如果有，则间接返回该援用实例，不存在，则实例化该字符串放入常量池中。

字符串常量池是JVM所保护的一个字符串实例的援用表，在HotSpot VM中，它是一个叫做StringTable的全局表。在字符串常量池中保护的是字符串实例的援用，底层C++实现就是一个Hashtable。这些被保护的援用所指的字符串实例，被称作”被驻留的字符串”或”interned string”或通常所说的”进入了字符串常量池的字符串”!

封装类常量池

除了字符串常量池，Java的根本类型的封装类大部分也都实现了常量池。包含Byte,Short,Integer,Long,Character,Boolean

留神，浮点数据类型Float,Double是没有常量池的。

封装类的常量池是在各自外部类中实现的，比方IntegerCache(Integer的外部类)。要留神的是，这些常量池是有范畴的：

  • Byte,Short,Integer,Long : [-128~127]
  • Character : [0~127]
  • Boolean : [True, False]

测试代码如下：

public static void main(String[] args) {
  Character a=129;
  Character b=129;
  Character c=120;
  Character d=120;
  System.out.println(a==b);
  System.out.println(c==d);
  System.out.println("...integer...");
  Integer i=100;
  Integer n=100;
  Integer t=290;
  Integer e=290;
  System.out.println(i==n);
  System.out.println(t==e);
}

运行后果：

false
true
...integer...
true
false

封装类的常量池，其实就是在各个封装类外面本人实现的缓存实例（并不是JVM虚拟机层面的实现），如在Integer中，存在IntegerCache，提前缓存了-128~127之间的数据实例。意味着这个区间内的数据，都采纳同样的数据对象。这也是为什么下面的程序中，通过==判断失去的后果为true。

这种设计其实就是享元模式的利用。

private static class IntegerCache {
  static final int low = -128;
  static final int high;
  static final Integer cache[];

  static {
    // high value may be configured by property
    int h = 127;
    String integerCacheHighPropValue =
      sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high");
    if (integerCacheHighPropValue != null) {
      try {
        int i = parseInt(integerCacheHighPropValue);
        i = Math.max(i, 127);
        // Maximum array size is Integer.MAX_VALUE
        h = Math.min(i, Integer.MAX_VALUE - (-low) -1);
      } catch( NumberFormatException nfe) {
        // If the property cannot be parsed into an int, ignore it.
      }
    }
    high = h;

    cache = new Integer[(high - low) + 1];
    int j = low;
    for(int k = 0; k < cache.length; k++)
      cache[k] = new Integer(j++);

    // range [-128, 127] must be interned (JLS7 5.1.7)
    assert IntegerCache.high >= 127;
  }

  private IntegerCache() {}
}

封装类常量池的设计初衷其实String雷同，也是针对频繁应用的数据区间进行缓存，防止频繁创建对象的内存开销。

对于字符串常量池的问题摸索

在上述常量池中，对于String字符串常量池的设计，还有很多问题须要摸索：

  1. 如果常量池中曾经存在某个字符串常量，后续定义雷同字符串的字面量时，是如何指向同一个字符串常量的援用？也就是上面这段代码的断言后果是true。

    String a="Mic";
String b="Mic";
assert(a==b); //true
  1. 字符串常量池的容量到底有多大？
  2. 为什么要设计针对字符串独自设计一个常量池？

为什么要设计针对字符串独自设计一个常量池？

首先，咱们来看一下String的定义。

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

    /** Cache the hash code for the string */
    private int hash; // Default to 0
}

从上述源码中能够发现。

  1. String这个类是被final润饰的，代表该类无奈被继承。
  2. String这个类的成员属性value[]也是被final润饰，代表该成员属性不可被批改。

因而String具备不可变的个性，也就是说String一旦被创立，就无奈更改。这么设计的益处有几个。

  1. 不便实现字符串常量池：在Java中，因为会大量的应用String常量，如果每一次申明一个String都创立一个String对象，那将会造成极大的空间资源的节约。Java提出了String pool的概念，在堆中开拓一块存储空间String pool，当初始化一个String变量时，如果该字符串曾经存在了，就不会去创立一个新的字符串变量，而是会返回曾经存在了的字符串的援用。如果字符串是可变的，某一个字符串变量扭转了其值，那么其指向的变量的值也会扭转，String pool将不可能实现！
  2. 线程安全性，在并发场景下，多个线程同时读一个资源，是平安的，不会引发竞争，但对资源进行写操作时是不平安的，不可变对象不能被写，所以保障了多线程的平安。
  3. 保障 hash 属性值不会频繁变更。确保了唯一性，使得相似HashMap容器能力实现相应的key-value缓存性能，于是在创建对象时其hashcode就能够释怀的缓存了，不须要从新计算。这也就是Map喜爱将String作为Key的起因，处理速度要快过其它的键对象。所以HashMap中的键往往都应用String。

留神，因为String的不可变性能够不便实现字符串常量池这一点很重要，这时实现字符串常量池的前提。

字符串常量池，其实就是享元模式的设计，它和在JDK中提供的IntegerCache、以及Character等封装对象的缓存设计相似，只是String是JVM层面的实现。

字符串的调配，和其余的对象调配一样，消耗昂扬的工夫与空间代价。JVM为了进步性能和缩小内存开销，在实例化字符串常量的时候进行了一些优化。为 了缩小在JVM中创立的字符串的数量，字符串类保护了一个字符串池，每当代码创立字符串常量时，JVM会首先查看字符串常量池。如果字符串曾经存在池中， 就返回池中的实例援用。如果字符串不在池中，就会实例化一个字符串并放到池中。Java可能进行这样的优化是因为字符串是不可变的，能够不必放心数据抵触 进行共享。

咱们把字符串常量池当成是一个缓存，通过双引号定义一个字符串常量时，首先从字符串常量池中去查找，找到了就间接返回该字符串常量池的援用，否则就创立一个新的字符串常量放在常量池中。

常量池有多大呢?

我想大家肯定和我一样好奇，常量池到底能存储多少个常量？

后面咱们说过，常量池实质上是一个hash表，这个hash示意不可动静扩容的。也就意味着极有可能呈现单个 bucket 中的链表很长，导致性能升高。

在JDK1.8中，这个hash表的固定Bucket数量是60013个，咱们能够通过上面这个参数配置指定数量

-XX:StringTableSize=N

能够减少上面这个虚拟机参数，来打印常量池的数据。

-XX:+PrintStringTableStatistics

减少参数后，运行上面这段代码。

public class StringExample {
    private int value = 1;
    public final static int fs=101;

    public static void main(String[] args) {
        final String a="ab";
        final String b="a"+"b";
        String c=a+b;
    }
}

在JVM退出时，会打印常量池的应用状况如下:

SymbolTable statistics:
Number of buckets       :     20011 =    160088 bytes, avg   8.000
Number of entries       :     12192 =    292608 bytes, avg  24.000
Number of literals      :     12192 =    470416 bytes, avg  38.584
Total footprint         :           =    923112 bytes
Average bucket size     :     0.609
Variance of bucket size :     0.613
Std. dev. of bucket size:     0.783
Maximum bucket size     :         6
StringTable statistics:
Number of buckets       :     60013 =    480104 bytes, avg   8.000
Number of entries       :       889 =     21336 bytes, avg  24.000
Number of literals      :       889 =     59984 bytes, avg  67.474
Total footprint         :           =    561424 bytes
Average bucket size     :     0.015
Variance of bucket size :     0.015
Std. dev. of bucket size:     0.122
Maximum bucket size     :         2

能够看到字符串常量池的总大小是60013，其中字面量是889。

字面量是什么时候进入到字符串常量池的

字符串字面量，和其余根本类型的字面量或常量不同，并不会在类加载中的解析（resolve） 阶段填充并驻留在字符串常量池中，而是以非凡的模式存储在 运行时常量池（Run-Time Constant Pool） 中。而是只有当此字符串字面量被调用时（如对其执行ldc字节码指令，将其增加到栈顶），HotSpot VM才会对其进行resolve，为其在字符串常量池中创立对应的String实例。

具体来说，应该是在执行ldc指令时（该指令示意int、float或String型常量从常量池推送至栈顶）

在JDK1.8的HotSpot VM中，这种未真正解析（resolve）的String字面量，被称为pseudo-string，以JVM_CONSTANT_String的模式寄存在运行时常量池中，此时并未为其创立String实例。

在编译期，字符串字面量以”CONSTANT_String_info”+”CONSTANT_Utf8_info”的模式寄存在class文件的 常量池（Constant Pool） 中；

在类加载之后，字符串字面量以”JVM_CONSTANT_UnresolvedString(JDK1.7)”或者”JVM_CONSTANT_String(JDK1.8)”的模式寄存在 运行时常量池（Run-time Constant Pool） 中；

在首次应用某个字符串字面量时，字符串字面量以真正的String对象的形式寄存在 字符串常量池（String Pool） 中。

通过上面这段代码能够证实。

public static void main(String[] args) {
  String a =new String(new char[]{'a','b','c'});
  String b = a.intern();
  System.out.println(a == b);

  String x =new String("def");
  String y = x.intern();
  System.out.println(x == y);
}

应用new char[]{‘a’,’b’,’c’}构建的字符串，并没有在编译的时候应用常量池，而是在调用a.intern()时，将abc保留到常量池并返回该常量池的援用。

intern()办法

在Integer中的valueOf办法中，咱们能够看到，如果传递的值i是在IntegerCache.low和IntegerCache.high范畴以内，则间接从IntegerCache.cache中返回缓存的实例对象。

public static Integer valueOf(int i) {
  if (i >= IntegerCache.low && i <= IntegerCache.high)
    return IntegerCache.cache[i + (-IntegerCache.low)];
  return new Integer(i);
}

那么，在String类型中，既然存在字符串常量池，那么有没有办法可能实现相似于IntegerCache的性能呢？

答案是：intern()办法。因为字符串池是虚拟机层面的技术，所以在String的类定义中并没有相似IntegerCache这样的对象池，String类中提及缓存/池的概念只有intern() 这个办法。

/**
     * Returns a canonical representation for the string object.
     * <p>
     * A pool of strings, initially empty, is maintained privately by the
     * class {@code String}.
     * <p>
     * When the intern method is invoked, if the pool already contains a
     * string equal to this {@code String} object as determined by
     * the {@link #equals(Object)} method, then the string from the pool is
     * returned. Otherwise, this {@code String} object is added to the
     * pool and a reference to this {@code String} object is returned.
     * <p>
     * It follows that for any two strings {@code s} and {@code t},
     * {@code s.intern() == t.intern()} is {@code true}
     * if and only if {@code s.equals(t)} is {@code true}.
     * <p>
     * All literal strings and string-valued constant expressions are
     * interned. String literals are defined in section 3.10.5 of the
     * <cite>The Java&trade; Language Specification</cite>.
     *
     * @return  a string that has the same contents as this string, but is
     *          guaranteed to be from a pool of unique strings.
     */
public native String intern();

这个办法的作用是：去拿String的内容去Stringtable里查表，如果存在，则返回援用，不存在，就把该对象的”援用”保留在Stringtable表里。

比方上面这段程序：

public static void main(String[] args) {
  String str = new String("Hello World");
  String str1=str.intern();
  String str2 = "Hello World";
  System.out.print(str1 == str2);
}

运行的后果为：true。

实现逻辑如下图所示，str1通过调用str.intern()去常量池表中获取Hello World字符串的援用，接着str2通过字面量的模式申明一个字符串常量，因为此时Hello World曾经存在于字符串常量池中，所以同样返回该字符串常量Hello World的援用，使得str1和str2具备雷同的援用地址，从而运行后果为true。

总结：intern办法会从字符串常量池中查问以后字符串是否存在：

  • 若不存在就会将以后字符串放入常量池中，并返回当地字符串地址援用。
  • 如果存在就返回字符串常量池那个字符串地址。

留神，所有字符串字面量在初始化时，会默认调用intern()办法。

这段程序，之所以a==b，是因为申明a时，会通过intern()办法去字符串常量池中查找是否存在字符串Hello，因为不存在，则会创立一个。同理，变量b也同样如此，所以b在申明时，发现字符常量池中曾经存在Hello的字符串常量，所以间接返回该字符串常量的援用。

public static void main(String[] args) {
  String a="Hello";
  String b="Hello";
}

OK，学习到这里，是不是感觉本人懂了？我出一道题目来考考大家，上面这段程序的运行后果是什么？

public static void main(String[] args) {
  String a =new String(new char[]{'a','b','c'});
  String b = a.intern();
  System.out.println(a == b);

  String x =new String("def");
  String y = x.intern();
  System.out.println(x == y);
}

正确答案是：

true
false

第二个输入为false还能够了解，因为new String(“def”)会做两件事：

  1. 在字符串常量池中创立一个字符串def。
  2. new关键字创立一个实例对象string，并指向字符串常量池def的援用。

而x.intern()，是从字符串常量池获取def的援用，他们的指向地址不同，我前面的内容还会具体解释。

第一个输入后果为true是为啥捏？

JDK文档中对于intern()办法的阐明：当调用intern办法时，如果常量池（内置在 JVM 中的）中曾经蕴含雷同的字符串，则返回池中的字符串。否则，将此String对象增加到池中，并返回对该String对象的援用。

在构建String a的时候，应用new char[]{‘a’,’b’,’c’}初始化字符串时（不会主动调用intern()，字符串采纳懒加载形式进入到常量池），并没有在字符串常量池中构建abc这个字符串实例。所以当调用a.intern()办法时，会把该String对象增加到字符常量池中，并返回对该String对象的援用，所以a和b指向的援用地址是同一个。

问题答复

面试题：String a = “ab”; String b = “a” + “b”; a == b 是否相等

答复：a==b是相等的，起因如下：

  1. 变量a和b都是常量字符串，其中b这个变量，在编译时，因为不存在可变动的因素，所以编译器会间接把变量b赋值为ab（这个是属于编译器优化领域，也就是编译之后，b会保留到Class常量池中的字面量）。
  2. 对于字符串常量，初始化a时， 会在字符串常量池中创立一个字符串ab并返回该字符串常量池的援用。
  3. 对于变量b，赋值ab时，首先从字符串常量池中查找是否存在雷同的字符串，如果存在，则返回该字符串援用。
  4. 因而，a和b所指向的援用是同一个，所以a==b成立。

问题总结

对于常量池局部的内容，要比拟深刻和全面的了解，还是须要花一些工夫的。

比方大家通过浏览下面的内容，认为对字符串常量池有一个十分深刻的了解，能够，咱们再来看一个问题：

public static void main(String[] args) {
  String str = new String("Hello World");
  String str1=str.intern();
  System.out.print(str == str1);
}

下面这段代码，很显然返回false，起因如下图所示。很显著str和str1所指向的援用地址不是同一个。

然而咱们把上述代码革新一下：

public static void main(String[] args) {
  String str = new String("Hello World")+new String("!");
  String str1=str.intern();
  System.out.print(str == str1);
}

上述程序输入的后果变成了：true。为什么呢？

这里也是JVM编译器层面做的优化，因为String是不可变类型，所以实践上来说，上述程序的执行逻辑是：通过+进行字符串拼接时，相当于把原有的String变量指向的字符串常量HelloWorld取出来，加上另外一个String变量指向的字符串常量!，再生成一个新的对象。

假如咱们是通过for循环来对String变量进行拼接，那将会生成大量的对象，如果这些对象没有被及时回收，会造成十分大的内存节约。

所以JVM优化之后，其实是通过StringBuilder来进行拼接，也就是只会产生一个对象实例StringBuilder，而后再通过append办法来拼接。

为了证实我说的状况，来看一下上述代码的字节码。

 public static void main(java.lang.String[]);
    descriptor: ([Ljava/lang/String;)V
    flags: ACC_PUBLIC, ACC_STATIC
    Code:
      stack=4, locals=3, args_size=1
         0: new           #3                  // class java/lang/StringBuilder
         3: dup
         4: invokespecial #4                  // Method java/lang/StringBuilder."<init>":()V
         7: new           #5                  // class java/lang/String
        10: dup
        11: ldc           #6                  // String Hello World
        13: invokespecial #7                  // Method java/lang/String."<init>":(Ljava/lang/String;)V
        16: invokevirtual #8                  // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
        19: new           #5                  // class java/lang/String
        22: dup
        23: ldc           #9                  // String !
        25: invokespecial #7                  // Method java/lang/String."<init>":(Ljava/lang/String;)V
        28: invokevirtual #8                  // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
        31: invokevirtual #10                 // Method java/lang/StringBuilder.toString:()Ljava/lang/String;
        34: astore_1
        35: aload_1
        36: invokevirtual #11                 // Method java/lang/String.intern:()Ljava/lang/String;
        39: astore_2
        40: getstatic     #12                 // Field java/lang/System.out:Ljava/io/PrintStream;
        43: aload_1
        44: aload_2
        45: if_acmpne     52
        48: iconst_1
        49: goto          53
        52: iconst_0
        53: invokevirtual #13                 // Method java/io/PrintStream.print:(Z)V
        56: return

从字节码中能够看到，构建了一个StringBuilder，

 0: new           #3                  // class java/lang/StringBuilder

而后把字符串常量通过append办法进行拼接，最初调用toString()办法失去一个字符串常量。

16: invokevirtual #8                  // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
28: invokevirtual #8                  // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
31: invokevirtual #10                 // Method java/lang/StringBuilder.toString:()Ljava/lang/String;

因而，上述代码，等价于上面这种模式。

public static void main(String[] args) {
  StringBuilder sb=new StringBuilder().append(new String("Hello World")).append(new String("!"));
  String str=sb.toString();
  String str1=str.intern();
  System.out.print(str == str1);
}

所以，失去的后果是true。

基于这个问题的变体还有很多，比方再来变一次，上面这段程序的运行后果是多少？

public static void main(String[] args) {
  String s1 = "a";
  String s2 = "b";
  String s3 = "ab";
  String s4 = s1 + s2;
  System.out.println(s3 == s4);
}

答案是false。

因为上述程序等价于， s3和s4指向不同的地址援用，天然不相等。

public static void main(String[] args) {
  String s1 = "a";
  String s2 = "b";
  String s3 = "ab";
  StringBuilder sb=new StringBuilder().append(s1).append(s2);
  String s4 = sb.toString();
  System.out.println(s3 == s4);
}

总结：只有足够清晰的了解了字符串常量池相干的所有知识点，不论面试过程中如何变动，你都能精确答复，这就是常识的力量！

须要java学习材料的的小伙伴能够帮忙点赞+转发，关注小编一下后，戳此即可收费下载一份这套全面零碎的PDFJava外围面试题~

评论

发表回复

您的邮箱地址不会被公开。 必填项已用 * 标注

这个站点使用 Akismet 来减少垃圾评论。了解你的评论数据如何被处理。

更多文章