Java 程序員排行前 10 的錯誤，你會不會解決？

作者 | 風一樣的碼農

來源 | cnblogs.com/chenpi/p/5508949.html

• Array轉ArrayList

• 判斷一個數組是否包含某個值

• 在循環內部刪除List中的一個元素

• HashTable與HashMap

• 使用集合原始類型（raw type）

• 訪問級別

• ArrayList和LinkedList

• 可變與不可變

• 父類和子類的構造方法

• “”還是構造方法

• 未來工作

---

這個列表總結了10個Java開發人員最常犯的錯誤。

Array轉ArrayList

當需要把Array轉成ArrayList的時候，開發人員經常這樣做：

List<String> list = Arrays.asList(arr);

Arrays.asList()會返回一個ArrayList，但是要特別注意，這個ArrayList是Arrays類的靜態內部類，並不是java.util.ArrayList類。java.util.Arrays.ArrayList類實現了set()， get()，contains()方法，但是並沒有實現增加元素的方法（事實上是可以調用add方法，但是沒有具體實現，僅僅拋出UnsupportedOperationException異常），因此它的大小也是固定不變的。爲了創建一個真正的java.util.ArrayList，你應該這樣做：

ArrayList<String> arrayList = new ArrayList<String>(Arrays.asList(arr));

ArrayList的構造方法可以接收一個Collection類型，而java.util.Arrays.ArrayList已經實現了該接口。

判斷一個數組是否包含某個值

開發人員經常這樣做：

1. Set<String> set = new HashSet<String>(Arrays.asList(arr));

2. return set.contains(targetValue);

以上代碼可以正常工作，但是沒有必要將其轉換成set集合，將一個List轉成Set需要額外的時間，其實我們可以簡單的使用如下方法即可：

Arrays.asList(arr).contains(targetValue);

或者

1. for(String s: arr){

2.     if(s.equals(targetValue))

3.         return true;

4. }

5. return false;

第一種方法可讀性更強。

在循環內部刪除List中的一個元素

考慮如下代碼，在迭代期間刪除元素：

1. ArrayList<String> list = new ArrayList<String>(Arrays.asList("a", "b", "c","d"));

2. for (int i = 0; i < list.size(); i++) {

3.     list.remove(i);

4. }

5. System.out.println(list);

結果打印：[b, d]

在上面這個方法中有一系列的問題，當一個元素被刪除的時候，list大小減小，然後原先索引指向了其它元素。所以如果你想在循環裏通過索引來刪除多個元素，將不會正確工作。

你也許知道使用迭代器是在循環裏刪除元素的正確方式，或許你也知道foreach循環跟迭代器很類似，但事實情況卻不是這樣，如下代碼：

1. ArrayList<String> list = new ArrayList<String>(Arrays.asList("a", "b", "c","d"));

2. for (String s : list) {

3.     if (s.equals("a"))

4.         list.remove(s);

5. }

將拋出ConcurrentModificationException異常。

然而接下來的代碼卻是OK的：

1. ArrayList<String> list = new ArrayList<String>(Arrays.asList("a", "b", "c","d"));

2. Iterator<String> iter = list.iterator();

3. while (iter.hasNext()) {

4.     String s = iter.next();

5.     if (s.equals("a")) {

6.         iter.remove();

7.     }

8. }

next()方法需要在remove()方法之前被調用，在foreach循環裏，編譯器會在刪除元素操作化調用next方法，這導致了ConcurrentModificationException異常。更多詳細信息，可以查看ArrayList.iterator()的源碼。

HashTable與HashMap

從算法的角度來講，HashTable是一種數據結構名稱。但是在Java中，這種數據結構叫做HashMap。HashTable與HashMap的一個主要的區別是HashTable是同步的，所以，通常來說，你會使用HashMap，而不是Hashtable。

更多信息：HashMap vs. TreeMap vs. Hashtable vs. LinkedHashMap Top 10 questions about Map

使用集合原始類型（raw type）

在Java中，原始類型（raw type）和無界通配符類型很容易讓人混淆。舉個Set的例子，Set是原始類型，而Set是無界通配符類型。

請看如下代碼，add方法使用了一個原始類型的List作爲入參：

1. public static void add(List list, Object o){

2.     list.add(o);

3. }

4. public static void main(String[] args){

5.     List<String> list = new ArrayList<String>();

6.     add(list, 10);

7.     String s = list.get(0);

8. }

運行以上代碼將會拋出異常：

Exception in thread "main" java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.Stringat …

使用原始類型集合非常危險，因爲它跳過了泛型類型檢查，是不安全的。另外，Set, Set, 和Set這三個有很大的不同，具體請看：類型擦除和Raw type vs. Unbounded wildcard。

訪問級別

開發人員經常使用public修飾類字段，雖然這很容易讓別人直接通過引用獲取該字段的值，但這是一個不好的設計。根據經驗，應該儘可能的降低成員屬性的訪問級別。

相關閱讀：public, default, protected, and private

ArrayList和LinkedList

爲什麼開發人員經常使用ArrayList和LinkedList，卻不知道他們之間的區別，因爲它們看起來很像。然而它們之間有着巨大的性能差異。簡單的說，如果有大量的增加刪除操作並且沒有很多的隨機訪問元素的操作，應該首選LinkedList。

相關閱讀：ArrayList vs. LinkedList

可變與不可變

不可變對象有很多優點，如簡單、安全等。但是對於每個不同的值都需要一個單獨的對象，太多的對象會引起大量垃圾回收，因此在選擇可變與不可變的時候，需要有一個平衡。

通常，可變對象用於避免產生大量的中間對象，一個經典的例子是大量字符串的拼接。如果你使用一個不可變對象，將會馬上產生大量符合垃圾回收標準的對象，這浪費了CPU大量的時間和精力。使用可變對象是正確的解決方案（StringBuilder）；

1. String result="";

2. for(String s: arr){

3.     result = result + s;

4. }

另外，在有些其它情況下也是需要使用可變對象。例如往一個方法傳入一個可變對象，然後收集多種結果，而不需要寫太多的語法。另一個例子是排序和過濾：當然，你可以寫一個方法來接收原始的集合，並且返回一個排好序的集合，但是那樣對於大的集合就太浪費了。

更多閱讀：Why String is Immutable??

Why we need mutable classes?

父類和子類的構造方法

之所以出現這個編譯錯誤，是因爲父類的默認構造方法未定義。在Java中，如果一個類沒有定義構造方法，編譯器會默認插入一個無參數的構造方法；但是如果一個構造方法在父類中已定義，在這種情況，編譯器是不會自動插入一個默認的無參構造方法，這正是以上demo的情況；

對於子類來說，不管是無參構造方法還是有參構造方法，都會默認調用父類的無參構造方法；當編譯器嘗試在子類中往這兩個構造方法插入super()方法時，因爲父類沒有一個默認的無參構造方法，所以編譯器報錯；

要修復這個錯誤，很簡單：

1、在父類手動定義一個無參構造方法：

1. public Super(){

2.     System.out.println("Super");

3. }

2、移除父類中自定義的構造方法

3、在子類中自己寫上父類構造方法的調用；如super(value)；

“”還是構造方法

有兩種創建字符串的方式：

1. //1. use double quotes

2. String x = "abc";

3. //2. use constructor

4. String y = new String("abc");

它們之間有什麼區別呢？

以下代碼提供了一個快速回答：

1. String a = "abcd";

2. String b = "abcd";

3. System.out.println(a == b); // True

4. System.out.println(a.equals(b)); // True

5. String c = new String("abcd");

6. String d = new String("abcd");

7. System.out.println(c == d); // False

8. System.out.println(c.equals(d)); // True