1. 程式人生 > >Java基礎3:深入理解String及包裝類

Java基礎3:深入理解String及包裝類

運行 例子 integer image soft 浪費 十分 應該 pub

Java基礎3:深入理解String及包裝類

String的連接

@Test
public void contact () {
//1連接方式
String s1 = "a";
String s2 = "a";
String s3 = "a" + s2;
String s4 = "a" + "a";
String s5 = s1 + s2;
//表達式只有常量時,編譯期完成計算
//表達式有變量時,運行期才計算,所以地址不一樣
System.out.println(s3 == s4); //f
System.out.println(s3 == s5); //f
System.out.println(s4 == "aa"); //t
?
}

String類型的intern

public void intern () {
//2:string的intern使用
//s1是基本類型,比較值。s2是string實例,比較實例地址
//字符串類型用equals方法比較時只會比較值
String s1 = "a";
String s2 = new String("a");
//調用intern時,如果s2中的字符不在常量池,則加入常量池並返回常量的引用
String s3 = s2.intern();
System.out.println(s1 == s2); //f
System.out.println(s1 == s3); //t
}

String類型的equals

//字符串的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;
// }

StringBuffer和Stringbuilder

底層是繼承父類的可變字符數組value

/**
* The value is used for character storage.
*/
char[] value;
初始化容量為16
?
/**
* Constructs a string builder with no characters in it and an
* initial capacity of 16 characters.
*/
public StringBuilder() {
super(16);
}
//這兩個類的append方法都是來自父類AbstractStringBuilder的方法
?
public AbstractStringBuilder append(String str) {
if (str == null)
return appendNull();
int len = str.length();
ensureCapacityInternal(count + len);
str.getChars(0, len, value, count);
count += len;
return this;
}
@Override
public StringBuilder append(String str) {
super.append(str);
return this;
}
?
@Override
public synchronized StringBuffer append(String str) {
toStringCache = null;
super.append(str);
return this;
}

append

Stringbuffer在大部分涉及字符串修改的操作上加了synchronized關鍵字來保證線程安全,效率較低。
?
String類型在使用 + 運算符例如
?
String a = "a"
?
a = a + a;時,實際上先把a封裝成stringbuilder,調用append方法後再用tostring返回,所以當大量使用字符串加法時,會大量地生成stringbuilder實例,這是十分浪費的,這種時候應該用stringbuilder來代替string。

擴容

//註意在append方法中調用到了一個函數
?
ensureCapacityInternal(count + len);
//該方法是計算append之後的空間是否足夠,不足的話需要進行擴容
?
public void ensureCapacity(int minimumCapacity) {
if (minimumCapacity > 0)
ensureCapacityInternal(minimumCapacity);
}
private void ensureCapacityInternal(int minimumCapacity) {
// overflow-conscious code
if (minimumCapacity - value.length > 0) {
value = Arrays.copyOf(value,
newCapacity(minimumCapacity));
}
}
/*如果新字符串長度大於value數組長度則進行擴容
?
擴容後的長度一般為原來的兩倍 + 2;
?
假如擴容後的長度超過了jvm支持的最大數組長度MAX_ARRAY_SIZE。
?
考慮兩種情況
?
如果新的字符串長度超過int最大值,則拋出異常,否則直接使用數組最大長度作為新數組的長度。*/
?
private int hugeCapacity(int minCapacity) {
if (Integer.MAX_VALUE - minCapacity < 0) { // overflow
throw new OutOfMemoryError();
}
return (minCapacity > MAX_ARRAY_SIZE)
? minCapacity : MAX_ARRAY_SIZE;
}

刪除

這兩個類型的刪除操作:
?
都是調用父類的delete方法進行刪除
?
public AbstractStringBuilder delete(int start, int end) {
if (start < 0)
throw new StringIndexOutOfBoundsException(start);
if (end > count)
end = count;
if (start > end)
throw new StringIndexOutOfBoundsException();
int len = end - start;
if (len > 0) {
System.arraycopy(value, start+len, value, start, count-end);
count -= len;
}
return this;
}
//事實上是將剩余的字符重新拷貝到字符數組value。

這裏用到了system.arraycopy來拷貝數組,速度是比較快的

system.arraycopy方法

轉自知乎:
?
在主流高性能的JVM上(HotSpot VM系、IBM J9 VM系、JRockit系等等),可以認為System.arraycopy()在拷貝數組時是可靠高效的——如果發現不夠高效的情況,請報告performance bug,肯定很快就會得到改進。
?
java.lang.System.arraycopy()方法在Java代碼裏聲明為一個native方法。所以最native的實現方式就是通過JNI調用JVM裏的native代碼來實現。

String的不可變性

關於String的不可變性,這裏轉一個不錯的回答

什麽是不可變?

String不可變很簡單,如下圖,給一個已有字符串”abcd”第二次賦值成”abcedl”,不是在原內存地址上修改數據,而是重新指向一個新對象,新地址。 技術分享圖片

String為什麽不可變?

翻開JDK源碼,java.lang.String類起手前三行,是這樣寫的:

public final class String implements java.io.Serializable, Comparable<String>, CharSequence {   
/** String本質是個char數組. 而且用final關鍵字修飾.*/
private final char value[]; ... ...
}

首先String類是用final關鍵字修飾,這說明String不可繼承。再看下面,String類的主力成員字段value是個char[]數組,而且是用final修飾的。

final修飾的字段創建以後就不可改變。 有的人以為故事就這樣完了,其實沒有。因為雖然value是不可變,也只是value這個引用地址不可變。擋不住Array數組是可變的事實。

Array的數據結構看下圖。 技術分享圖片

也就是說Array變量只是stack上的一個引用,數組的本體結構在heap堆。

String類裏的value用final修飾,只是說stack裏的這個叫value的引用地址不可變。沒有說堆裏array本身數據不可變。看下面這個例子,

final int[] value={1,2,3} ;
int[] another={4,5,6};
 value=another;    //編譯器報錯,final不可變 value用final修飾,編譯器不允許我把value指向堆區另一個地址。
但如果我直接對數組元素動手,分分鐘搞定。

 final int[] value={1,2,3};
 value[2]=100;  //這時候數組裏已經是{1,2,100}   所以String是不可變,關鍵是因為SUN公司的工程師。
 在後面所有String的方法裏很小心的沒有去動Array裏的元素,沒有暴露內部成員字段。

private final char value[]這一句裏,private的私有訪問權限的作用都比final大。而且設計師還很小心地把整個String設成final禁止繼承,避免被其他人繼承後破壞。所以String是不可變的關鍵都在底層的實現,而不是一個final。考驗的是工程師構造數據類型,封裝數據的功力。 

不可變有什麽好處?

這個最簡單地原因,就是為了安全。看下面這個場景(有評論反應例子不夠清楚,現在完整地寫出來),一個函數appendStr( )在不可變的String參數後面加上一段“bbb”後返回。appendSb( )負責在可變的StringBuilder後面加“bbb”。

總結以下String的不可變性。

1 首先final修飾的類只保證不能被繼承,並且該類的對象在堆內存中的地址不會被改變。

2 但是持有String對象的引用本身是可以改變的,比如他可以指向其他的對象。

3 final修飾的char數組保證了char數組的引用不可變。但是可以通過char[0] = ‘a’來修改值。不過String內部並不提供方法來完成這一操作,所以String的不可變也是基於代碼封裝和訪問控制的。

舉個例子

final class Fi {
    int a;
    final int b = 0;
    Integer s;

}
final char[]a = {‘a‘};
final int[]b = {1};
@Test
public void final修飾類() {
    //引用沒有被final修飾,所以是可變的。
    //final只修飾了Fi類型,即Fi實例化的對象在堆中內存地址是不可變的。
    //雖然內存地址不可變,但是可以對內部的數據做改變。
    Fi f = new Fi();
    f.a = 1;
    System.out.println(f);
    f.a = 2;
    System.out.println(f);
    //改變實例中的值並不改變內存地址。


    Fi ff = f;
    //讓引用指向新的Fi對象,原來的f對象由新的引用ff持有。
    //引用的指向改變也不會改變原來對象的地址
    f = new Fi();
    System.out.println(f);
    System.out.println(ff);
}
這裏的對f.a的修改可以理解為char[0] = ‘a‘這樣的操作。只改變數據值,不改變內存值。

Java基礎3:深入理解String及包裝類