教育行業(yè)A股IPO第一股（股票代碼 003032）

全國咨詢/投訴熱線：400-618-4000

JVM字符串底層實現(xiàn)原理是什么？【Java培訓】

更新時間:2020年10月28日17時26分 來源:黑馬程序員 瀏覽次數(shù):

一、什么字符串會進入字符串常量池

  1. 直接寫的字面量

  2. 字面量的拼接結果(注意：如果字符串拼接中有變量則結果不會進入字符串常量池)

  3. 調(diào)用String的intern方法可以將String存入字符串常量池

二、字面量的拼接原理

有如下示列代碼

  1. package com.hgy;
  3. import java.util.Arrays;
  4. import java.util.List;
  6. public class hello {
  7.     public static void main(String[] args) {
  8.     String a = "hello" + " world";
  9.     }
  10. }

  • 在idea中查看編譯后的class文件

    1. //
    2. // Source code recreated from a .class file by IntelliJ IDEA
    3. // (powered by Fernflower decompiler)
    4. //
    5. package com.hgy;
    6. public class hello {
    7. public hello() {
    8. }
    10. public static void main(String[] args) {
    11.   String a = "hello world";
    12. }
    13. }

結論：
以上面兩個文件我們可以看出，這種字符串的拼接在編譯期間就已經(jīng)優(yōu)化了，直接就合并為一個字符串;并且這個字符串存放在字符串常量池。

3. 字符串和變量拼接原理

java源碼

  1. package com.hgy;
  2. import java.util.Arrays;
  3. import java.util.List;
  4. public class hello {
  5.   public static void main(String[] args) {
  6.     String v = "java";
  7.     String a = v + "hello" + " world";
  8.   }
  9. }
  • 利用jclasslib查看main方法的字節(jié)碼命令
    ·如果一下名詞不明白請閱讀請自行了解學習java虛擬機棧
    ·我們可以發(fā)現(xiàn)就簡單的兩行代碼，產(chǎn)生了這么多的字節(jié)碼命令;在代碼中我簡單解釋了每一行的作用，
  1. ldc #2 <java> // 從字符串常量池加載java
  2. astore_1 // 存儲常量到索引為1的局部變量表中
  3. new #3 <java/lang/StringBuilder> //給StringBuilder對象分配內(nèi)存空間
  4. dup
  5. invokespecial #4 <java/lang/StringBuilder.<init>> //執(zhí)行StringBuilder的構造方法
  6. aload_1 //獲取局部變量表索引為1的引用地址，
  7. invokevirtual #5 <java/lang/StringBuilder.append> //把上面加載的內(nèi)容作為參數(shù)傳遞給append方法
  8. ldc #6 <hello world> // 從字符串常量池加載hello world
  9. invokevirtual #5 <java/lang/StringBuilder.append> //把上面加載的內(nèi)容作為參數(shù)
  10. 傳遞給append方法
  11. invokevirtual #7 <java/lang/StringBuilder.toString> //調(diào)用toString方法
  12. astore_2 //結果存儲到局部變量表
  13. return
  • 以上內(nèi)容我們可以知道字符串拼接實際上就是創(chuàng)建了一個StringBuilder對象然后向里面append內(nèi)容，最后調(diào)用toString方法獲得結果

3.1 為什么結果沒有存儲在常量池

從上述字節(jié)碼指令已經(jīng)知道了字符串拼接結果是StringBuilder的toString方法的結果，那么toString里面具體做了什么事情，又是為什么結果不在常量池?
以下是StringBuilder.toString的源碼以及字節(jié)碼指令

  1. @Override
  2. public String toString() {
  3.   // Create a copy, don't share the array
  4.   //此處value為一個char數(shù)組【我的jdk版本為jdk8】
  5.   return new String(value, 0, count);
  6. }
  1. new #80 <java/lang/String>
  2. dup
  3. aload_0
  4. getfield #234 <java/lang/StringBuilder.value>
  5. iconst_0
  6. aload_0
  7. getfield #233 <java/lang/StringBuilder.count>
  8. invokespecial #291 <java/lang/String.<init>>
  9. areturn

以上代碼可以很好的解釋實際上最終是調(diào)用了String的構造方法傳入一個char數(shù)組，那么最終的結果肯定也就在咱么的堆空間。

4. 為什么字符串拼接效率低

4.1. 源碼準備
首先編寫兩個方法一個使用字符串拼接，一個使用StringBuilder進行拼接;

  1. public class hello {
  2.   public void concatStrByDefault() {
  3.     String basic = "name ";
  4.     for (int i = 0; i < 100; i++) {
  5.       basic += i;
  6.     }
  7.     System.out.println(basic);
  8.   }
  9.   public void concatStrByBuilder() {
  10.     StringBuilder basic = new StringBuilder("name ");
  11.     for (int i = 0; i < 100; i++) {
  12.       basic.append(i);
  13.     }
  14.     System.out.println(basic.toString());
  15.   }
  16. }

4.2.字節(jié)碼指令層面解析

一上代碼的執(zhí)行時間長短我就不在重復測試了相信大家都會，接下來我們來一起看看這兩個方法字節(jié)碼指令

concatStrByDefault方法的字節(jié)碼指令如下

簡單解釋下循環(huán)是在33行的goto指令調(diào)到第5行這樣不斷循環(huán);并且在11行也就是循環(huán)中不斷的通過new創(chuàng)建了StringBuilder對象，也就是循環(huán)了多少次就創(chuàng)建了多少個StringBuilder對象，并且如果大家看了我之前寫字符串拼接原理，在StringBuilder的toString方法中還new了一個String對象;這里這么多對象的創(chuàng)建就必然需要垃圾回收效率自然就低了

  1. ldc #2 <name >
  2. astore_1
  3. iconst_0
  4. istore_2
  5. iload_2
  6. bipush 100
  7. if_icmpge 36 (+28)
  8. new #3 <java/lang/StringBuilder>
  9. dup
  10. invokespecial #4 <java/lang/StringBuilder.<init>>
  11. aload_1
  12. invokevirtual #5 <java/lang/StringBuilder.append>
  13. iload_2
  14. invokevirtual #6 <java/lang/StringBuilder.append>
  15. invokevirtual #7 <java/lang/StringBuilder.toString>
  16. astore_1
  17. iinc 2 by 1
  18. goto 5 (-28)
  19. getstatic #8 <java/lang/System.out>
  20. aload_1
  21. invokevirtual #9 <java/io/PrintStream.println>
  22. return

concatStrByBuilder方法的字節(jié)碼指令

此處循環(huán)在27行的goto指令跳到12行，并且循環(huán)之間是沒有創(chuàng)建新對象的，緊緊只是調(diào)用了append方法，這里就能很明顯的看出這種方式比普通拼接少創(chuàng)建了很多的對象

  1. new #3 <java/lang/StringBuilder>
  2. dup
  3. ldc #2 <name >
  4. invokespecial #10 <java/lang/StringBuilder.<init>>
  5. astore_1
  6. iconst_0
  7. istore_2
  8. iload_2
  9. bipush 100
  10. if_icmpge 30 (+15)
  11. aload_1
  12. iload_2
  13. invokevirtual #6 <java/lang/StringBuilder.append>
  14. pop
  15. iinc 2 by 1
  16. goto 12 (-15)
  17. getstatic #8 <java/lang/System.out>
  18. aload_1
  19. invokevirtual #7 <java/lang/StringBuilder.toString>
  20. invokevirtual #9 <java/io/PrintStream.println>
  21. return

4.3. 總結

拼接效率低的主要原因也就是每一次拼接都創(chuàng)建了一個StringBuilder對象，并且在賦值是又需要調(diào)用toString方法，而toString方法的實現(xiàn)里面有new了一個String對象，所以拼接的效率很低。

0 分享到：
和我們在線交談！