jvm学习String - 请叫我师哥

String基本特性

String声明为final的，不可被继承
String实现了Serializable接口：表示字符串是支持序列化的
String实现了Comparable接口：表示string可以比较大小
String在jdk8及以前内部定义了final char[ ] value用于存储字符串数据。JDK9时改为byte[ ]

String再也不用char[ ] 来存储了，改成了byte[ ] 加上编码标记，节约了一些空间

不可变性
- 当对字符串重新赋值时，需要重写指定内存区域赋值，不能使用原有的value进行赋值
- 对现有的字符串进行连接操作时，也需要重新指定内存区域赋值，不能使用原有的value进行赋值
- 当调用string的replace( )方法修改指定字符或字符串时，也需要重新指定内存区域赋值，不能使用原有的value进行赋值
通过字面量的方式（区别于new）给一个字符串赋值，此时的字符串值声明在字符串常量池中
字符串常量池是不会存储相同内容的字符串的
- String的String Pool是一个固定大小的Hashtable，默认值大小长度是1009。如果放进String Pool的String非常多，就会造成Hash冲突严重，从而导致链表会很长，而链表长了后直接会造成的影响就是当调用String.intern时性能会大幅下降
- 在JDK8开始，设置StringTable长度的话，1009是可以设置的最小值

String的内存分配

String和其他8种基本数据类型一样，都存放在常量池中
String的常量池有点特殊，String str = "hello world..." 这样声明的对象是直接存放常量池的，String str = new String("hello world ..."); new的方式声明的是存放在堆中，需要调用intern()方法，才会存放到常量池中
Java 6及以前，字符串常量池存放在永久代
Java 7之后，字符串常量池存放在堆中

String字符串拼接

常量与常量的拼接结果在常量池，原理是编译期优化
常量池中不会存在相同内容的变量
只要其中有一个是变量，结果就在堆中。变量拼接的原理是StringBuilder
如果拼接的结果调用intern( )方法，则主动将常量池中还没有的字符串对象放入池中，并返回此对象地址

@Test
public void test1(){
  String s1 = "a" + "b" + "c"; //编译期优化：等同于"abc"
  String s2 = "abc"; //"abc"一定是放在字符串常量池中，将此地址赋给s2
  /*
   * 最终.java编译成.class,再执行.class
   * String s1 = "abc";
   * String s2 = "abc"
   */
  System.out.println(s1 == s2); //true
  System.out.println(s1.equals(s2)); //true
}

@Test
public void test2(){
  String s1 = "javaEE";
  String s2 = "hadoop";

  String s3 = "javaEEhadoop";
  String s4 = "javaEE" + "hadoop";//编译期优化
  //如果拼接符号的前后出现了变量，则相当于在堆空间中new String()，具体的内容为拼接的结果：javaEEhadoop
  // s5 s6 s7 的前或后面都存在变量，是通过StringBuilder拼接然后返回的toStirng(),所以这三个对象都是在堆空间中new出来的，地址不同
  String s5 = s1 + "hadoop";
  String s6 = "javaEE" + s2;
  String s7 = s1 + s2;

  System.out.println(s3 == s4);//true
  System.out.println(s3 == s5);//false
  System.out.println(s3 == s6);//false
  System.out.println(s3 == s7);//false
  System.out.println(s5 == s6);//false
  System.out.println(s5 == s7);//false
  System.out.println(s6 == s7);//false
  //intern():判断字符串常量池中是否存在javaEEhadoop值，如果存在，则返回常量池中javaEEhadoop的地址；
  //如果字符串常量池中不存在javaEEhadoop，则在常量池中加载一份javaEEhadoop，并返回此对象的地址。
  String s8 = s6.intern();
  System.out.println(s3 == s8);//true
}

@Test
public void test3(){
  String s1 = "a";
  String s2 = "b";
  String s3 = "ab";
  /*
    如下的s1 + s2 的执行细节：
    ① StringBuilder s = new StringBuilder();
    ② s.append("a")
    ③ s.append("b")
    ④ s.toString()  --> 约等于 new String("ab")
        所以s4 = new String("ab")，存放在堆空间中，而s3在常量池中，地址不同。所以结果为false
    补充：在jdk5.0之后使用的是StringBuilder,在jdk5.0之前使用的是StringBuffer
   */
  String s4 = s1 + s2;//
  System.out.println(s3 == s4);//false
}

@Test
public void test4(){
  final String s1 = "a";
  final String s2 = "b";
  String s3 = "ab";
  /*
    这里虽然出现了变量,但是因为变量是通过final修饰的，所以也是从常量池中取的值
    所以 s4 = "a"+"b";通过编译器优化为s4 = "ab";

  */
  String s4 = s1 + s2; //s4:常量
  System.out.println(s3 == s4);//true
}

intern()的使用

intern() 是一个native 修饰的方法，调用的是底层 C 的方法。

public native String intern();

如果不是使用""定义的变量，可以使用intern()，它会从字符串常量池中查询当前字符串是否存在，若不存在就会将当前字符串放入常量池中,存在则不会放入，并且返回该值在常量池中的引用
- String str = new String("hello world").intern();
intern()方法就是保证字符串在常量池中只存在一个，返回的结果就是在常量池中的地址

new String(“a”) + new String(“b”) 会创建几个对象

对象1：new StringBuilder()
对象2：new String("a")
对象3：常量池中的 “a”
对象4：new String("b")
对象5：常量池中的 “b”
对象6：toString 中会创建一个 new String("ab")。toString方法没有在常量池中创建对象

判断字符串是否相等

看两个字符串的地址，如果是new的对象在堆中，直接赋值的对象在常量池。
在调用intern()前是否在字符串常量池中已经存在了，如果存在了无事发生，不存在则会常量池中的对象，jdk6 中只会创建一个常量池中的对象，jdk 7/8 中，没有创建常量池对象，而是将常量池中的地址指向了堆空间的地址

public class StringIntern {

    public static void main(String[] args) {

        /**
         * ① String s = new String("1")
         * 创建了两个对象
         *      堆空间中一个new对象
         *      字符串常量池中一个字符串常量"1"（注意：此时字符串常量池中已有"1"）
         * ② s.intern()由于字符串常量池中已存在"1"，所以不会忘字符串常量池添加
         *
         * s  指向的是堆空间中的对象地址
         * s2 指向的是堆空间中常量池中"1"的地址
         * 所以不相等
         */
        String s = new String("1");
        s.intern();//调用此方法之前，字符串常量池中已经存在了"1"
        String s2 = "1";
        System.out.println(s == s2);//jdk6：false   jdk7/8：false

        /**
         * ① String s3 = new String("1") + new String("1")
         * 等价于new String（"11"），但是，常量池中并不生成字符串"11"；
         *
         * ② s3.intern()
         * 由于此时常量池中并无"11"，所以把s3中记录的对象的地址存入常量池
         * 所以s3 和 s4 指向的都是一个地址
         */
        String s3 = new String("1") + new String("1");//s3变量记录的地址为：new String("11")
        //执行完上一行代码以后，字符串常量池中，是否存在"11"呢？答案：不存在！！
        s3.intern();//在字符串常量池中生成"11"。如何理解：jdk6:在常量池中真正创建了一个新的对象"11",也就有新的地址。
                                            //         jdk7:此时常量池中并没有真正创建"11",而是创建一个指向堆空间中new String("11")的地址
        String s4 = "11";//s4变量记录的地址：使用的是上一行代码代码执行时，在常量池中生成的"11"的地址
        System.out.println(s3 == s4);//jdk6：false  jdk7/8：true
    }

}