編寫高效Java代碼 java.lang.String類和java.util.Vector類

養成好的代碼編寫習慣非常重要，比如正確地、巧妙地運用java.lang.String類和java.util.Vector類，它能夠顯著地提高程式的效能。下面我們就來具體地分析一下這方面的問題。

在java中，使用最頻繁、同時也是濫用最多的一個類或許就是java.lang.String，它也是導致代碼效能低下最主要的原因之一。請考慮下面這個例子：

 

String s1 = "Testing String";
String s2 = "Concatenation Performance";
String s3 = s1 + " " + s2;

幾乎所有的Java程式員都知道上面的代碼效率不高。那麼，我們應該怎麼辦呢？也許可以試試下面這種代碼：

 

StringBuffer s = new StringBuffer();
s.append("Testing String");
s.append(" ");
s.append("Concatenation Performance");
String s3 = s.toString();

這些代碼會比第一個程式碼片段效率更高嗎？答案是否定的。這裡的代碼實際上正是編譯器編譯第一個程式碼片段之後的結果。既然與使用多個獨立的
String對象相比，StringBuffer並沒有使代碼有任何效率上的提高，那為什麼有那麼多的Java書籍批評第一種方法、推薦使用第二種方法？

第二個程式碼片段用到了StringBuffer類（編譯器在第一個片段中也將使用StringBuffer類），我們來分析一下StringBuffer類的預設建構函式，下面是它的代碼：

 

public StringBuffer() { this(16); }

預設建構函式預設了16個字元的緩衝容量。現在我們再來看看StringBuffer類的append()方法：

 

public synchronized StringBuffer append(String str) {
 if (str == null) {
    str = String.valueOf(str);
  }
 int len = str.length();
 int newcount = count + len;
 if (newcount > value.length) expandCapacity(newcount);
 str.getChars(0, len, value, count);
 count = newcount; return this;
}

append()方法首先計算字串追加完成後的總長度，如果這個總長度大於StringBuffer的儲存能力，append()方法調
用私人的expandCapacity()方法。expandCapacity()方法在每次被調用時使StringBuffer儲存能力加倍，並把現有
的字元數組內容複寫到新的儲存空間。

在第二個程式碼片段中（以及在第一個程式碼片段的編譯結果中），由於字串追加操作的最後結果是“Testing String
Concatenation
Performance”，它有40個字元，StringBuffer的儲存能力必須擴充兩次，從而導致了兩次代價昂貴的複製操作。因此，我們至少有一點
可以做得比編譯器更好，這就是分配一個初始儲存容量大於或者等於40個字元的StringBuffer，如下所示：

 

StringBuffer s = new StringBuffer(45);
s.append("Testing String");
s.append(" ");
s.append("Concatenation Performance");
String s3 = s.toString();

再考慮下面這個例子：

String s = "";
int sum = 0;
for(int I=1; I<10; I++) {
  sum += I;
  s = s + "+" +I ;
 }
s = s + "=" + sum;

分析一下為何前面的代碼比下面的代碼效率低：

 

StringBuffer sb = new StringBuffer();
int sum = 0;
 for(int I=1;
 I<10; I++){
  sum + = I;
  sb.append(I).append("+");
 }
String s = sb.append("=").append(sum).toString();

原因就在於每個s = s + "+" + I操作都要建立並拆除一個StringBuffer對象以及一個String對象。這完全是一種浪費，而在第二個例子中我們避免了這種情況。

我們再來看看另外一個常用的Java類??java.util.Vector。簡單地說，一個Vector就是一個
java.lang.Object執行個體的數組。Vector與數組相似，它的元素可以通過整數形式的索引訪問。但是，Vector類型的對象在建立之後，
對象的大小能夠根據元素的增加或者刪除而擴充、縮小。請考慮下面這個向Vector加入元素的例子：

 

Object obj = new Object();
 Vector v = new Vector(100000);
 for(int I=0;
 I<100000; I++) { v.add(0,obj); }

除非有絕對充足的理由要求每次都把新元素插入到Vector的前面，否則上面的代碼對效能不利。在預設建構函式中，Vector的初始儲存
能力是10個元素，如果新元素加入時儲存能力不足，則以後儲存能力每次加倍。Vector類就象StringBuffer類一樣，每次擴充儲存能力時，所
有現有的元素都要複製到新的儲存空間之中。下面的程式碼片段要比前面的例子快幾個數量級：

 

Object obj = new Object();
 Vector v = new Vector(100000);
 for(int I=0; I<100000; I++) { v.add(obj); }

同樣的規則也適用於Vector類的remove()方法。由於Vector中各個元素之間不能含有“空隙”，刪除除最後一個元素之外的任意其他元素都導致被刪除元素之後的元素向前移動。也就是說，從Vector刪除最後一個元素要比刪除第一個元素“開銷”低好幾倍。

假設要從前面的Vector刪除所有元素，我們可以使用這種代碼：

 

for(int I=0; I<100000; I++){ v.remove(0); }

但是，與下面的代碼相比，前面的代碼要慢幾個數量級：

 

for(int I=0; I<100000; I++){ v.remove(v.size()-1); }

從Vector類型的對象v刪除所有元素的最好方法是：

 

v.removeAllElements();

假設Vector類型的對象v包含字串“Hello”。考慮下面的代碼，它要從這個Vector中刪除“Hello”字串：

 

String s = "Hello"; int i = v.indexOf(s); if(I != -1) v.remove(s);

這些代碼看起來沒什麼錯誤，但它同樣對效能不利。在這段代碼中，indexOf()方法對v進行順序搜尋尋找字串“Hello”，remove(s)方法也要進行同樣的順序搜尋。改進之後的版本是：

 

String s = "Hello"; int i = v.indexOf(s); if(I != -1) v.remove(i);

這個版本中我們直接在remove()方法中給出待刪除元素的精確索引位置，從而避免了第二次搜尋。一個更好的版本是：

 

String s = "Hello"; v.remove(s);

最後，我們再來看一個有關Vector類的程式碼片段：

Vector v=new Vector(100 000);

for(int I=0; I<v.size();i++);

如果v包含100,000個元素，這個程式碼片段將調用v.size()方法100,000次。雖然size方法是一個簡單的方法，但它仍舊
需要一次方法調用的開銷，至少JVM需要為它配置以及清除堆棧環境。在這裡，for迴圈內部的代碼不會以任何方式修改Vector類型對象v的大小，因此
上面的代碼最好改寫成下面這種形式：

 

int size = v.size(); for(int I=0; I<v.size();i++);