在 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 开发中常见的坑点，了解这些可以帮助你在日常开发中编写更健壮、可靠的代码。希望这篇实战避坑指南能够帮助你规避一些常见问题，提升开发效率和代码质量。