溫馨提示×
您好，登錄后才能下訂單哦！
點擊 登錄注冊 即表示同意《億速云用戶服務條款》
您好，登錄后才能下訂單哦！
這篇文章主要介紹了JVM中StringTable的示例分析，具有一定借鑒價值，感興趣的朋友可以參考下，希望大家閱讀完這篇文章之后大有收獲，下面讓小編帶著大家一起了解一下。
String：字符串，使用一對 "" 引起來表示
String s1 = "Nemo"; // 字面量的定義方式
String s2 = new String("Nemo");
String 聲明為 final 的，不可被繼承
String 實現了 Serializable 接口：表示字符串是支持序列化的。
實現了 Comparable 接口：表示 string 可以比較大小
String 在 jdk8 及以前內部定義了
private final char[] value 用于存儲字符串數據。
JDK9 時改為 byte[]
官方說明：http://openjdk.java.net/jeps/254
String 類的當前實現將字符存儲在 char 數組中，每個字符使用兩個字節（16 位）。從許多不同的應用程序收集的數據表明，字符串是堆使用的主要組成部分，而且，大多數字符串對象只包含拉丁字符。這些字符只需要一個字節的存儲空間，因此這些字符串對象的內部 char 數組中有一半的空間將不會使用。
我們建議改變字符串的內部表示 class 從 utf - 16 字符數組到字節數組 + 一個 encoding-flag 字段。新的 String 類將根據字符串的內容存儲編碼為 ISO-8859-1/Latin-1（每個字符一個字節）或 UTF-16（每個字符兩個字節）的字符。編碼標志將指示使用哪種編碼。
結論：String 再也不用 char[] 來存儲了，改成了 byte[] 加上編碼標記，節約了一些空間
↓CloseCode↓
// 之前private final char value[];// 之后private final byte[] value
同時基于 String 的數據結構，例如 StringBuffer 和 StringBuilder 也同樣做了修改
String：代表不可變的字符序列。簡稱：不可變性。
當對字符串重新賦值時，需要重寫指定內存區域賦值，不能使用原有的 value 進行賦值。
當對現有的字符串進行連接操作時，也需要重新指定內存區域賦值，不能使用原有的 value 進行賦值。
當調用 String 的
replace() 方法修改指定字符或字符串時，也需要重新指定內存區域賦值，不能使用原有的 value 進行賦值。
通過字面量的方式（區別于 new）給一個字符串賦值，此時的字符串值聲明在字符串常量池中。
代碼
↓CloseCode↓
/**
* String的不可變性
*
* @author: Nemo
*/public class StringTest1 { public static void test1() { // 字面量定義的方式，“abc”存儲在字符串常量池中
String s1 = "abc";
String s2 = "abc";
System.out.println(s1 == s2);
s1 = "hello";
System.out.println(s1 == s2);
System.out.println(s1);
System.out.println(s2);
System.out.println("----------------");
} public static void test2() {
String s1 = "abc";
String s2 = "abc"; // 只要進行了修改，就會重新創建一個對象，這就是不可變性
s2 += "def";
System.out.println(s1);
System.out.println(s2);
System.out.println("----------------");
} public static void test3() {
String s1 = "abc";
String s2 = s1.replace('a', 'm');
System.out.println(s1);
System.out.println(s2);
} public static void main(String[] args) {
test1();
test2();
test3();
}
}運行結果
↓CloseCode↓
truefalsehello abc----------------abc abcdef----------------abc mbc
↓CloseCode↓
/**
* 面試題
*
* @author: Nemo
*/public class StringExer {
String str = new String("good"); char [] ch = {'t','e','s','t'}; public void change(String str, char ch []) {
str = "test ok";
ch[0] = 'b';
} public static void main(String[] args) {
StringExer ex = new StringExer();
ex.change(ex.str, ex.ch);
System.out.println(ex.str);
System.out.println(ex.ch);
}
}輸出結果
↓CloseCode↓
goodbest
字符串常量池是不會存儲相同內容的字符串的
String 的 string Pool 是一個固定大小的 Hashtable，默認值大小長度是 1009。如果放進 string Pool 的 string 非常多，就會造成 Hash 沖突嚴重，從而導致鏈表會很長，而鏈表長了后直接會造成的影響就是當調用 string.intern 時性能會大幅下降。
使用
-XX:StringTablesize 可設置 stringTable 的長度
在 jdk6 中 stringTable 是固定的，就是 1009 的長度，所以如果常量池中的字符串過多就會導致效率下降很快。stringTablesize 設置沒有要求
在 jdk7 中，stringTable 的長度默認值是 60013，stringTablesize 設置沒有要求
在 jdk8 中，StringTable 的長度可以設置的最小值為 1009
在 Java 語言中有 8 種基本數據類型和一種比較特殊的類型 string。這些類型為了使它們在運行過程中速度更快、更節省內存，都提供了一種常量池的概念。
常量池就類似一個 Java 系統級別提供的緩存。8 種基本數據類型的常量池都是系統協調的，String 類型的常量池比較特殊。它的主要使用方法有兩種。
直接使用雙引號聲明出來的 String 對象會直接存儲在常量池中。
比如：string info="atguigu.com";
如果不是用雙引號聲明的 string 對象，可以使用 string 提供的
intern() 方法。
Java 6 及以前，字符串常量池存放在永久代
Java 7 中 oracle 的工程師對字符串池的邏輯做了很大的改變，即將字符串常量池的位置調整到 Java 堆內
所有的字符串都保存在堆（Heap）中，和其他普通對象一樣，這樣可以讓你在進行調優應用時僅需要調整堆大小就可以了。
字符串常量池概念原本使用得比較多，但是這個改動使得我們有足夠的理由讓我們重新考慮在 Java 7 中使用
String.intern()。
Java8 元空間，字符串常量在堆
官網說明：https://www.oracle.com/technetwork/java/javase/jdk7-relnotes-418459.html#jdk7changes
在 JDK 7 中，interned 字符串不再在 Java 堆的永久生成中分配，而是在 Java 堆的主要部分（稱為年輕代和年老代）中分配，與應用程序創建的其他對象一起分配。此更改將導致駐留在主 Java 堆中的數據更多，駐留在永久生成中的數據更少，因此可能需要調整堆大小。由于這一變化，大多數應用程序在堆使用方面只會看到相對較小的差異，但加載許多類或大量使用字符串的較大應用程序會出現這種差異。intern() 方法會看到更顯著的差異。
原因：
永久代的默認比較小
永久代垃圾回收頻率低
Java 語言規范里要求完全相同的字符串字面量，應該包含同樣的 Unicode 字符序列（包含同一份碼點序列的常量），并且必須是指向同一個 String 類實例。
常量與常量的拼接結果在常量池，原理是編譯期優化
常量池中不會存在相同內容的變量
只要其中有一個是變量，結果就在堆中。變量拼接的原理是 StringBuilder
如果拼接的結果調用
intern() 方法，則主動將常量池中還沒有的字符串對象放入池中，并返回此對象地址
↓CloseCode↓
public static void test1() {
String s1 = "a" + "b" + "c"; // 得到 abc的常量池
String s2 = "abc"; // abc存放在常量池，直接將常量池的地址返回
/**
* 最終java編譯成.class，再執行.class
*/
System.out.println(s1 == s2); // true，因為存放在字符串常量池
System.out.println(s1.equals(s2)); // true
} public static void test2() {
String s1 = "javaEE";
String s2 = "hadoop";
String s3 = "javaEEhadoop";
String s4 = "javaEE" + "hadoop";
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
String s8 = s6.intern();
System.out.println(s3 == s8); // true
}從上述的結果我們可以知道：
如果拼接符號的前后出現了變量，則相當于在堆空間中 new String()，具體的內容為拼接的結果
而調用 intern 方法，則會判斷字符串常量池中是否存在 JavaEEhadoop 值，如果存在則返回常量池中的值，否者就在常量池中創建
拼接操作的底層其實使用了 StringBuilder
s1 + s2 的執行細節
StringBuilder s = new StringBuilder();
s.append(s1);
s.append(s2);
s.toString(); -> 類似于new String("ab");
在 JDK5 之后，使用的是 StringBuilder，在 JDK5 之前使用的是 StringBuffer
| String | StringBuffer | StringBuilder |
|---|---|---|
| String 的值是不可變的，這就導致每次對 String 的操作都會生成新的 String 對象，不僅效率低下，而且浪費大量優先的內存空間 | StringBuffer 是可變類，和線程安全的字符串操作類，任何對它指向的字符串的操作都不會產生新的對象。每個 StringBuffer 對象都有一定的緩沖區容量，當字符串大小沒有超過容量時，不會分配新的容量，當字符串大小超過容量時，會自動增加容量 | 可變類，速度更快 |
| 不可變 | 可變 | 可變 |
| 線程安全 | 線程不安全 | |
| 多線程操作字符串 | 單線程操作字符串 |
注意，我們左右兩邊如果是變量的話，就是需要 new StringBuilder 進行拼接，但是如果使用的是 final 修飾，則是從常量池中獲取。所以說拼接符號左右兩邊都是字符串常量或常量引用 則仍然使用編譯器優化。也就是說被 final 修飾的變量，將會變成常量，類和方法將不能被繼承。
在開發中，能夠使用 final 的時候，建議使用上
↓CloseCode↓
public static void test4() { final String s1 = "a"; final String s2 = "b";
String s3 = "ab";
String s4 = s1 + s2;
System.out.println(s3 == s4);
}運行結果
↓CloseCode↓
true
↓CloseCode↓
public static void method1(int highLevel) {
String src = ""; for (int i = 0; i < highLevel; i++) {
src += "a"; // 每次循環都會創建一個StringBuilder對象
}
} public static void method2(int highLevel) {
StringBuilder sb = new StringBuilder(); for (int i = 0; i < highLevel; i++) {
sb.append("a");
}
}方法 1 耗費的時間：4005ms，方法 2 消耗時間：7ms
結論：
通過 StringBuilder 的
append() 方式添加字符串的效率，要遠遠高于 String 的字符串拼接方法
好處
StringBuilder 的 append 的方式，自始至終只創建一個 StringBuilder 的對象
對于字符串拼接的方式，還需要創建很多 StringBuilder 對象和調用 toString 時候創建的 String 對象
內存中由于創建了較多的 StringBuilder 和 String 對象，內存占用過大，如果進行 GC 那么將會耗費更多的時間
改進的空間
我們使用的是 StringBuilder 的空參構造器，默認的字符串容量是 16，然后將原來的字符串拷貝到新的字符串中，我們也可以默認初始化更大的長度，減少擴容的次數
因此在實際開發中，我們能夠確定，前前后后需要添加的字符串不高于某個限定值，那么建議使用構造器創建一個閾值的長度
intern 是一個 native 方法，調用的是底層 C 的方法
字符串池最初是空的，由 String 類私有地維護。在調用 intern 方法時，如果池中已經包含了由
equals(object) 方法確定的與該字符串對象相等的字符串，則返回池中的字符串。否則，該字符串對象將被添加到池中，并返回對該字符串對象的引用。
如果不是用雙引號聲明的 string 對象，可以使用 string 提供的 intern 方法：intern 方法會從字符串常量池中查詢當前字符串是否存在，若不存在就會將當前字符串放入常量池中。
比如：
↓CloseCode↓
String myInfo = new string("I love atguigu").intern();也就是說，如果在任意字符串上調用 string.intern 方法，那么其返回結果所指向的那個類實例，必須和直接以常量形式出現的字符串實例完全相同。因此，下列表達式的值必定是 true：
↓CloseCode↓
（"a"+"b"+"c"）.intern（）=="abc"
通俗點講，Interned string 就是確保字符串在內存里只有一份拷貝，這樣可以節約內存空間，加快字符串操作任務的執行速度。注意，這個值會被存放在字符串內部池（String Intern Pool）
我們通過測試一下，使用了 intern 和不使用的時候，其實相差還挺多的
↓CloseCode↓
/**
* 使用Intern() 測試執行效率
* @author: Nemo
*/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++) {
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 (Exception e) {
e.getStackTrace();
}
}
}結論：對于程序中大量使用存在的字符串時，尤其存在很多已經重復的字符串時，使用
intern() 方法能夠節省內存空間。
大的網站平臺，需要內存中存儲大量的字符串。比如社交網站，很多人都存儲：北京市、海淀區等信息。這時候如果字符串都調用
intern() 方法，就會很明顯降低內存的大小。
↓CloseCode↓
/**
* new String("ab") 會創建幾個對象？ 看字節碼就知道是2個對象
*
* @author: Nemo
*/public class StringNewTest { public static void main(String[] args) {
String str = new String("ab");
}
}我們轉換成字節碼來查看
↓CloseCode↓
0 new #2 <java/lang/String> 3 dup 4 ldc #3 <ab> 6 invokespecial #4 <java/lang/String.<init>> 9 astore_110 return
這里面就是兩個對象
一個對象是：new 關鍵字在堆空間中創建
另一個對象：字符串常量池中的對象
↓CloseCode↓
/**
* new String("ab") 會創建幾個對象？ 看字節碼就知道是2個對象
*
* @author: Nemo
*/public class StringNewTest { public static void main(String[] args) {
String str = new String("a") + new String("b");
}
}字節碼文件為
↓CloseCode↓
0 new #2 <java/lang/StringBuilder> 3 dup 4 invokespecial #3 <java/lang/StringBuilder.<init>> 7 new #4 <java/lang/String>10 dup11 ldc #5 <a>13 invokespecial #6 <java/lang/String.<init>>16 invokevirtual #7 <java/lang/StringBuilder.append>19 new #4 <java/lang/String>22 dup23 ldc #8 <b>25 invokespecial #6 <java/lang/String.<init>>28 invokevirtual #7 <java/lang/StringBuilder.append>31 invokevirtual #9 <java/lang/StringBuilder.toString>34 astore_135 return
我們創建了 6 個對象
對象 1：new StringBuilder()
對象 2：new String("a")
對象 3：常量池的 a
對象 4：new String("b")
對象 5：常量池的 b
對象 6：toString中會約等于創建一個 new String("ab")
調用 toString 方法，不會在常量池中生成"ab"（而是會生成"a"和"b"），因為并沒有聲明"ab"常量。當然，如果是 new String("ab") 那常量池肯定有常量。
↓CloseCode↓
String s = new String("1"); // 在常量池中已經有了，"1"常量放到常量池，new對象放到堆s.intern(); // 將該對象放入到常量池。但是調用此方法沒有太多的區別，因為已經存在了1String s2 = "1";
System.out.println(s == s2); // falseString 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); // false輸出結果
↓CloseCode↓
falsefalse
為什么對象會不一樣呢？String s = new String("1");"1" 常量放到常量池，new 對象放到堆String s2 = "1";時，去檢查常量池，發現有 "1"，直接返回了常量池的引用，沒有創建對象。
對于 s2 字符串來說，它的創建過程同上所說。在創建該對象之前，JVM 會在 String 對象池中去搜索該字符對象是否已經被創建，如果已經被創建，則直接返回一個引用，否則先創建在返回引用。
而 s 字符串變量，它的創建過程就要多一個步驟。除了類似于 str2 字符串對象創建過程以外，它還會額外的創建一個新的 String 對象，也就是 new 關鍵字的作用，并且返回一個引用給 s。
一個是 new 創建的對象，是堆空間中的地址
一個是字面量賦值，是常量池中的對象，是常量池從的地址，顯然不是同一個
如果是下面這樣的，那么就是 true
↓CloseCode↓
String s = new String("1");
s = s.intern();
String s2 = "1";
System.out.println(s == s2); // true而對于下面的來說，因為 s3 變量記錄的地址是 new String("11")，然后這段代碼執行完以后，常量池中不存在 "11"，這是 JDK6 的關系，然后執行 s3.intern() 后，就會在常量池中生成 "11"，最后 s4 用的就是 s3 的地址
為什么最后輸出的 s3 == s4 會為false呢？
這是因為在 JDK6 中創建了一個新的對象 "11"，也就是有了新的地址，s2 = 新地址
而在 JDK7 中，在 JDK7 中，并沒有創新一個新對象，而是指向常量池中的新對象
↓CloseCode↓
String s = new String("1");
s.intern();
String s2 = "1";
System.out.println(s == s2); // falseString s3 = new String("1") + new String("1");
s3.intern();
String s4 = "11";
System.out.println(s3 == s4); // true
↓CloseCode↓
String s3 = new String("1") + new String("1");
String s4 = "11"; // 在常量池中生成的字符串s3.intern(); // 然后s3就會從常量池中找，發現有了，就什么事情都不做System.out.println(s3 == s4);我們將 s4 的位置向上移動一行，發現變化就會很大，最后得到的是 false
總結 string 的
intern() 的使用：
JDK1.6 中，將這個字符串對象嘗試放入串池（字符串常量池）。
如果串池中有，則并不會放入。返回已有的串池中的對象的地址
如果沒有，會把此對象復制一份，放入串池，并返回串池中的對象地址
JDK1.7 起，將這個字符串對象嘗試放入串池。
如果串池中有，則并不會放入。返回已有的串池中的對象的地址
如果沒有，則會把對象的引用地址復制一份，放入串池，并返回串池中的引用地址
練習：
在 JDK6 中，在字符串常量池中創建一個字符串 "ab"
在 JDK8 中，在字符串常量池中沒有創建 "ab"，而是將堆中的地址復制到 串池中。
所以上述結果，在 JDK6 中是：
↓CloseCode↓
truefalse
在JDK8中是
↓CloseCode↓
truetrue
針對下面這題，在 JDK6 和 8 中表現的是一樣的
使用
intern() 優化執行效率：空間使用上
結論：對于程序中大量存在的字符串，尤其是其中存在很多重復字符串時，使用
intern() 可以節省內存空間。
大的網站平臺，需要內存中存儲大量的字符串。比如社交網站，很多人都存儲：北京市、海淀區等信息。這時候如果字符串都調用
intern() 方法，就會明顯降低內存的大小。
↓CloseCode↓
/**
* String的垃圾回收
* -Xms15m -Xmx15m -XX:+PrintStringTableStatistics -XX:+PrintGCDetails
* @author: Nemo
*/public class StringGCTest { public static void main(String[] args) { for (int i = 0; i < 100000; i++) {
String.valueOf(i).intern();
}
}
}執行之后只有 60000 多個對象，因為進行了垃圾回收。
官方說明：http://openjdk.java.net/jeps/192
注意這里說的重復，指的是在堆中的數據，而不是常量池中的，因為常量池中的本身就不會重復
String str1 = new String("hello");String str2 = new String("hello");
是指這個堆中的對象去重
背景：對許多 Java 應用（有大的也有小的）做的測試得出以下結果：
堆存活數據集合里面 string 對象占了 25%
堆存活數據集合里面重復的 string 對象有 13.5%
string 對象的平均長度是 45
許多大規模的 Java 應用的瓶頸在于內存，測試表明，在這些類型的應用里面，Java 堆中存活的數據集合差不多 25% 是 String 對象。更進一步，這里面差不多一半 String 對象是重復的，重復的意思是說：stringl.equals（string2）= true。堆上存在重復的 string 對象必然是一種內存的浪費。這個項目將在 G1 垃圾收集器中實現自動持續對重復的 string 對象進行去重，這樣就能避免浪費內存。
當垃圾收集器工作的時候，會訪問堆上存活的對象。對每一個訪問的對象都會檢查是否是候選的要去重的 string 對象。
如果是，把這個對象的一個引用插入到隊列中等待后續的處理。一個去重的線程在后臺運行，處理這個隊列。處理隊列的一個元素意味著從隊列刪除這個元素，然后嘗試去重它引用的 string 對象。
使用一個 hashtable 來記錄所有的被string 對象使用的不重復的 char 數組。當去重的時候，會查這個 hashtable，來看堆上是否已經存在一個一模一樣的 char 數組。
如果存在，string 對象會被調整引用那個數組，釋放對原來的數組的引用，最終會被垃圾收集器回收掉。
如果查找失敗，char 數組會被插入到 hashtable，這樣以后的時候就可以共享這個數組了。
感謝你能夠認真閱讀完這篇文章，希望小編分享的“JVM中StringTable的示例分析”這篇文章對大家有幫助，同時也希望大家多多支持億速云，關注億速云行業資訊頻道，更多相關知識等著你來學習!
免責聲明：本站發布的內容（圖片、視頻和文字）以原創、轉載和分享為主，文章觀點不代表本網站立場，如果涉及侵權請聯系站長郵箱：is@yisu.com進行舉報，并提供相關證據，一經查實，將立刻刪除涉嫌侵權內容。
