本列表总结了Java开发人员经常犯的十大错误。
1.转换数组为ArrayList
将数组转成一个ArrayList，开发者经常这样做：
List<String> list = Arrays.asList(arr);
Arrays.asList()将返回一个ArrayList，它是数组中的一个私有静态类，它不是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;
代码1的可读性更好，特别注意其实这个包含检测其实非常耗时间的。
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);
}
它会抛出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。
HashMap vs. TreeMap vs. Hashtable vs. LinkedHashMap
Top 10 questions about Map
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>有很大的不同。
Raw type vs. Unbounded wildcard
Type Erasure
6 访问权限
开发人员经常使用公共领域。 通过直接引用很容易获得字段值，但这是一个非常糟糕的设计。 经验法则是给成员的访问级别尽可能低。
public, default, protected, and private
7. ArrayList vs. LinkedList
当开发人员不知道ArrayList和LinkedList之间的区别时，他们经常使用ArrayList，因为它看起来很熟悉。 但是，它们之间有着巨大的性能差异。 简而言之，如果有大量的添加/删除操作，并且没有大量的随机访问操作，则应该首选LinkedList。 查看ArrayList与LinkedList，以获取有关其性能的更多信息，如果这对您而言是新的。
.
8 可变与不可变
不可变对象具有简单性，安全性等诸多优点，但是对于每一个不同的值都需要一个独立的对象，过多的对象可能会导致垃圾收集成本高。 在可变和不可变之间进行选择时应该有一个平衡。
通常，可变对象用于避免产生太多的中间对象。 一个典型的例子是连接大量的字符串。 如果你使用一个不可变的字符串，你会产生很多符合垃圾收集条件的对象。 这浪费了时间和精力在CPU上，使用可变对象的正确解决方案（例如StringBuilder）。
String result="";
for(String s: arr){
result = result + s;
}
还有其他的情况下，可变的对象是可取的。 例如，将可变对象传递给方法可让您收集多个结果，而不会跳过太多的语法环。 另一个例子是排序和过滤：当然，你可以创建一个方法来获取原始的集合，并返回一个已排序的集合，但是对于大集合来说，这将变得非常浪费。
(Fromdasblinkenlight's answeron Stack Overflow)
9. Super和Sub的构造函数
出现此编译错误是因为默认的超级构造函数未定义。 在Java中，如果一个类没有定义一个构造函数，那么编译器默认会为这个类插入一个默认的无参构造函数。 如果在Super类中定义了一个构造函数，在这种情况下，Super（String s），编译器将不插入默认的无参数构造函数。 以上是超级班的情况。
Sub类的构造函数，无论是参数还是无参数，都会调用无参数的Super构造函数。 由于编译器试图向Sub类中的2个构造函数中插入super()，但Super的默认构造函数未定义，因此编译器会报告错误消息。
为了解决这个问题，只需要:
1）添加一个Super()构造函数给Super类
public Super(){
System.out.println("Super");
}
2）删除自定义的超级构造函数.
3）将super的调用添加到子构造函数。
Constructor of Super and Sub
10."" 或构造函数
字符串有两种定义：
//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
For more details about how they are allocated in memory, check out
Create Java String Using ” ” or Constructor?
未来的工作
该列表基于我对GitHub上的大量开源项目，堆栈溢出问题和流行的Google查询的分析。 没有任何评价证明他们正是前十名，但绝对是非常普遍的。 请留下您的评论，如果您不同意任何部分。 如果你能指出一些更常见的错误，我将不胜感激。
.
