0036-StringTable

文章目錄

1. String的基本特性

String的基本特性

1. String字符串的定義方式
    String s1 = "atguigu";// 字面量定義方式
    String s2 = new String("hello");
    
2. String聲明爲final的，不可被繼承

3. String實現了Serializable接口：表示字符串是支持序列化的，實現了Comparable接口：表示String可以比較大小

4. String在jdk8及以前內部定義了final char[] value用於存儲字符串數據，jdk9時改爲byte[]

5. String代表不可變的字符序列，簡稱不可變性
    5.1 當對字符串重新賦值時，需要重寫指定內存區域賦值，不能使用原有的value進行賦值
    5.2 當對現有的字符串進行連接操作時，也需要重新指定內存區域賦值，不能使用原有的value進行賦值
    5.3 當調用String的replace()方法修改指定字符或字符串時，也需要重新指定內存區域賦值，不能使用原有的value進行賦值
    
6. 通過字面量的方式（區別於new）給一個字符串賦值，此時的字符串值聲明在字符串常量池中
    字符串常量池中是不會存儲相同內容的字符串的
    
7. String的字符串常量池是一個固定大小的HashTable，默認值大小長度時1009，
如果放進String Poll的String非常多，就會造成Hash衝突嚴重，從而導致鏈表會很長，
而鏈表長了後直接造成的影響就是當調用String.intern時性能會大幅下降

8. 使用-XX:StringTableSize可設置StringTable的長度

9. 在jdk6中StringTable是固定，就是1009，所以如果常量池的字符串過多就會導致效率下降很快。StringTableSize設置沒有要求

10. 在jdk7中StringTable的長度默認值是60013

11. jdk8開始，設置StringTable的長度的話，1009是可設置的最小值

不可變性-實例

    @Test
    public void test1() {
        String s1 = "abc";//字面量定義的方式，"abc"存儲在字符串常量池中
        String s2 = "abc";
        s1 = "hello";

        System.out.println(s1 == s2);//判斷地址：true  --> false

        System.out.println(s1);//hello
        System.out.println(s2);//abc

    }

    @Test
    public void test2() {
        String s1 = "abc";
        String s2 = "abc";
        s2 += "def";
        System.out.println(s2);//abcdef
        System.out.println(s1);//abc
    }

    @Test
    public void test3() {
        String s1 = "abc";
        String s2 = s1.replace('a', 'm');
        System.out.println(s1);//abc
        System.out.println(s2);//mbc
    }

2. String的內存分配

基本原則

1. 在java語言中有8種基本數據類型和一種比較特殊的類型String,這些類型爲了使他們在運行過程中速度更快、更節省內存，都提供了一種常量池的概念

2. 常量池就類似一個Java系統級別提供的緩存。8種基本數據類型的常量池使系統協調的，String類型的常量池比較特殊，它的主要使用方法有兩種。
    2.1 直接使用雙引號聲明出來的String對象會直接存儲在常量池種。
    比如：String info = "atguigu.com"
    2.2 如果不是雙引號聲明的String對象，可以使用String提供的intern()方法
    
3. java 6及以前，字符串常量池存放在永久代

4. java7種oracle的工程師對字符串池的邏輯做了很大的改變，即將字符串常量池的位置調整到java堆內
    4.1 所有的字符串都保存在堆（heap）種，和其它對象一樣，這樣可以讓你在進行調優應用時僅需要調整堆大小就可以了
    4.2 字符串常量池概念原本使用得比較多，但是這個改動使得我們有足夠得理由讓我們重新考慮在java 7中使用String.intern()

5. java8元空間，字符串常量在堆

StringTable爲什麼要調整

1. PermSize本身比較小

2. 永久代回收頻率低

圖示

String s = “a” 內存結構

注：通過字面量創建得字符串，直接在字符串常量池中分配

String s = new String(“a”)內存結構

注：通過new創建得字符串，在堆中會有一個String對象，同時在字符串常量池中會有一個對象

3. String的基本操作

字符串常量池中不會存儲重複字符串

public static void main(String[] args) {
        System.out.println();//2293
        System.out.println("1");//2294
        System.out.println("2");
        System.out.println("3");
        System.out.println("4");
        System.out.println("5");
        System.out.println("6");
        System.out.println("7");
        System.out.println("8");
        System.out.println("9");
        System.out.println("10");//2303
        //如下的字符串"1" 到 "10"不會再次加載
        System.out.println("1");//2304
        System.out.println("2");//2304
        System.out.println("3");
        System.out.println("4");
        System.out.println("5");
        System.out.println("6");
        System.out.println("7");
        System.out.println("8");
        System.out.println("9");
        System.out.println("10");//2304
    }

內存結構

class Memory {
    public static void main(String[] args) {//line 1
        int i = 1;//line 2
        Object obj = new Object();//line 3
        Memory mem = new Memory();//line 4
        mem.foo(obj);//line 5
    }//line 9

    private void foo(Object param) {//line 6
        String str = param.toString();//line 7
        System.out.println(str);
    }//line 8
}

4. 字符串拼接操作

基本規則

1. 常量與常量得拼接結果在常量池，原理是編譯期優化

2. 常量池中不會存在相同內容的變量

3. 拼接過程只要其中有一個是變量，結果就在堆中（非字符串常量池），變量拼接的原理是StringBuilder(字節碼可知)

4. 如果拼接的結果調用intern()方法，則主動將常量池中還沒有的字符串對象放入池中，並返回次對象的地址

拼接過程只要其中有一個是變量，結果就在堆中（非字符串常量池），變量拼接的原理是StringBuilder-字節碼查看
java代碼

    public void test3() {
        String s1 = "a";
        String s2 = "b";
        String s3 = "ab";
        /*
        如下的s1 + s2 的執行細節：(變量s是我臨時定義的）
        ① StringBuilder s = new StringBuilder();
        ② s.append("a")
        ③ s.append("b")
        ④ s.toString()  --> 約等於 new String("ab")

        補充：在jdk5.0之後使用的是StringBuilder,在jdk5.0之前使用的是StringBuffer
         */
        String s4 = s1 + s2;//
        System.out.println(s3 == s4);//false
    }

對應的字節碼文件（獲取字節碼的方法1. javap -v xx.class 2. idea中jclasslib插件）

 0 ldc #14 <a> // 將a放入常量池
 2 astore_1 // 將a放入局部變量表
 3 ldc #15 <b> 
 5 astore_2
 6 ldc #16 <ab>
 8 astore_3
 9 new #9 <java/lang/StringBuilder> // 創建StringBuilder對象
12 dup
13 invokespecial #10 <java/lang/StringBuilder.<init>> // StringBuilder的構造方法
16 aload_1
17 invokevirtual #11 <java/lang/StringBuilder.append> // append方法調用
20 aload_2
21 invokevirtual #11 <java/lang/StringBuilder.append>
24 invokevirtual #12 <java/lang/StringBuilder.toString>
27 astore 4
29 getstatic #3 <java/lang/System.out>
32 aload_3
33 aload 4
35 if_acmpne 42 (+7)
38 iconst_1
39 goto 43 (+4)
42 iconst_0
43 invokevirtual #4 <java/io/PrintStream.println>
46 return

實例分析

@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
        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 的執行細節：(變量s是我臨時定義的）
        ① StringBuilder s = new StringBuilder();
        ② s.append("a")
        ③ s.append("b")
        ④ s.toString()  --> 約等於 new String("ab") --> StringBuilder的toString方法不會往常量池塞數據，Object的toString()會

        補充：在jdk5.0之後使用的是StringBuilder,在jdk5.0之前使用的是StringBuffer
         */
        String s4 = s1 + s2;//
        System.out.println(s3 == s4);//false
    }

    /*
    1. 字符串拼接操作不一定使用的是StringBuilder!
       如果拼接符號左右兩邊都是字符串常量或常量引用，則仍然使用編譯期優化，即非StringBuilder的方式。
    2. 針對於final修飾類、方法、基本數據類型、引用數據類型的量的結構時，能使用上final的時候建議使用上。
     */
    @Test
    public void test4() {
        final String s1 = "a";
        final String s2 = "b";
        String s3 = "ab";
        String s4 = s1 + s2;
        System.out.println(s3 == s4);//true
    }

    //練習：
    @Test
    public void test5() {
        String s1 = "javaEEhadoop";
        String s2 = "javaEE";
        String s3 = s2 + "hadoop";
        System.out.println(s1 == s3);//false

        final String s4 = "javaEE";//s4:常量
        String s5 = s4 + "hadoop";
        System.out.println(s1 == s5);//true

    }

    /*
    體會執行效率：通過StringBuilder的append()的方式添加字符串的效率要遠高於使用String的字符串拼接方式！
    詳情：① StringBuilder的append()的方式：自始至終中只創建過一個StringBuilder的對象
          使用String的字符串拼接方式：創建過多個StringBuilder和String的對象
         ② 使用String的字符串拼接方式：內存中由於創建了較多的StringBuilder和String的對象，內存佔用更大；如果進行GC，需要花費額外的時間。

     改進的空間：在實際開發中，如果基本確定要前前後後添加的字符串長度不高於某個限定值highLevel的情況下,建議使用構造器實例化：
               StringBuilder s = new StringBuilder(highLevel);//new char[highLevel]
     */
    @Test
    public void test6() {

        long start = System.currentTimeMillis();

//        method1(100000);//4014
        method2(100000);//7

        long end = System.currentTimeMillis();

        System.out.println("花費的時間爲：" + (end - start));
    }

    public void method1(int highLevel) {
        String src = "";
        for (int i = 0; i < highLevel; i++) {
            src = src + "a";//每次循環都會創建一個StringBuilder、String
        }
//        System.out.println(src);

    }

    public void method2(int highLevel) {
        //只需要創建一個StringBuilder
        StringBuilder src = new StringBuilder();
        for (int i = 0; i < highLevel; i++) {
            src.append("a");
        }
//        System.out.println(src);
    }

5. intern()的使用

基本原則

1. 如果不是用雙引號聲明的String對象，可以使用String提供的intern方法；
intern方法會從字符串常量池中查詢當前字符串是否存在，若不存在就會將當前字符串放入常量池中
    比如：String s = new String("i love atguigu").interrn();
    
2. 任意字符串調用intern()方法，那麼其返回結果所指向的哪個類實例，必須和直接以常量形式出現的字符串完全相同
    ("a"+"b"+"c").intern()=="abc"
    
3. 字符串常量池一個字符只有一份

常見面試題

new String(“ab”)創建幾個對象

答案：2個
 new String("ab")會創建幾個對象？看字節碼，就知道是兩個。
 一個對象是：new關鍵字在堆空間創建的
 另一個對象是：字符串常量池中的對象"ab"。 字節碼指令：ldc

new String(“a”) + new String(“b”)創建幾個對象

答案：6個
new String("a") + new String("b")呢？
對象1：new StringBuilder()
對象2：new String("a")
對象3：常量池中的"a"
對象4：new String("b")
對象5：常量池中的"b"
深入剖析： StringBuilder的toString():
對象6 ：new String("ab")
強調一下，toString()的調用，在字符串常量池中，沒有生成"ab"

-題3
題目的難題在於在jdk6和jdk7及以後的結果不同

    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");//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

jdk6中的內存結構，在jdk6中在字符串常量池中生成"11"。如何理解：jdk6:創建了一個新的對象"11",也就有新的地址，所以不相等

jdk7中的內存結構，jdk7:此時常量中並沒有創建"11",而是創建一個指向堆空間中new String(“11”)的地址

關於String的intern()方法總結

1. jdk6中，將這個字符串對象嘗試放入串池
    1.1 如果串池中有，則不會放入，返回以後對象的地址
    1.2 如果沒有，會把此對象複製一份，放入串池，並返回串池地址
    
2. jdk7中，將這個字符串對象嘗試放入串池
    2.1 如果串池中有，則不會放入，返回以後對象的地址
    2.2 如果沒有，但是堆中有對象，則會拔對象的引用複製一份，放入串池，並返回串池地址，否則在串池中放入這個對象

jdk6
jdk7

intern()方法有助於降低內存

public class StringIntern2 {
    static final int MAX_COUNT = 1000 * 10000;
    static final String[] arr = new String[MAX_COUNT];

    public static void main(String[] args) {
        Integer[] data = new Integer[]{1,2,3,4,5,6,7,8,9,10};

        long start = System.currentTimeMillis();
        for (int i = 0; i < MAX_COUNT; i++) {
            // 每次都會分配一個String對象，並且String對象被引用，不能回收
//            arr[i] = new         String(String.valueOf(data[i % data.length])); 
            // 每次都會分配一個String對象，但是String對象不全被引用，可以回收（常量池中有數據時，返回常量池中的引用）
            arr[i] = new String(String.valueOf(data[i % data.length])).intern();

        }
        long end = System.currentTimeMillis();
        System.out.println("花費的時間爲：" + (end - start));

        try {
            Thread.sleep(1000000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.gc();
    }
}

文章目錄

1. String的基本特性

2. String的內存分配

3. String的基本操作

4. 字符串拼接操作

5. intern()的使用

0040-垃圾收集算法

0050-垃圾回收器

0060-Config理論

0041-Ribbon使用Hystrix

0044-Hystrix Dashbord監控單機Feign

Mac下配置sublime實現LaTeX

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結