十个JAVA程序员容易犯的错误

本文列举了Java开发过程中常见的十个误区,包括如何正确地从数组转换到ArrayList、如何检测数组是否包含某个元素、如何在循环中移除List中的元素等。这些误区可能会导致代码效率低下或者出现运行时错误。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

十个JAVA程序员容易犯的错误

本文是翻译自

1. Array 转 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.检测一个Array是否包含一个元素

一般开发者喜欢用:

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

这段代码能够工作,但并没有先转将list转为set,list转为set需要额外时间,可以用下面更简单的:

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

或者

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

第一种方法比第二种的可读性更好。

3. 在一个循环中移除list中的元素

考虑下下面这种方法:

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的大小就缩减了,索引也发生了改变。所以如果想要在一个循环中使用索引移除多个元素,这是不可行的。

或许你又想用迭代器的方式解决这个问题,但实际上也不可行,考虑下下面的代码:

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

4. Hashtable vs HashMap

在算法中,哈希表是数据结构的名称。但在Java中,数据结构的名字是HashMap中。其中一个Hashtable和HashMap的之间的主要区别是,Hashtable是同步的。所以,很多时候,你并不需要哈希表,HashMap就够用了。

5.使用原始类型的集合

在Java中,原始类型和无界通配符类型很容易混在一起。以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<?>, and Set

6.访问权限

很多开发者使用public修饰类的字段,这样很容易获取字段值,但这是一个糟糕的设计。经验法则是给用户尽可能低的访问权限。

7.ArrayList vs. LinkedList

大部分的开发者并不知道ArrayList和LinkedList 的区别,所以经常使用ArrayList,这个看起来更熟悉。但是,在这两者之间,有一个很大的性能差异。

简单来说,在有很多插入和删除操作时,同时有很少或者几乎没有随机访问的操作情况下,推荐使用LinkedList。其次,再使用ArrayList。

8.Mutable vs. Immutable(可变 VS 不可变)

不可变对象有很多优势这样简单,安全,等等。但它对于每一个不同的变量,需要一个单独的对象。太多的对象可能会导致高成本的垃圾收集。所以在选择可变和不可变的时应该有个权衡。

一般来说,使用可变对象,以避免产生过多的中间对象。一个经典的例子就是连接大量的字符串。如果使用不可变的String,你会产生很多立马要被垃圾收集回收的对象,这很消耗时间和精力。如果使用一个不可变的,类似StringBuffer。

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

可变对象还有其他的例子:函数传参的过程中,可以传入可变对象,这样可以得到多个结果。

9.父类和子类的构建

编译出错的原因主要是默认的Super类的构造函数并没有被定义。在Java中,如果一个类没有实现构造函数,编译器默认会给这个类插入一个无参构造函数。如果在父类中已经有了构造函数,那么编译器将不会再插入默认无参构造函数。

子类的构造函数,要么是带参的要么是无参的,都会调用父类的无参构造。因为编译器想在子类中,加入super(),但是父类的无参构造函数并不存在。所以,编译器会报错。

为了解决这个问题,有两种解决办法,第一,在Super类中,加入无参构造:

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

第二种方式,移除自定义的父类构造函数

第三种方式,子类的构造函数中加入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
<think>嗯,用户想了解Java程序员错误,我需要整理一个结构清晰的回答。首先,我应该回忆常见的错误类型,比如基础语法、异常处理、集合框架、并发问题、内存管理、代码设计等。然后每个类别下要举具体的例子,这样用户更容易理解。 首先,基础语法部分,String的比较问题很典型,很多人用==而不是equals。还有可变对象的修改,比如Date的使用。然后是循环中修改集合结构,这会导致ConcurrentModificationException,需要提醒使用迭代器或者CopyOnWriteArrayList。 接下来是异常处理,捕获异常后不处理或者捕获太泛泛的Exception,这些都不好。资源泄漏也是一个点,需要提到try-with-resources来自动关闭资源。 集合框架方面,初始化集合时容量的问题,比如ArrayList默认大小是10,如果数据量大,扩容会影响性能。还有使用迭代器时的并发修改问题,可能需要再详细说明一下。 并发问题,线程安全的数据结构和非线程安全的混用,比如HashMap在并发环境下的问题。synchronized的使用不当,比如方法锁和对象锁的区别。volatile和原子类的应用场景也需要解释清楚。 内存管理方面,静态集合导致的内存泄漏,比如缓存没有清理机制。还有对象复用的例子,比如StringBuilder的正确使用方式。 代码设计方面,过度设计比如滥用设计模式,或者硬编码配置,应该用外部配置文件。还有忽略API文档,导致方法使用不当。 另外,可以补充一些其他常见问题,比如使用null时没检查导致的NPE,Java 8之后的Optional用法。还有日期时间类的问题,推荐使用新的java.time包。 需要确保每个点都有例子和解决方法,这样用户能明白如何避免。结构上分大类,每个大类下分小点,用列表展示。语言要口语化但专业,符合用户要求的中文回答。 检查一下是否有遗漏的常见错误,比如自动装箱拆箱的空指针问题,或者重写equals和hashCode的注意事项。可能这些也是值得提到的点,但暂时先按现有结构整理,避免内容太多太杂。最后总结一下建议,帮助用户形成良好的编程习惯。</think>作为Java开发者常错误可归纳为以下几类,结合具体案例说明: ### 一、基础语法问题 1. **字符串比较用`==`而非`equals()`** ```java String s1 = new String("hello"); String s2 = new String("hello"); System.out.println(s1 == s2); // 输出false(比较对象地址) System.out.println(s1.equals(s2)); // 输出true(比较内容) ``` 2. **循环中修改集合结构** ```java List<String> list = new ArrayList<>(Arrays.asList("a", "b", "c")); for (String s : list) { list.remove(s); // 抛出ConcurrentModificationException } // 正确做法:使用迭代器的remove()方法 ``` ### 二、异常处理误区 1. **吞掉异常** ```java try { // 可能出错的代码 } catch (Exception e) { e.printStackTrace(); // 仅打印不处理 } ``` **改进**:记录日志后根据业务场景选择恢复或抛出 2. **资源未正确关闭** ```java FileInputStream fis = null; try { fis = new FileInputStream("file.txt"); } finally { if (fis != null) fis.close(); // 可能忘记关闭 } ``` **改进**:使用try-with-resources ```java try (FileInputStream fis = new FileInputStream("file.txt")) { // 自动关闭资源 } ``` ### 三、集合框架使用不当 1. **忽略初始容量** ```java List<Integer> list = new ArrayList<>(); // 默认容量10 for (int i = 0; i < 1_000_000; i++) { list.add(i); // 频繁扩容导致性能下降 } ``` **优化**:预先指定容量`new ArrayList<>(1000000)` 2. **错误使用线程安全集合** ```java Map<String, Integer> map = new HashMap<>(); // 多线程环境下put操作可能导致数据错乱 ``` **解决**:改用`ConcurrentHashMap`或同步包装类 ### 四、并发编程陷阱 1. **误用`synchronized`** ```java public synchronized void methodA() { // 锁住的是当前对象实例 } public static synchronized void methodB() { // 锁住的是Class对象 } ``` 需明确锁的作用范围 2. **可见性问题未处理** ```java class Counter { private int count; // 未使用volatile public void increment() { count++; } } ``` **风险**:多线程环境下可能读取到旧值 **解决**:使用`AtomicInteger`或`volatile`(需配合原子操作) ### 五、内存管理疏忽 1. **静态集合导致内存泄漏** ```java public class Cache { private static final Map<Long, Object> CACHE = new HashMap<>(); public static void store(Long id, Object obj) { CACHE.put(id, obj); // 对象永不释放 } } ``` **改进**:使用WeakHashMap或定期清理机制 2. **未复用不可变对象** ```java String s = new String("value"); // 错误 String s = "value"; // 正确(利用字符串常量池) ``` ### 六、代码设计缺陷 1. **过度设计** ```java // 简单的DTO类使用工厂模式+策略模式 // 应根据实际复杂度选择设计模式 ``` 2. **硬编码配置** ```java String dbUrl = "jdbc:mysql://localhost:3306/mydb"; // 应外置到配置文件 ``` ### 七、其他典型问题 1. **忽略`@Override`注解** 可能导致方法未被正确重写: ```java class Parent { public void show() { ... } } class Child extends Parent { public void Show() { ... } // 大小写错误,未重写 } ``` 2. **日期时间处理错误** ```java Date date = new Date(2023, 1, 1); // 月份从0开始,实际是二月 // 应使用java.time.LocalDate ``` ### 建议改进方向 1. 使用静态代码分析工具(如SonarQube) 2. 编写单元测试覆盖核心逻辑 3. 定期进行Code Review 4. 阅读JDK源码理解底层实现 5. 关注Java语言更新(如Records、Pattern Matching等新特性)
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值