Java基础深度总结：String

今天是如此珍贵,不值得为了苦涩的烦恼及悔恨而糟蹋它，抬高你的下巴，保持思想开朗，如同春阳下闪耀的水涧。紧紧把握住今天,因为它一去不复返。

1.String概述

String被声明为final，因此它不可被继承。

• Java8中，String内部使用char数组存储数据

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

• Java9中，String类的实现改为byte数组存储字符串，并用coder标识使用的编码

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

    /** The identifier of the encoding used to encode the bytes in {@code value}. */
    private final byte coder;
}

2.String的不可变性

String的不可变性由以下两点保证：

1. final修饰存放字符的成员变量（Java8中的char数组、Java9中的byte数组和coder都被声明为final），意味着它们都只能被赋值一次，并且String内部的方法都没有去改变存放字符的成员变量的内容，而是每次创建一个新的String对象，如 split()、subString等方法。
2. final修饰String类，表明String类不可被继承，子类无法继承父类，就不能通过重写String类中的方法改变String不可变性的特点。

针对第一点，需要注意的是，String通过char数组或byte数组存放字符串，数组是引用类型，final修饰引用类型仅仅表示改引用的值（地址）只能被赋值一次，因此不能保证该引用所指向对象的内容不发生改变。对于引用类型，只有final修饰还不足以保证不可变性，此时还需要增加额外的逻辑去保证。String类在每次要改变数组内容时，都返回了一个新的String对象来保证不可变。

不可变的好处

• 可以缓存hash值（hash码的唯一）
  String经常作为hash值被使用，如String作为hashMap的key，String的不可变性保证了hash值的不可变。
• String Pool的需要
  如果一个String对象已经被创建过了，那么就会从String Pool中取得引用，只有String是不可变的，才能使用/实现String Pool。
• 安全性
  String经常作为参数，如果字符串是可变的，就会引起各种严重错误和安全漏洞。
• 线程安全
  String的不可变性天生具备线程安全，可在多线程环境下安全的使用。

3.String，StringBuffer，StringBuilder

类别	可变性	线程安全性	效率
String	不可变	线程安全	低
StringBuffer	可变	线程安全	中
StringBuilder	可变	线程不安全	高

（1）可变性

• String的不可变性
• StringBuffer和StringBuilder都继承自AbstractStringBuilder类，AbstractStringBuilder使用char数组来保存字符串，是可变的。

（2）线程安全性

• String的不可变性保证了线程安全
• StringBuilder线程不安全
• StringBuffer对方法加入了synchronized同步锁进行同步，因此线程安全

（3）效率

       StringBuilder > StringBuffer > String

• 由于String的不可变性，导致每次对String的改变都会生成新的对象，因此在大量的字符串操作下，会造成效率低下，且大量消耗内存
• StringBuffer和StringBuilder会通过append方法，将新的字符串加入value数组末尾（默认value数组的容量为16）
• StringBuffer对方法加入了同步锁，因此效率低于StringBuilder，但在多线程环境下，不应该使用StringBuilder

4.String Pool 字符串常量池（重点）

在JVM中存放着一个字符串池，其中保存着很多String对象，这些对象可以被共享使用。当以字符串直接创建String对象时，会首先在字符串池中查找是否存在该常量。如果不存在，则在String Pool中创建一个，然后将其地址返回。如果在String Pool中查询到已经存在该常量，则不创建对象，直接返回这个对象地址。

字符串常量池存在于运行时常量池中。

常量池常分为两大类：
（1）静态常量池：用于存放编译后生成的各种字面量和符号引用。
（2）运行时常量池：再类加载后产生的新常量放入运行时常量池中。运行时常量池主要包含：

• 类、接口、方法、类字段表述信息
• 字符串常量池
• 被final修饰的类变量
• 包装类缓存池

Tips:

• JDK1.7之前，运行时常量池逻辑包含字符串常量池，放在方法区，此时hotspot虚拟机对方法区的实现为永久代。
• JDK1.7字符串常量池从方法区拿到了堆中，原因是方法区空间有限，在大量使用字符串的场景下，会导致内存溢出（OutOfMemory）
• JDK1.8 hotspot用元空间替换了永久代，字符串常量池还在堆中，方法区的实现从永久代变为元空间。

字面量创建字符串常量：String s = "abc"

使用字面量创建字符串常量时（String s = “abc”），JVM首先会检查 String Pool 字符串常量池中是否存在"abc"字符串对象，若该字符串对象已存在于 String Pool 中，则会直接将常量池中该对象的内存地址赋值给 s。

String s5 = "bbb";
String s6 = "bbb";
System.out.println(s5 == s6);  // true

使用关键字new创建字符串常量：String s = new String(“abc”)

使用这种方式一共会创建两个字符串对象（前提是 String Pool 中还没有 “abc” 字符串对象）。

• 由于"abc"作为构造参数，本身就是一个字面量字符串，所以若String Pool中没有 "abc"字符串对象，那么就会在在 String Pool 中创建一个字符串对象。
• 使用new关键字会在堆中创建一个字符串对象。

String s1 = new String("aaa");
String s2 = new String("aaa");
System.out.println(s1 == s2);           // false

String.intern()解析

intern方法: 如果String Pool 中已经存在该字符串对象，则直接返回String Pool中该对象的引用。否则，在String Pool中加入该对象，然后返回引用。（这里的加入该对象，在Java7之前和Java7及以后的处理方式不同）

String s1 = new String("1"); // String Pool中和堆中分别创建了一个对象，s1指向堆中的对象
s1.intern();	 //String Pool中已经创建过该字符串对象了
String s2 = "1"; //s2指向String Pool中的字符串对象
System.out.println(s1 == s2);  //false

JDK1.6与JDK1.7 intern方法的区别

String s3 = new String("1") + new String("1"); // 堆中有 "1"和"11"两个对象，String Pool中有"1"一个对象，s3指向堆中的'11"对象
s3.intern();  //将“11”对象加入String Pool中，JDK1.6 和 JDK1.7不同
String s4 = "11"; 
System.out.println(s3 == s4); // JDK1.6:false   JDK1.7:true

JDK1.6：调用s3.intern();若字符串常量池中不存在该字符串对象，则在String Pool中创建一个对象，然后返回它在String Pool的内存地址；若存在则直接返回String Pool中该对象的内存地址。

JDK1.7：调用s3.intern();若字符串常量池中不存在该字符串对象，则会将堆中此对象的引用添加到String Pool中，并返回该引用；若存在则直接返回String Pool中该对象的内存地址。

Tip：也就是说JDK1.7开始，String Pool中即可以存放字符串对象，也可以存放字符串对象的引用。因此JDK1.6中 String Pool存放的是"11"字符串对象，s4就指向String Pool中的"11"对象，因此是false，而JDK1.7 String Pool 存放的是"11"字符串对象在堆内存的引用，所以s4和s3是同一个对象，结果为true。

String里的"+"操作

• 字面量常量字符串之间的"+"操作会在编译阶段优化，直接合成一个字符串。
  如：String str = “JA”+“VA”; 编译后等同于String str = “JAVA”;因此String Pool中只会有"JAVA"这一个对象。
• 字面量常量字符串与变量的"+“操作，会调用StringBuilder.append()在堆中创建新的对象。
  如：String str2 = str + “01”; 等同于 String str2 = new StringBuilder(str).append(“01”);会将str转化成一个StringBuilder对象，然后调用append方法，添加"01”,因此str2不会进入常量池，但由于每次拼接字符串时都会new StringBuilder，所以在循环拼接字符串时，不建议用 + 号。
• 被final修饰的字段，编译期直接进行常量替换

fianl Sring s1 = "Ja";
fianl Sring s2 = "va";
String s3 = s1 + s2;

在编译时，直接替换成：String s3 = “Ja” + “va”; 又由于 “Ja” 和 “va” 都是字面量常量字符串，于是又被优化成：String s3 = “Java”;

5.String 作为形参

Java中只有值传递，没有引用传递。

	值传递	引用传递
根本区别	创建副本	不创建副本
所以	函数中无法改变原对象	函数中可以改变原对象

public class Test{
	public static void main(String[] args) {
		String s = "aaa";
		System.out.println(s.hashcode()); //96321
		change(s);
		System.out.println(s);// aaa
	}

	public static void change(String s1){
		System.out.println(s1.hashcode()); //96321
		s1 = "bbb";
		System.out.println(s1.hashcode()); //97314
	}
}

解析：

s1是s的副本，因此开始与s同时指向aaa对象，s1=“bbb”,并不是改变了s1原来所指向对象的值，而是在常量池中新创建了一个对象"bbb"，然后指向"bbb"，而s的指向没有发生变化。

Tip：Java语言中所谓的"引用传递"，本质上依然是一种值传递，其修改的内容是指针所指向对象的属性，而不是对象本身。