java8 String

亦凉 2023-07-25 08:47 3阅读 0赞

### String ###

*   *  一.概览
     *  二.不可变的好处
     *   *  1. 可以缓存 hash 值
         *  2. String Pool 的需要
         *  3. 安全性
         *  4. 线程安全
     *  三.String, StringBuffer and StringBuilder
     *   *  1. 可变性
         *  2. 线程安全
     *  四.String Pool
     *  五.new String("abc")
     *  
     *  六 .其他

**本文全文摘抄自gihub[CyC2018/CS-Notes][CyC2018_CS-Notes]仅供本人学习记录使用**

## 一.概览 ##

String 被声明为 final，因此它不可被继承。(Integer 等包装类也不能被继承）

在 Java 8 中，String 内部使用 char 数组存储数据。

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

在 Java 9 之后，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;
    }

value 数组被声明为 final，这意味着 value 数组初始化之后就不能再引用其它数组。并且 String 内部没有改变 value 数组的方法，因此可以保证 String 不可变。

## 二.不可变的好处 ##

### 1. 可以缓存 hash 值 ###

因为 String 的 hash 值经常被使用，例如 String 用做 HashMap 的 key。不可变的特性可以使得 hash 值也不可变，因此只需要进行一次计算。

### 2. String Pool 的需要 ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZlbmdxaW5neXVlYmFpMTk_size_16_color_FFFFFF_t_70]  
如果一个 String 对象已经被创建过了，那么就会从 String Pool 中取得引用。只有 String 是不可变的，才可能使用 String Pool。

### 3. 安全性 ###

String 经常作为参数，String 不可变性可以保证参数不可变。例如在作为网络连接参数的情况下如果 String 是可变的，那么在网络连接过程中，String 被改变，改变 String 的那一方以为现在连接的是其它主机，而实际情况却不一定是。

### 4. 线程安全 ###

String 不可变性天生具备线程安全，可以在多个线程中安全地使用。

[Program Creek : Why String is immutable in Java?][Program Creek _ Why String is immutable in Java]

## 三.String, StringBuffer and StringBuilder ##

### 1. 可变性 ###

String 不可变  
StringBuffer 和 StringBuilder 可变

### 2. 线程安全 ###

String 不可变，因此是线程安全的  
StringBuilder 不是线程安全的  
StringBuffer 是线程安全的，内部使用 synchronized 进行同步  
[StackOverflow : String, StringBuffer, and StringBuilder][StackOverflow _ String_ StringBuffer_ and StringBuilder]

## 四.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 错误。

[StackOverflow : What is String interning?][StackOverflow _ What is String interning].  
[深入解析 String\#intern][String_intern]

## 五.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;
    }

## 六 .其他 ##

构造函数可以参考：[String 源码学习笔记][String]

public final class String
        implements java.io.Serializable, Comparable<String>, CharSequence { 
        
    	 private final char value[];
    	 private int hash; // Default to 0
    	 private static final long serialVersionUID = -6849794470754667710L;
    	 private static final ObjectStreamField[] serialPersistentFields =
    	        new ObjectStreamField[0];

public String(char value[]) { 
            this.value = Arrays.copyOf(value, value.length);
        }

String重写的equals

public boolean equals(Object anObject) { 
            if (this == anObject) { 
                return true;
            }
            if (anObject instanceof String) { 
                String anotherString = (String)anObject;
                int n = value.length;
                if (n == anotherString.value.length) { 
                    char v1[] = value;
                    char v2[] = anotherString.value;
                    int i = 0;
                    while (n-- != 0) { 
                        if (v1[i] != v2[i])
                            return false;
                        i++;
                    }
                    return true;
                }
            }
            return false;
        }
       public int hashCode() { 
            int h = hash;
            if (h == 0 && value.length > 0) { 
                char val[] = value;
    
                for (int i = 0; i < value.length; i++) { 
                    h = 31 * h + val[i];
                }
                hash = h;
            }
            return h;
        }

hashCode写法可以参考：https://blog.csdn.net/w2393040183/article/details/100105779  
为什么要用31：https://segmentfault.com/a/1190000010799123  
源码解析参考：[【Java源码分析】Java8的String源码分析][Java_Java8_String]

[CyC2018_CS-Notes]: https://github.com/CyC2018/CS-Notes/blob/master/notes/Java%20%E5%9F%BA%E7%A1%80.md
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZlbmdxaW5neXVlYmFpMTk_size_16_color_FFFFFF_t_70]: /images/20230528/10f50789783b45709df7a3bbe6e5f028.png
[Program Creek _ Why String is immutable in Java]: https://www.programcreek.com/2013/04/why-string-is-immutable-in-java/
[StackOverflow _ String_ StringBuffer_ and StringBuilder]: https://stackoverflow.com/questions/2971315/string-stringbuffer-and-stringbuilder
[StackOverflow _ What is String interning]: https://stackoverflow.com/questions/10578984/what-is-string-interning
[String_intern]: https://tech.meituan.com/in_depth_understanding_string_intern.html
[String]: https://blog.csdn.net/sun_shaoping/article/details/82079354?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522158677955519724848308638%2522%252C%2522scm%2522%253A%252220140713.130102334..%2522%257D&request_id=158677955519724848308638&biz_id=0&utm_source=distribute.pc_search_result.none-task-blog-soetl_so_first_rank_v2_rank_v25-1
[Java_Java8_String]: https://blog.csdn.net/SnailMann/article/details/80882719?depth_1-utm_source=distribute.pc_relevant.none-task-blog-BlogCommendFromBaidu-2&utm_source=distribute.pc_relevant.none-task-blog-BlogCommendFromBaidu-2