String知识点复习

为什么String在Java中是不可变的？

String在Java中是不可变的。不可变类只是一个无法修改其实例的类。
创建实例时，将初始化实例中的所有信息，并且无法修改信息。
不可变类有许多优点。本文总结了为什么String设计为不可变的。这篇文章从内存，同步和数据结构的角度说明了不变性概念。

1.字符串池的要求

字符串池（String intern pool）是方法区域中的特殊存储区域。创建字符串并且池中已存在该字符串时，将返回现有字符串的引用，而不是创建新对象。
以下代码将在堆中仅创建一个字符串对象。

String string1 =  “abcd” ; 
String string2 =  “abcd” ;

以下是它的外观：

如果字符串是可变的，则使用一个引用更改字符串将导致其他引用的值错误。

2.缓存Hashcode

字符串的哈希码经常在Java中使用。 例如，在HashMap或HashSet中。不可变保证哈希码总是相同的，这样就可以不用担心变化。这意味着，每次使用时都不需要计算哈希码。这更有效率。 在String类中，它具有以下代码：

private  int hash ; //这用于缓存哈希码。

3.促进其他结构的使用

为了具体，请考虑以下程序：

HashSet < String > set =  new HashSet < String > （）; 
set.add （new  String （“a” ））; 
set.add （new  String （“b” ））; 
set.add （new  String （“c” ））;
for （String a ： set ） 
	a.value  =  “a” ;

在此示例中，如果String是可变的，则可以更改其值，这将违反set的设计（set包含非重复元素）。当然，上面的例子仅用于演示目的，并且value在真正的字符串类中没有字段。

4.安全

String 经常作为参数，String 不可变性可以保证参数不可变。例如在作为网络连接参数的情况下如果 String 是可变的，那么在网络连接过程中，String 被改变，改变 String 对象的那一方以为现在连接的是其它主机，而实际情况却不一定是。可变字符串也可能在Reflection中引起安全问题，因为参数是字符串。

这是一个代码示例：

   boolean connect(string s){
    if (!isSecure(s)) { 
throw new SecurityException(); 
}
   //如果在此之前使用其他引用更改了s， 这将导致问题。
    causeProblem(s);
}

5.不可变对象自然是线程安全的

由于无法更改不可变对象，因此可以在多个线程之间自由共享它们。这消除了进行同步的要求。
总之，String出于效率和安全原因，它被设计为不可变的。

String, StringBuffer and StringBuilder

1. 可变性
   String 不可变
   StringBuffer 和 StringBuilder 可变

2. 线程安全
   String 不可变，因此是线程安全的
   StringBuilder 不是线程安全的
   StringBuffer 是线程安全的，内部使用 synchronized 进行同步

String Pool

字符串常量池（String Pool）保存着所有字符串字面量（literal strings），这些字面量在编译时期就确定。不仅如此，还可以使用 String 的 intern() 方法在运行过程中将字符串添加到 String Pool 中。

当一个字符串调用 intern() 方法时，如果 String Pool 中已经存在一个字符串和该字符串值相等（使用 equals() 方法进行确定），那么就会返回 String Pool 中字符串的引用；否则，就会在 String Pool 中添加一个新的字符串，并返回这个新字符串的引用。

下面示例中，s1 和 s2 采用 new String() 的方式新建了两个不同字符串，而 s3 和 s4 是通过 s1.intern() 方法取得一个字符串引用。intern() 首先把 s1 引用的字符串放到 String Pool 中，然后返回这个字符串引用。因此 s3 和 s4 引用的是同一个字符串。

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

如果是采用 “bbb” 这种字面量的形式创建字符串，会自动地将字符串放入 String Pool 中。

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

在 Java 7 之前，String Pool 被放在运行时常量池中，它属于永久代。而在 Java 7，String Pool 被移到堆中。这是因为永久代的空间有限，在大量使用字符串的场景下会导致 OutOfMemoryError 错误。

new String(“abc”)

使用这种方式一共会创建两个字符串对象（前提是 String Pool 中还没有 “abc” 字符串对象）。
“abc” 属于字符串字面量，因此编译时期会在 String Pool 中创建一个字符串对象，指向这个 “abc” 字符串字面量；

而使用 new 的方式会在堆中创建一个字符串对象。
创建一个测试类，其 main 方法中使用这种方式来创建字符串对象。

public class NewStringTest {
    public static void main(String[] args) {
        String s = new String("abc");
    }
}

使用 javap -verbose 进行反编译，得到以下内容：

// ...
Constant pool:
// ...
   #2 = Class              #18            // java/lang/String
   #3 = String             #19            // abc
// ...
  #18 = Utf8               java/lang/String
  #19 = Utf8               abc
// ...

  public static void main(java.lang.String[]);
    descriptor: ([Ljava/lang/String;)V
    flags: ACC_PUBLIC, ACC_STATIC
    Code:
      stack=3, locals=2, args_size=1
         0: new           #2                  // class java/lang/String
         3: dup
         4: ldc           #3                  // String abc
         6: invokespecial #4                  // Method java/lang/String."<init>":(Ljava/lang/String;)V
         9: astore_1
// ...

在 Constant Pool 中，#19 存储这字符串字面量 “abc”，#3 是 String Pool 的字符串对象，它指向 #19 这个字符串字面量。在 main 方法中，0: 行使用 new #2 在堆中创建一个字符串对象，并且使用 ldc #3 将 String Pool 中的字符串对象作为 String 构造函数的参数。

以下是 String 构造函数的源码，可以看到，在将一个字符串对象作为另一个字符串对象的构造函数参数时，并不会完全复制 value 数组内容，而是都会指向同一个 value 数组。

public String(String original) {
    this.value = original.value;
    this.hash = original.hash;
}