十个JAVA程序员容易犯的错误

た入场券 2022-05-26 07:40 208阅读 0赞

###### 十个JAVA程序员容易犯的错误 ######

2017年10月21日 17:07:03

阅读数：158

## 十个JAVA程序员容易犯的错误 ##

本文是翻译自

[http://www.programcreek.com/2014/05/top-10-mistakes-java-developers-make/][http_www.programcreek.com_2014_05_top-10-mistakes-java-developers-make]

### 1. Array 转 ArrayList ###

一般开发者喜欢用：

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

Arrays.asList() 会返回一个ArrayList，这是Arrays里内嵌的一个私有静态类，而并不是java.util.ArrayList类java.util.Arrays.ArrayList 有set(), get(), contains()方法，但并支持添加元素，所以大小是固定的，想要创建一个真正的ArrayList，你应该：

**\[java\]** [view plain][] [copy][view plain]

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

关于这个方法更多的解释，请参见我之前的一篇文章

[http://www.cnblogs.com/tina-smile/p/5056174.html][http_www.cnblogs.com_tina-smile_p_5056174.html]

### 2.检测一个Array是否包含一个元素 ###

一般开发者喜欢用：

**\[java\]** [view plain][] [copy][view plain]

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

这段代码能够工作，但并没有先转将list转为set，list转为set需要额外时间，可以用下面更简单的：

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

或者

**\[java\]** [view plain][] [copy][view plain]

1.  for(String s: arr)\{  
2.  if(s.equals(targetValue))  
3.      return true;  
4.  \}  
5.  return false;

第一种方法比第二种的可读性更好。

### 3. 在一个循环中移除list中的元素 ###

考虑下下面这种方法：

**\[java\]** [view plain][] [copy][view plain]

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的大小就缩减了，索引也发生了改变。所以如果想要在一个循环中使用索引移除多个元素，这是不可行的。

或许你又想用迭代器的方式解决这个问题，但实际上也不可行，考虑下下面的代码：

**\[java\]** [view plain][] [copy][view plain]

1.  ArrayList<String> list = new ArrayList<String>(Arrays.asList("a", "b", "c", "d"));  
2.    
3.  for (String s : list) \{  
4.      if (s.equals("a"))  
5.          list.remove(s);  
6.  \}

会报错 ConcurrentModificationException.

正确的应该是：

**\[java\]** [view plain][] [copy][view plain]

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.     
6.      if (s.equals("a")) \{  
7.          iter.remove();  
8.      \}  
9.  \}

### 4. Hashtable vs HashMap ###

在算法中，哈希表是数据结构的名称。但在Java中，数据结构的名字是HashMap中。其中一个Hashtable和HashMap的之间的主要区别是，Hashtable是同步的。所以，很多时候，你并不需要哈希表，HashMap就够用了。

### 5.使用原始类型的集合 ###

在Java中，原始类型和无界通配符类型很容易混在一起。以Set为例，设定为原始类型，同时set<?>是无界的通配符类型。

使用原始类型list，考虑下面的情况：

**\[java\]** [view plain][] [copy][view plain]

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.  \}

这个代码将会抛出错误：

**\[java\]** [view plain][] [copy][view plain]

1.  Exception in thread "main" java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.String  
2.  at ...

使用原始类型集合是很危险的一件事，因为它跳过了类属性检测并且是不安全的。Set, Set<?>, and Set

### 6.访问权限 ###

很多开发者使用public修饰类的字段，这样很容易获取字段值，但这是一个糟糕的设计。经验法则是给用户尽可能低的访问权限。

### 7.ArrayList vs. LinkedList ###

大部分的开发者并不知道ArrayList和LinkedList 的区别，所以经常使用ArrayList，这个看起来更熟悉。但是，在这两者之间，有一个很大的性能差异。

简单来说，在有很多插入和删除操作时，同时有很少或者几乎没有随机访问的操作情况下，推荐使用LinkedList。其次，再使用ArrayList。

### 8.Mutable vs. Immutable（可变 VS 不可变） ###

不可变对象有很多优势这样简单,安全,等等。但它对于每一个不同的变量，需要一个单独的对象。太多的对象可能会导致高成本的垃圾收集。所以在选择可变和不可变的时应该有个权衡。

一般来说,使用可变对象,以避免产生过多的中间对象。一个经典的例子就是连接大量的字符串。如果使用不可变的String，你会产生很多立马要被垃圾收集回收的对象，这很消耗时间和精力。如果使用一个不可变的，类似StringBuffer。

**\[java\]** [view plain][] [copy][view plain]

1.  String result="";  
2.  for(String s: arr)\{  
3.      result = result + s;  
4.  \}

可变对象还有其他的例子：函数传参的过程中，可以传入可变对象，这样可以得到多个结果。

### 9.父类和子类的构建 ###

![20160108175046_403.png][]

编译出错的原因主要是默认的Super类的构造函数并没有被定义。在Java中，如果一个类没有实现构造函数，编译器默认会给这个类插入一个无参构造函数。如果在父类中已经有了构造函数，那么编译器将不会再插入默认无参构造函数。

子类的构造函数，要么是带参的要么是无参的，都会调用父类的无参构造。因为编译器想在子类中，加入super()，但是父类的无参构造函数并不存在。所以，编译器会报错。

为了解决这个问题，有两种解决办法，第一，在Super类中，加入无参构造：

public Super(){
        System.out.println("Super");
    }

第二种方式，移除自定义的父类构造函数

第三种方式，子类的构造函数中加入super(value)

### 10."" or Constructor? ###

创建一个String 有两种方式：

**\[java\]** [view plain][] [copy][view plain]

1.  //1. use double quotes  
2.  String x = "abc";  
3.  //2. use constructor  
4.  String y = new String("abc");

区别是什么？

**\[java\]** [view plain][] [copy][view plain]

1.  String a = "abcd";  
2.  String b = "abcd";  
3.  System.out.println(a == b);  // True  
4.  System.out.println(a.equals(b)); // True  
5.     
6.  String c = new String("abcd");  
7.  String d = new String("abcd");  
8.  System.out.println(c == d);  // False  
9.  System.out.println(c.equals(d)); // True

[http_www.programcreek.com_2014_05_top-10-mistakes-java-developers-make]: http://www.programcreek.com/2014/05/top-10-mistakes-java-developers-make/
[view plain]: https://blog.csdn.net/smilelvcha/article/details/78304902#
[http_www.cnblogs.com_tina-smile_p_5056174.html]: http://www.cnblogs.com/tina-smile/p/5056174.html
[20160108175046_403.png]: /images/20220526/ac337c1afec540ee9c2c972c9445c2fc.png