这篇文章总结了十大Java开发者经常会出现的错误
1.Convert Array to ArrayList
大多数程序员经常会按这样的方式将数组转换成 ArrayList:
List<String> list = Arrays.asList(arr);
Arrays.asList()将返回一个ArrayList的静态内部类Arrays,而不是java.util.ArrayList本身.java.util.Arrays.ArrayList类拥有set(),get(),contains()方法,但是无法向其中添加元素,所以它的大小是固定的.想要创建一个Arraylist,需要这样做:
ArrayList<String> arrayList = new ArrayList<String>(Arrays.asList(arr));
2.Check if an Array Contains a Value
开发经常会这样做:
Set<String> set = new HashSet<String>(Arrays.asList(arr));
return set.contains(targetValue);
这段代码当然是可以达到目的的,但是没必要将 list 转成 set,这个转换过程本身是需要时间的,我们可以简单的这样写:
Arrays.asList(arr).contains(targetValue);
或者是这样写:
for(String s: arr){
if(s.equals(targetValue))
return true;
}
return false;
第一种写法比第二种更具可读性
3.Remove an Element from a list inside a Loop
思考一下下面在循环中删除元素的代码:
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]
这里有一个严重的问题.当一个元素被删除,list 的size 会变小,并且 index 也会变.所以如果你想要通过使用index在循环中删除多个元素,并不会得到正确的结果
你可以知道使用iterator是一个循环中删除元素的正确方式,并且你知道 foreach 循环底层便是用的 iterator,所以你认为可以使用foreach 循环,但实际上也并非如此,思考一下如下代码:
ArrayList<String> list = new ArrayList<String>(Arrays.asList("a", "b", "c", "d"));
for (String s : list) {
if (s.equals("a"))
list.remove(s);
}
这段代码会抛出ConcurrentModificationException异常,感兴趣的同学可以试一下
而接下来这段代码是可以工作的:
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 循环中,编译器会让.next()在删除操作之后被调用,所以会造成ConcurrentModificationException异常.
4.Hashtable vs HashMap
根据约定的算法,Hashtable是数据结构的命名.但是在Java中,数据结构的名称是 HashMap.这两者之前最关键的一个区别是 Hashtableis 是同步的(synchronized).所以在大多数情况中是无需使用Hashtable的.
如果想要更深的了解这两者的区别,可以看这篇文章
HashMap vs. TreeMap vs. Hashtable vs. LinkedHashMap
5.Use Raw Type of Collection
在 Java 中,raw type 和 unbounded wildcard type 很容易被混在一起.举一个简单的栗子,Set是 raw type,而Set<?>是unbounded wildcard type.
思考下如下代码:
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 ...
使用 raw type collection 向来是危险的,因为 raw type collection 跳过了泛型类型检查的步骤,并且也不安全.
Set,Set<?>和Set<Object>之前还有很多的不同,如果感兴趣,可以查看这篇文章
Raw type vs. Unbounded wildcard
6.Access Level
很多开发会给类的属性使用 public 修饰符.这样做可以很方便的直接引用属性值,但这是一个非常不好的设计.经验告诉我们,我们需要尽可能的赋予成员更低的访问权限
7.ArrayList vs. LinkedList
当开发不知道ArrayList和LinkedList的区别是,他们通常会使用ArrayList,因为看起来更熟悉一些.然而这两者之间在性能上有着巨大的差异.简而言之,LinkedList通常使用在需要大量的删除插入操作,而没有过多的随机读取操作的情形中.而ArraryList则正相反.通常知道这个也就能区分大多数的使用场景了,如果想要了解更多,可以查看这篇文章ArrayList vs. LinkedList
8.Mutable vs. Immutable
不可变对象有很多的好处,比如简单,安全等等.但是它们对应每一个不同的值,都需要一个单独的对象,而太多的对象又会造成 GC 的消耗.所以选择可变对象还是不可变对象,这里需要一个平衡.
通常来说,变量的使用是为了避免创建过多的中间对象.一个经典的例子是连接大量的 string.如果使用不可变string,就会在短时间内创建大量符合 GC 回收标准的对象.这会浪费CPU 的时间和性能.在这里使用可变对象是一个好的选择
String result="";
for(String s: arr){
result = result + s;
}
还有其他很多情况可以使用可变对象.比如给方法传递一个可变对象,你就可以很方便的收集到多个返回结果,而不需要通过多个方法来获取.另外一个栗子是排序和筛选.当然,你也可以创建一个方法,接收一个原始的 collection,返回排序好的 collection.但是这会造成大量的资源空间的浪费.
9.Constructor of Super and Sub
造成这个编译错误的原因是父类 super 没有默认的构造方法.在 Java 中,如果一个类没有定义构造方法,编译器会添加一个默认的无参构造方法.如果父类定义 了一个构造方法,在这个栗子中就是
Super(String s),编译器就不会添加默认的无参构造方法了.
而在这个栗子的子类中,无论是有参构造方法还是无参构造方法,都会调用父类的无参构造方法.当编译器试图为子类的两个构造方法添加super()方法时,因为父类没有定义默认构造方法,编译器就报出了这个错误.
为了解决这个问题.简单的1)为父类添加一个无参构造方法:
public Super(){
System.out.println("Super");
}
,或者2)删除父类自定义的构造方法,3)为子类的构造方法手动添加super(value)方法.
10.""or Constructor?
string 可以通过两种方式被创建:
//1. use double quotes
String x = "abc";
//2. use constructor
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
