文章目录
在 Java 开发中，一不小心就可能掉入各种坑。本篇文章总结了 9 个常见的 Java 开发中的“坑点”，并提供实战案例帮助你掌握如何避免这些问题。
1. 避免使用 == 比较字符串
直接用 == 比较字符串容易出现问题，因为它比较的是引用地址而不是内容。应该使用 equals 方法来比较字符串的内容。
案例：
String str1 = "hello";
String str2 = new String("hello");
if (str1 == str2) { // 错误：比较的是引用地址
System.out.println("str1 和 str2 相等");
} else {
System.out.println("str1 和 str2 不相等");
}
if (str1.equals(str2)) { // 正确：比较的是内容
System.out.println("str1 和 str2 内容相等");
}
解析：== 仅在字符串池内的字符串时才会为 true。建议使用 equals 比较内容，以避免不一致的行为。
2. 谨慎处理 NullPointerException
NullPointerException 是 Java 中最常见的异常之一。通过合理的空值检查和 Optional 可以减少空指针的发生。
案例：
public String getUserName(User user) {
return user != null ? user.getName() : "Unknown"; // 空值检查
}
// 使用 Optional 避免空指针
public Optional<String> getUserNameOpt(User user) {
return Optional.ofNullable(user).map(User::getName);
}
解析：空值检查和 Optional 可以大大减少空指针的风险，提升代码的安全性。
3. 小心隐式类型转换
在涉及整数、浮点数的运算时，隐式类型转换可能会导致精度丢失或错误的结果。应明确类型转换，确保结果正确。
案例：
int a = 10;
double b = 5.5;
// 错误：隐式类型转换，可能导致精度丢失
int result = (int) (a + b); // 转换为 int 时小数会被截掉
System.out.println("Result: " + result); // 输出 Result: 15
// 正确：先计算浮点结果，再转换
double correctResult = a + b;
System.out.println("Correct Result: " + correctResult); // 输出 Correct Result: 15.5
解析：通过显式的类型转换，我们可以避免误操作导致的精度丢失。
4. 避免过度使用静态变量
静态变量属于类级别，生命周期长，容易造成内存泄漏。尽量避免使用静态变量来存储业务数据。
案例：
// 错误：使用静态变量存储业务数据，容易内存泄漏
public class DataStorage {
private static List<String> data = new ArrayList<>();
}
// 正确：使用实例变量，合理控制数据生命周期
public class DataStorage {
private List<String> data = new ArrayList<>();
}
解析：静态变量应慎用，避免无意的内存泄漏，特别是长时间运行的项目。
5. 合理控制线程池大小
设置线程池大小不合理可能导致资源耗尽或线程争抢，应根据系统负载和硬件条件配置线程池。
案例：
// 错误：创建无限大的线程池，可能导致资源耗尽
ExecutorService executor = Executors.newCachedThreadPool();
// 正确：根据硬件资源设置固定大小的线程池
ExecutorService executor = Executors.newFixedThreadPool(10);
解析：使用固定大小的线程池可以避免线程无序增长，合理控制资源。
6. 小心浮点数比较
浮点数在计算机中会产生精度误差，直接比较浮点数可能导致意想不到的结果。建议用误差范围来比较。
案例：
double a = 0.1 * 3;
double b = 0.3;
// 错误：直接比较浮点数
System.out.println(a == b); // 输出 false
// 正确：使用误差范围
double epsilon = 0.00001;
System.out.println(Math.abs(a - b) < epsilon); // 输出 true
解析：浮点数比较时应使用误差范围，以减少精度误差导致的错误判断。
7. 避免死锁
多线程操作时，若两个线程相互等待对方释放锁，就会发生死锁。要确保加锁顺序一致，减少加锁次数，避免死锁。
案例：
public void methodA() {
synchronized (lock1) {
synchronized (lock2) {
// do something
}
}
}
public void methodB() {
synchronized (lock2) {
synchronized (lock1) { // 错误：加锁顺序与 methodA 不同，易导致死锁
// do something
}
}
}
解析：通过保证加锁顺序一致，可以有效避免死锁。
8. 谨慎使用可变参数（Varargs）
可变参数在方法调用中可以方便地传递多个参数，但在某些场景中可能造成不必要的内存开销，甚至影响性能。
案例：
// 错误：频繁创建新数组，浪费内存
public void printNumbers(int... numbers) {
for (int num : numbers) {
System.out.println(num);
}
}
// 正确：避免无意义的可变参数使用
public void printNumbers(List<Integer> numbers) {
numbers.forEach(System.out::println);
}
解析：在需要频繁传递大量参数时，避免使用可变参数而改用集合类来优化性能。
9. 使用 equals 和 hashCode 时实现一致性
在集合类中，如果对象的 equals 和 hashCode 不一致，可能会导致数据结构无法正常工作。必须保证 equals 相等的对象 hashCode 也相等。
案例：
public class Person {
private String name;
private int age;
// 错误：没有实现 hashCode 方法，导致集合操作异常
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Person person = (Person) o;
return age == person.age && name.equals(person.name);
}
// 正确：实现 equals 和 hashCode 的一致性
@Override
public int hashCode() {
return Objects.hash(name, age);
}
}
解析：保证 equals 和 hashCode 的一致性是集合操作正常的前提。
总结
以上 9 个技巧涵盖了 Java 开发中常见的坑点，了解这些可以帮助你在日常开发中编写更健壮、可靠的代码。希望这篇实战避坑指南能够帮助你规避一些常见问题，提升开发效率和代码质量。
推荐阅读文章
- 由 Spring 静态注入引发的一个线上T0级别事故（真的以后得避坑）
- 如何理解 HTTP 是无状态的，以及它与 Cookie 和 Session 之间的联系
- HTTP、HTTPS、Cookie 和 Session 之间的关系
- 使用 Spring 框架构建 MVC 应用程序：初学者教程
- 有缺陷的 Java 代码：Java 开发人员最常犯的 10 大错误
- Java Spring 中常用的 @PostConstruct 注解使用总结
- 线程 vs 虚拟线程：深入理解及区别
- 深度解读 JDK 8、JDK 11、JDK 17 和 JDK 21 的区别
- 10大程序员提升代码优雅度的必杀技，瞬间让你成为团队宠儿！
- 探索 Lombok 的 @Builder 和 @SuperBuilder：避坑指南（一）
- 为什么用了 @Builder 反而报错？深入理解 Lombok 的“暗坑”与解决方案（二）