深度解析String s=“1“生成几个对象系列问题

JVM中的常量池

说字符串之前要说一下jvm中的常量池，JVM中常量池有三个：

1.运行时常量池 （常说的常量池，HSDB可以看到，InstanceKlass的一个属性 ConstantPool* _constants; 存在方法区（jdk1.8元空间））

2.字符串常量池 （String pool 存在堆中）

3.class文件中的常量池 （Constant pool ， javap -v 可以看到， 存在硬盘上）

该篇重点看字符串常量池，先看一下字符串常量池的结构：

即String Pool，但是JVM中对应的类是StringTable，底层实现是一个hashtable，

其openjdk的源码为：

class StringTable : public Hashtable<oop, mtSymbol> {

那么StringTable的key和value又是什么呢？

key:通过String的内容+长度生成hash值，再将hash值转为key

value：将Java的String类的实例instanceOopDesc封装成HashtableEntry

问：

为什么map的key多是String而不是其他基本类型？

答：

最关键的是String中缓存有个hash变量，它可以缓存hashCode，避免重复计算hashCode

不同方式创建字符串在JVM中的存在形式

结合着demo来说明字符串的一些问题

demo1

public void test1(){
        String s1 = "1";
    }

main方法忽略，就是直接调用这个方法，问生成几个对象？

首先在 String s1 = "1";做断点，在idea中查看

debug放行，查看对象数量变化

发现char[]和String都增加了1，我们看一下String的结构。

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

在最开始有一个char[]类型的属性，也就是说新增的char[]其实就是这个属性。

现在就可以回答刚刚那个问题，创建了几个对象？

答：两个oop对象，一个char[]和一个string对应的instanceOOP；字符串对象只生成了一个（s1）。

图示：先生成一个String对象，然后去找字符串常量池是不是有1这个值，

如果有，则直接拿；如果没有则去创建一个char[]对象，将1这个值存进去，并将1存到常量池中。

demo2

public void test2(){
        String s = new String("2");
    }

创建了几个对象？

答：三个oop对象，一个char[]和两个string对应的instanceOOP；字符串对象生成了两个（s和new String（））。

图示：new的方式，在原基础上新增了一个String对应的oop对象，因为是把new出来的赋给了s

demo3

public void test3(){
    String s1 = new String("3");
    String s2 = new String("3");
}

创建了几个对象？

答：四个oop对象，一个char[]和三个string对应的instanceOOP；字符串对象生成了三个（s1  new String () s2）。

图示：生成两个不同的String对象分别指向同一个值。

demo4

public void test4(){
        String s1 = "4";
        String s2 = "4";
    }

创建了几个对象？

答：两个oop对象，一个char[]和一个string对应的instanceOOP；字符串对象生成了一个（s1）。

demo5

public void test5(){
        String s = new String(new char[]{'1','2'},0,2);
        String s2 = new String("12");
    }

创建了几个对象？

答：这个主要是分析三个参数和一个参数创建的区别，

一个参数就是2String+1char[]；

三个参数是一个String和一个char[]，为什么？因为这个构造方法底层没有产生new String并且没有在常量池中生成记录，所以后面的12常量又创建了一次。

demo6

public void test6(){
        String s1 = "6";
        String s2 = "6";
        String s = s1+s2;
    }

这个主要是分析字符串拼接的问题，其 String s = s1+s2;编译后的代码是new StringBuilder().append("6").append("6").toString();

而StringBuilder的toString()方法为：

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

最终就是三个参数那个示例。

  String s = s1+s2;创建了几个对象？

答：  String s = s1+s2;这句创建了两个OOP对象，一个char[]和一个string对应的instanceOOP；字符串对象生成了一个（s），这个s1+s2得到的值并没有存入字符串常量。

demo7

public void test7(){
        String s1 = "7";
        String s2 = "7";

        String s = s1+s2;
        s.intern();
        //intern就是将s写入了常量池
        String str = "77";
        System.out.println(s==str);
    }

这里用到了intern方法，这个方法主要作用就是如果常量池里有s的值，则直接返回，没有的话将s的值放入字符串常量池

String str = "77";创建了几个对象？

答：  String str = "77";这句创建了一个OOP对象，string对应的instanceOOP；字符串对象生成了一个（str），因为字符串常量池中已经被intern方法放入了77所以不会再次创建。

demo8

 public void test8(){
        final String s1 = "8";
        final String s2 = "8";
        String s = s1+s2;
        String str = "88";
    }

这里对String加了final修饰，所以在编译期就已经将s1当作常量处理了， String s = s1+s2;编译过后其实就是 String s =”8“+”8“; 运算时会直接当作”88“处理

整个过程生成了几个对象？

答：创建了4个oop对象，两个char[]（"8"和"88"）和两个string对应的instanceOOP；字符串对象生成了两个（s1 s）

demo9

 public void test9(){
        final String s1 = new String("9");
        final String s2 = new String("9");
        String s = s1+s2;
        String str = "99";
    }

这里对String的引用做了final操作，并没有对new String的值进行final修饰（这个机制是class懒加载机制），所以在  String s = s1+s2;并不能转换成”99“，其底层就又回到了

new StringBuilder().append("9").append("9").toString();所以也没有将99放入到字符串常量池中，最后创建String str = "99";又创建了一次char[]

整个过程生成了几个对象？

答：创建了8个oop对象，3个char[]（"8"和"88"）和5个string对应的instanceOOP；字符串对象生成了5个（s1 ,new String(), s2, s,str）

demo10

        String s1 = "5";  //生成一个String s1 和一个char 5
        String s2 = "6";  //生成一个String s2 和一个char 6
        String s= s1+s2+new String("7");  //生成两个String （new String 和 s） 两个char 56
        //最终生成4String和4char

        String ss = "1"+"2"+new String("3");  // 三个字符串一个字符串 “12” 一个new String 一个ss
        //三个char "12" "3"  "123"

整个过程生成了几个对象？

答：第一段代码生成4String和4char[] ，第二段代码生成3String和3char[]