Java开发人员爱犯的10个错

翻译自：Top 10 Mistakes Java Developers Make

因为自己在开发过程中也有犯过其中的一些错误，觉得写的很好，所以翻译在此。

1.将数组转换为ArrayList

为了将一个数组对象转换为ArrayList对象，程序员经常是这样实现：

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

Arrays.asList()方法返回一个ArrayList，但这个ArrayList是Arrays类中的一个私有静态类，它不是java.util.ArrayList 类。java.util.Arrays.ArrayList类有set()，get()，contains()方法，但没有任何添加元素的方法，所以它的大小是固定的，源码：

    private static class ArrayList<E> extends AbstractList<E>
        implements RandomAccess, java.io.Serializable
    {
        private static final long serialVersionUID = -2764017481108945198L;
        private final E[] a;

        ArrayList(E[] array) {
            a = Objects.requireNonNull(array);
        }

        @Override
        public int size() {
            return a.length;
        }

        @Override
        public Object[] toArray() {
            return a.clone();
        }

        @Override
        @SuppressWarnings("unchecked")
        public <T> T[] toArray(T[] a) {
        }

        @Override
        public E get(int index) {
           ...
        }

        @Override
        public E set(int index, E element) {
            ...
        }

        @Override
        public int indexOf(Object o) {
            ...
        }

        @Override
        public boolean contains(Object o) {
            return indexOf(o) != -1;
        }

        @Override
        public Spliterator<E> spliterator() {
           ...
        }

        @Override
        public void forEach(Consumer<? super E> action) {
            ...
        }

        @Override
        public void replaceAll(UnaryOperator<E> operator) {
            ...
        }

        @Override
        public void sort(Comparator<? super E> c) {
            Arrays.sort(a, c);
        }
    }

可以看到这个ArrayList继承自AbstractList，自然也就实现了List接口，但是并没有重写add方法，所以不能往里面添加元素。private final E[] a;表明了数组不可变，也就是说ArrayList不可变。如果想要使用java.util.ArrayList实现可变的List，应该这样做：

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

因为ArrayList的构造方法中可以接收一个Collection参数，Collection是java.util.Arrays.ArrayList的超类。

2.判断数组是否包含指定值

程序员经常是这样做的：

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

这样确实是可以实现，但是没有必要把List转换为Set，这需要消耗额外的资源，可以简化为：

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

（List和Set都提供了contains方法）

或者

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]

这就有一个问题，在删除一个元素之后，List的长度会减小，自然元素的序号也会改变，所以如果想通过索引去删除循环内的多个元素，是不可行的。也许你知道使用迭代器是删除循环内部元素的正确方法，而且你知道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);
}

它会抛异常：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异常发生，到这里你可能想去看看 ArrayList.iterator()的源码了。

4.Hashtable vs HashMap

按照算法中的约定，Hashtable是数据结构的名称。 但是在Java中，数据结构的名字是HashMap。 Hashtable和HashMap之间的一个主要区别是Hashtable是同步的。 所以很多时候你不需要Hashtable，而应该使用HashMap。在这里不一一列举，因为比较多，可以去看下面的内容

实用链接：https://www.programcreek.com/2013/09/top-9-questions-for-java-map/，

Map几个实现类的比较：https://www.programcreek.com/2013/03/hashmap-vs-treemap-vs-hashtable-vs-linkedhashmap/

对应国内翻译版本：http://www.importnew.com/8658.html

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 有很大的不同，可以参考：

Raw type vs. Unbounded wildcard, Type Erasure。

6.访问权限

很多开发人员通常都用public修饰类的属性，通过直接引用很容易获得字段值，但这是一个非常糟糕的设计， 经验法则是给成员的访问级别尽可能低。参考：

public, default, protected, and private

7.ArrayList vs. LinkedList

当开发人员不知道ArrayList和LinkedList之间的区别时，他们经常使用ArrayList，因为它看起来很熟悉。 但是，它们之间有着巨大的性能差异。 简单的说，如果有大量的添加/删除操作，并且没有大量的随机访问操作，则应该首选LinkedList。参考：

ArrayList vs. LinkedList

8.可变与不可变

不可变对象具有简单性，安全性等诸多优点，但是对于每一个不同的值都需要一个独立的对象，过多的对象可能会导致垃圾回收成本高。 在可变和不可变之间进行选择时应该有一个平衡。通常来说，可变对象用于避免产生太多的中间对象。 一个典型的例子是连接大量的字符串， 如果你使用一个不可变的字符串，你会产生很多符合垃圾收集条件的对象，这浪费了时间和精力在CPU上，使用可变对象的正确解决方案（例如StringBuilder）。

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

还有其他的情况下，可变的对象是可取的。 例如，将可变对象传递给方法可让您收集多个结果，而不会跳过太多的语法环。 另一个例子是排序和过滤：当然，你可以创建一个方法来获取原始的集合，并返回一个已排序的集合，但是对于大集合来说，这将变得非常浪费。 （来自dasblinkenlight关于Stack Overflow的回答）

参考：Why String is Immutable?

9. 子类和父类的构造器

public class Super {
    String s;

    public Super(String s) {
        this.s = s;
    }

}

public class Sub extends Super {
    int x = 200;

    public Sub(String s) {   // 编译错误
    }

    public Sub() {           // 编译错误
        System.out.println("sub");
    }

    public static void main(String[] args) {
        Sub s = new Sub();
    }
}

出现此编译错误是因为默认的超类构造函数未定义。 在Java中，如果一个类没有定义一个构造函数，那么编译器默认会为这个类插入一个默认的无参构造函数。 如果在超类中定义了一个构造函数，在这种情况下，说super（String s），编译器将不插入默认的无参数构造函数。 以上是超类的情况。

Sub类的构造函数，无论是参数还是无参数，都会调用无参数的Super构造函数，由于编译器试图向Sub类中的2个构造函数中插入super（），但Super的默认构造函数未定义，所以编译会报错。

要解决这些错误有三个方法：

(1).在Super中添加一个默认的构造方法：

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

(2).删除Super中自定义的构造方法

(3).添加一个super(value)。

public Sub(String s) {   // 编译错误
    super(s);
}

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

有关如何在内存中分配的更多细节，参考Create Java String Using ” ” or Constructor?.