基本介紹
substring方法提供兩種過載，第一種為只接受開始擷取位置一個引數的方法。
public String substring(int beginIndex)
比如我們使用上面的方法，”unhappy”.substring(2) 返回結果 ”happy”
另一種過載就是接受一個開始擷取位置和一個結束擷取位置的引數的方法。
public String substring(int beginIndex, int endIndex)
使用這個方法，”smiles”.substring(1, 5) 返回結果 ”mile”
通過這個介紹我們基本瞭解了substring的作用，這樣便於我們理解下面的內容。
準備工作
因為這個問題出現的情況在Java 6，如果你的Java版本號不是Java 6 需要調整一下。
終端調整（適用於Mac系統）
檢視java版本號
13:03 [ ubbcodeplace_3 ]nbsp;java -version java version "1.8.0_25" Java(TM) SE Runtime Environment (build 1.8.0_25-b17) Java HotSpot(TM) 64-Bit Server VM (build 25.25-b02, mixed mode)
切換到1.6
export JAVA_HOME=$(/usr/libexec/java_home -v 1.6)
Ubuntu使用alternatives –config java，Fedora上面使用alternatives –config java。
如果你使用Eclipse，可以選擇工程，右擊，選擇Properties（屬性）— Java Compiler（Java編譯器）進行特殊指定。
問題重現
這裡貼一下java官方bug裡用到的重現問題的程式碼。
public class TestGC {
private String largeString = new String(new byte[100000]);
String getString() {
return this.largeString.substring(0,2);
}
public static void main(String[] args) {
java.util.ArrayList list = new java.util.ArrayList();
for (int i = 0; i < 1000000; i++) {
TestGC gc = new TestGC();
list.add(gc.getString());
}
}
}然而上面的程式碼，只要使用Java 6 （Java 7和8 都不會丟擲異常）執行一下就會報java.lang.OutOfMemoryError: Java heap space的異常，這說明沒有足夠的堆記憶體供我們建立物件，JVM選擇了丟擲異常操作。
於是有人會說，是因為你每個迴圈中建立了一個TestGC物件，雖然我們加入ArrayList只是兩個字元的字串，但是這個物件中又儲存largeString這麼大的物件，這樣必然會造成OOM的。
然而，其實你說的不對。比如我們看一下這樣的程式碼,我們只修改getString方法。
public class TestGC {
private String largeString = new String(new byte[100000]);
String getString() {
//return this.largeString.substring(0,2);
return new String("ab");
}
public static void main(String[] args) {
java.util.ArrayList list = new java.util.ArrayList();
for (int i = 0; i < 1000000; i++) {
TestGC gc = new TestGC();
list.add(gc.getString());
}
}
}執行上面的方法，並不會導致OOM異常，因為我們持有的時1000000個ab字串物件，而TestGC物件（包括其中的largeString）會在java的垃圾回收中釋放掉。所以這裡不會存在記憶體溢位。那麼究竟是什麼導致的記憶體洩露呢？要研究這個問題，我們需要看一下方法的實現，即可。
深入Java 6實現
在String類中存在這樣三個屬性
- value 字元陣列，儲存字串實際的內容
- offset 該字串在字元陣列value中的起始位置
- count 字串包含的字元的長度
public String substring(int beginIndex, int endIndex) {
if (beginIndex < 0) {
throw new StringIndexOutOfBoundsException(beginIndex);
}
if (endIndex > count) {
throw new StringIndexOutOfBoundsException(endIndex);
}
if (beginIndex > endIndex) {
throw new StringIndexOutOfBoundsException(endIndex - beginIndex);
}
return ((beginIndex == 0) && (endIndex == count)) ? this :
new String(offset + beginIndex, endIndex - beginIndex, value);
}上述方法呼叫的構造方法
//Package private constructor which shares value array for speed.
String(int offset, int count, char value[]) {
this.value = value;
this.offset = offset;
this.count = count;
}當我們讀完上述的程式碼，我們應該會豁然開朗，原來是這個樣子啊！當我們呼叫字串a的substring得到字串b，其實這個操作，無非就是調整了一下b的offset和count，用到的內容還是a之前的value字元陣列，並沒有重新建立新的專屬於b的內容字元陣列。
舉個和上面重現程式碼相關的例子，比如我們有一個1G的字串a，我們使用substring(0,2)得到了一個只有兩個字元的字串b，如果b的生命週期要長於a或者手動設定a為null，當垃圾回收進行後，a被回收掉，b沒有回收掉，那麼這1G的記憶體佔用依舊存在，因為b持有這1G大小的字元陣列的引用。
看到這裡，大家應該可以明白上面的程式碼為什麼出現記憶體溢位了。
共享內容字元陣列
其實substring中生成的字串與原字串共享內容陣列是一個很棒的設計，這樣避免了每次進行substring重新進行字元陣列複製。正如其文件說明的,共享內容字元陣列為了就是速度。但是對於本例中的問題，共享內容字元陣列顯得有點蹩腳。
如何解決
對於之前比較不常見的1G字串只擷取2個字元的情況可以使用下面的程式碼，這樣的話，就不會持有1G字串的內容陣列引用了。
String littleString = new String(largeString.substring(0,2));
下面的這個構造方法，在源字串內容陣列長度大於字串長度時，進行陣列複製，新的字串會建立一個只包含源字串內容的字元陣列。
public String(String original) {
int size = original.count;
char[] originalValue = original.value;
char[] v;
if (originalValue.length > size) {
// The array representing the String is bigger than the new
// String itself. Perhaps this constructor is being called
// in order to trim the baggage, so make a copy of the array.
int off = original.offset;
v = Arrays.copyOfRange(originalValue, off, off+size);
} else {
// The array representing the String is the same
// size as the String, so no point in making a copy.
v = originalValue;
}
this.offset = 0;
this.count = size;
this.value = v;
}Java 7 實現
在Java 7 中substring的實現拋棄了之前的內容字元陣列共享的機制，對於子字串（自身除外）採用了陣列複製實現單個字串持有自己的應該擁有的內容。
public String substring(int beginIndex, int endIndex) {
if (beginIndex < 0) {
throw new StringIndexOutOfBoundsException(beginIndex);
}
if (endIndex > value.length) {
throw new StringIndexOutOfBoundsException(endIndex);
}
int subLen = endIndex - beginIndex;
if (subLen < 0) {
throw new StringIndexOutOfBoundsException(subLen);
}
return ((beginIndex == 0) && (endIndex == value.length)) ? this
: new String(value, beginIndex, subLen);
}substring方法中呼叫的構造方法，進行內容字元陣列複製。
public String(char value[], int offset, int count) {
if (offset < 0) {
throw new StringIndexOutOfBoundsException(offset);
}
if (count < 0) {
throw new StringIndexOutOfBoundsException(count);
}
// Note: offset or count might be near -1>>>1.
if (offset > value.length - count) {
throw new StringIndexOutOfBoundsException(offset + count);
}
this.value = Arrays.copyOfRange(value, offset, offset+count);
}真的是記憶體洩露麼
我們知道了substring某些情況下可能引起記憶體問題，但是這個叫做記憶體洩露麼？
其實個人認為這個不應該算為記憶體洩露，使用substring生成的字串b固然會持有原有字串a的內容陣列引用，但是當a和b都被回收之後，該字元陣列的內容也是可以被垃圾回收掉的。
哪個版本實現的好
關於Java 7 對substring做的修改，收到了褒貶不一的反饋。
個人更加傾向於Java 6的實現，當進行substring時，使用共享內容字元陣列，速度會更快，不用重新申請記憶體。雖然有可能出現本文中的記憶體效能問題，但也是有方法可以解決的。
Java 7的實現不需要程式設計師特殊操作避免了本文中問題，但是進行每次substring的操作效能總會比java 6 的實現要差一些。這種實現顯得有點“糟糕”。
問題的價值
雖然這個問題出現在Java 6並且Java 7中已經修復，但並不代表我們就不需要了解，況且Java 7的重新實現被噴的很厲害。
其實這個問題的價值，還是比較寶貴的，尤其是內容字元陣列共享這個優化的實現。希望可以為大家以後的設計實現提供幫助和一些想法。
受影響的方法
trim和subSequence都存在呼叫substring的操作。Java 6和Java 7 substring實現的更改也間接影響到了這些方法。
參考資源
以下三篇文章寫得都比較不錯，但是都稍微有一些問題，我都已經標明出來，大家閱讀時，需要注意。
- The substring() Method in JDK 6 and JDK 7 本文中解決java6中問題提到的字串拼接不推薦，具體原因可以參考Java細節：字串的拼接
- How SubString method works in Java – Memory Leak Fixed in JDK 1.7 本文中提到的有一個概念錯誤，新的字串不會阻止舊的字串被回收，而是阻止舊字串中的內容字元陣列。閱讀時需要注意。
- JDK-4513622 : (str) keeping a substring of a field prevents GC for object 本文中提到的有一個測試，使用非new的形式有一點問題，其忽視了字串常量池的存在，具體檢視下面的注意。
注意
上面的重現問題的程式碼中
String getString() {
//return this.largeString.substring(0,2);
return new String("ab");
}這裡最好不要寫成下面這樣，因為在JVM中存在字串常量池，”ab”不會重新建立新字串，所有的變數都會引用一個物件，而使用new String()則每次重新建立物件。
String getString() {
return "ab";
}關於字串常量池，以後的文章會有介紹。
另外，這篇文章對Java字串的10大問題進行了詳細的介紹，有興趣的朋友也可以看看。
來自：碼農網
相關閱讀
評論(1)