Java 开发人员常犯的 10 大错误

野性酷女 2024-03-27 09:01 82阅读 0赞

## Java 开发人员常犯的 10 大错误 ##

*本文译自：[Top 10 Mistakes Java Developers Make][]*

此列表总结了 Java 开发人员经常犯的 10 大错误。

1.  将数组转换为 ArrayList
2.  检查数组是否包含值
3.  从循环内的列表中删除元素
4.  哈希表与哈希图
5.  使用原始类型的集合
6.  访问权限
7.  ArrayList 与 LinkedList
8.  可变与不可变
9.  Super 和 Sub 的构造函数
10. “”还是构造函数？

### 1. 将数组转换为 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));

的构造函数`ArrayList`可以接受 Collection 类型，它也是 的超类型`java.util.Arrays.ArrayList`。

### 2. 检查数组是否包含值 ###

开发人员经常这样做：

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

该代码有效，但无需先将列表转换为 set。将列表转换为集合需要额外的时间。它可以很简单：

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);
    }

它将抛出[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()][ArrayList.iterator]的源代码。

### 4. 哈希表与哈希图 ###

按照算法的约定，Hashtable 是数据结构的名称。但在 Java 中，数据结构的名称是`HashMap`. `Hashtable`和之间的主要区别`HashMap`之一`Hashtable`是同步。所以很多时候你不需要`Hashtable`，相反`HashMap`应该使用。

[HashMap vs. TreeMap vs. Hashtable vs. LinkedHashMap][]  
[关于 Map 的十大问题][Map]

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

在 Java 中，*原始类型*和*无限通配符类型*很容易混合在一起。以Set为例，`Set`是raw类型，`Set<?>`而是unbounded wildcard类型。

考虑以下使用原始类型`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 用于类字段。直接引用很容易得到字段值，但这是一个非常糟糕的设计。经验法则是为成员提供尽可能低的访问级别。

[公共、默认、受保护和私有][Link 1]

### 7. ArrayList 与 LinkedList ###

当开发人员不知道 和 之间的区别时`ArrayList`，`LinkedList`他们经常使用`ArrayList`，因为它看起来很眼熟。但是，它们之间存在巨大的性能差异。简而言之，`LinkedList`如果有大量的添加/删除操作并且没有大量的随机访问操作，应该是首选。如果这对您来说是新的，请查看[`ArrayList`vs.`LinkedList`][ArrayList_vs._LinkedList]以获取有关其性能的更多信息。

### 8. 可变与不可变 ###

不可变对象具有简单、安全等诸多优点。但它需要为每个不同的值分配一个单独的对象，而且过多的对象可能会导致垃圾回收的高成本。在可变和不可变之间进行选择时应该保持平衡。

通常，可变对象用于避免产生过多的中间对象。一个典型的例子是连接大量的字符串。如果您使用不可变字符串，您将生成大量符合垃圾回收条件的对象。这会浪费 CPU 的时间和精力，使用可变对象才是正确的解决方案（例如`StringBuilder`）。

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

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

[为什么字符串是不可变的？][Link 2]

### 9. Super 和 Sub 的构造函数 ###

![在这里插入图片描述][bfc41f289e564f638291fc4fe5fbb3be.png_pic_center]

出现此编译错误是因为默认的超级构造函数未定义。在Java中，如果一个类没有定义构造函数，编译器会默认为该类插入一个默认的无参构造函数。如果在 Super 类中定义了构造函数，在本例中为 Super(String s)，编译器将不会插入默认的无参数构造函数。这是上面Super类的情况。

Sub 类的构造函数，无论是有参数还是无参数，都将调用无参数 Super 构造函数。由于编译器尝试将 super() 插入 Sub 类中的 2 个构造函数，但未定义 Super 的默认构造函数，因此编译器报告错误消息。

要解决此问题，只需 1) 向 Super 类添加一个 Super() 构造函数，例如

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

, 或者 2) 移除自定义的 Super 构造函数，或者 3) 添加`super(value)`到子构造函数。

[Super 和 Sub 的构造函数][Super _ 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

有关它们如何在内存中分配的更多详细信息，请查看[使用“”或构造函数创建 Java 字符串？][Java].

[Top 10 Mistakes Java Developers Make]: https://www.programcreek.com/2014/05/top-10-mistakes-java-developers-make/
[ConcurrentModificationException]: https://www.programcreek.com/2014/01/java-util-concurrentmodificationexception/
[ArrayList.iterator]: https://www.programcreek.com/2014/01/deep-understanding-of-arraylist-iterator/
[HashMap vs. TreeMap vs. Hashtable vs. LinkedHashMap]: https://www.programcreek.com/2013/03/hashmap-vs-treemap-vs-hashtable-vs-linkedhashmap/
[Map]: https://www.programcreek.com/2013/09/top-9-questions-for-java-map/
[Raw type vs. Unbounded wildcard]: https://www.programcreek.com/2013/12/raw-type-set-vs-unbounded-wildcard-set/
[Type Erasure]: https://www.programcreek.com/2011/12/java-type-erasure-mechanism-example/
[Link 1]: https://www.programcreek.com/2011/11/java-access-level-public-protected-private/
[ArrayList_vs._LinkedList]: https://www.programcreek.com/2013/03/arraylist-vs-linkedlist-vs-vector/
[dasblinkenlight]: https://stackoverflow.com/questions/23616211/why-we-need-mutable-classes
[Link 2]: https://www.programcreek.com/2013/04/why-string-is-immutable-in-java/
[bfc41f289e564f638291fc4fe5fbb3be.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/4f8597e102a243da80ea0db739bfd119.png
[Super _ Sub]: https://www.programcreek.com/2013/04/what-are-the-frequently-asked-questions-about-constructors-in-java/
[Java]: https://www.programcreek.com/2014/03/create-java-string-by-double-quotes-vs-by-constructor/