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();
}
}