Top 10 Mistakes Java Developers Make(转)-白红宇

Top 10 Mistakes Java Developers Make(转)

阅读量：7120 次

发布时间：2019-06-28

本文共 4046 字，大约阅读时间需要 13 分钟。

文章列出了Java开发者最常犯的是个错误。

1.将数组转换为ArrayList

为了将数组转换为ArrayList，开发者经常会这样做：

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

Arrays.asList()会返回一个ArrayList，但这个ArrayList是Arrays的私有静态类，不是java.util.ArrayList。java.util.Arrays.ArrayList有set(), get(), contains()方法，但没有任何能增加元素的方法，所以它的大小是确定的。为了创建一个真正的ArrayList，应该这样做：

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

ArrayList的构造函数能够接收一个Collection类型，而它也是java.util.Arrays.ArrayList的一个祖先类。

2.检查一个数组是否包含某个值

开发者经常这样做：

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

这个的代码可以工作，但没必要首先把数组转换为集合，把数组转换为集合需要额外的时间。可以这样做：

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

或者

                            
for
(String s: arr){ 
    
if
(s.equals(targetValue))
        
return
true
;
}
return
false
;
         
       

第一个比第二个的可读性更好。

3.在循环里边删除列表的元素

思考下面的代码，该代码在循环里边删除元素

                            
ArrayList<String> list = 
new
ArrayList<String>(Arrays.asList(
"a"
, 
"b"
, 
"c"
, 
"d"
));
for
(
int
i = 
0
; i < list.size(); i++) { 
    
list.remove(i);
}
System.out.println(list);
         
       

输出如下：

                            
[b, d]

上面的方法有一个严重的问题。当一个元素被移除后，列表的大小减小了，索引也就变了。所以希望利用索引在一个循环里边删除多个元素是做不到的。你可能知道利用迭代器在一个循环里边删除元素是正确的方法，并且知道Java的foreach循环很像一个迭代器，但事实上不是。思考下面的代码：

                            
ArrayList<String> list = 
new
ArrayList<String>(Arrays.asList(
"a"
, 
"b"
, 
"c"
, 
"d"
));
for
(String s : list) { 
    
if
(s.equals(
"a"
))
        
list.remove(s);
}
         
       

它将会抛出异常。下面的代码是可以的：

                            
ArrayList<String> list = 
new
ArrayList<String>(Arrays.asList(
"a"
, 
"b"
, 
"c"
, 
"d"
));
Iterator<String> iter = list.iterator();
while
(iter.hasNext()) { 
    
String s = iter.next();
    
if
(s.equals(
"a"
)) { 
        
iter.remove();
    
}
}
         
       

.next()方法必须在调用.remove()方法之前调用。在foreach循环里边，编译器会先调用.remove()，再调用.next()，从而导致异常ConcurrentModificationException。你可能想知道的源代码。

4.HashTable vs HashMap

根据算法的约定，HashTable是这个数据结构的名字，但在Java里边，HashMap是这个数据结构的名字。Hashtable和 HashMap的一个关键性的不同是，HashTable是同步的，而HashMap不是。所以通常不需要HashTable，HashMap用的更多。

5.使用原始集合类型

在Java里边，原始类型和无界通配符类型很容易混合在一起。以Set为例，Set是一个原始类型，而Set< ? >是一个无界通配符类型。考虑下面使用原始类型List作为参数的代码：

                            
public
static
void
add(List list, Object o){ 
    
list.add(o);
}
public
static
void
main(String[] args){ 
    
List<String> list = 
new
ArrayList<String>();
    
add(list, 
10
);
    
String s = list.get(
0
);
}
         
       

上面的代码将会抛出异常：

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

使用原始集合类型是很危险的，因为原始集合类型跳过了泛型类型检查，是不安全的。Set、Set< ? >和Set< Object >之间有很大差别。请参考和。

6.访问级别

开发者经常使用Public作为类的修饰符，这样可以很简单的通过直接引用得到值，但这是一个非常糟糕的设计。根据经验，分配给成员的访问级别应尽可能的低。

7.ArrayList vs LinkedList

当开发者不知道ArrayList和LinkedList的区别的时候，通常会使用ArrayList，因为它看起来更熟悉。然而，两者之间有很大的性能差异。简单地说，当有大量的插入/删除操作并且没有太多的随机访问操作的时候，应该使用LinkedList。如果对此不太了解，可参考。

8.可变与不可变

不可变对象有许多的优点，比如简单，安全等等。但是对于每一个不同的值都要有一个独立的对象，过多的对象导致垃圾回收的高消耗。当选择可变与不可变时应该有一个权衡。通常情况下，可变对象可以用来避免产生过多的中间对象。一个经典的实例就是连接大量的字符串，如果使用不可变的字符串，将会产生大量的需要进行垃圾回收的对象。这会浪费CPU大量的时间，使用可变对象才是正确的方案(比如StringBuilder)。

                            
String result=
""
;
for
(String s: arr){ 
    
result = result + s;
}
         
       

在其它的一些情况下也是需要使用可变对象的，比如将可变对象作为参数传入方法可以使你不需要使用很多语句便可以得到多个结果。另外一个例子是排序和过滤：当然，你可以写一个方法来接收原始的集合，并且返回一个排好序的集合，但是那样对于大的集合就太浪费了。(来自StackOverFlow的）。

9.父类和子类的构造函数

因为没有定义父类的默认构造函数，在编译的时候会产生错误。在Java里边，如果一个类没有定义构造函数，编译器将会插入一个无参数的默认构造函数。如果在父类里边定义了一个构造函数，在此例中即Super(String s)，编译器将不会插入默认的无参数构造函数。这就是上面示例中父类的情形。子类的构造函数，不管是没有参数还有有参数，都会调用父类的无参构造函数。因为编译器试图把super()插入到子类的两个构造函数中。但是父类默认的构造函数未定义，编译器就会报出这个错误信息。要修复这个问题，可以简单的通过1)在父类中添加一个Super()构造方法，就像这样：

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

或者2)移除自定义的父类构造函数，或者3)在子类的构造函数中调用父类的super(value)。

10.”“还是构造函数？

有两种方式构造字符串：

                            
//1. 利用双引号
String x = 
"abc"
;
//2. 利用构造函数
String y = 
new
String(
"abc"
);
         
       

区别在哪？下面的例子可以给出一个快速的答案：

                            
String a = 
"abcd"
;
String b = 
"abcd"
;
System.out.println(a == b);  
// True
System.out.println(a.equals(b)); 
// True
String c = 
new
String(
"abcd"
);
String d = 
new
String(
"abcd"
);
System.out.println(c == d);  
// False
System.out.println(c.equals(d)); 
// True
         
       