Java 中常见的几个陷阱，你没有遇到几个？(Java开发中你踩过这些常见陷阱吗？自查避坑指南！)

原创

ithorizon 6个月前 (10-21) 阅读数 23 #后端开发

Java 开发中的常见陷阱：自查避坑指南！

一、Java 中的常见陷阱

在 Java 开发过程中，我们也许会遇到一些常见的问题和陷阱。以下是其中的一些典型例子，让我们一起来看看你是否踩过这些坑。

二、整数缓存问题

Java 中，基本类型 int 的默认值是 0，而 Integer 的默认值是 null。Java 为了节省内存，对 Integer 进行了缓存处理。


        Integer a = 100;
        Integer b = 100;
        System.out.println(a == b); // 输出 true
        Integer c = 200;
        Integer d = 200;
        System.out.println(c == d); // 输出 false

这是基于 Java 在自动装箱时，只有值在 -128 到 127 之间时，才会使用缓存。超出这个范围的值，即使相同，也会创建新的对象。

三、浮点数精度问题

Java 中的浮点数（float 和 double）是基于 IEEE 754 标准实现的，这也许会使精度问题。


        double a = 0.1;
        double b = 0.2;
        System.out.println(a + b == 0.3); // 输出 false

为了解决这个问题，我们可以使用 BigDecimal 类来处理高精度的浮点数运算。

四、String 字符串拼接陷阱

在 Java 中，字符串拼接是一个常见的操作，但使用加号（+）拼接字符串时，也许会产生意想不到的性能问题。


        String str = "";
        for (int i = 0; i < 10000; i++) {
            str += "a";
        }

在这个例子中，每次循环都会创建一个新的字符串对象，然后复制旧的内容并追加 "a"，这会使性能急剧下降。为了解决这个问题，可以使用 StringBuilder 或 StringBuffer 类。

五、异常处理不当

Java 中的异常处理是一个重要的部分，但有时候我们也许会犯一些谬误。

1. 不捕获具体的异常类型

有时候，我们也许会捕获极为通用的异常类型，如 Exception，而不是捕获具体的异常类型，这也许会使代码难以维护。


        try {
            // 也许抛出异常的代码
        } catch (Exception e) {
            e.printStackTrace();
        }

2. 不 finally 块中释放资源

在使用资源（如文件、数据库连接等）时，应该在 finally 块中释放这些资源，以确保资源的正确关闭。


        try {
            // 使用资源
        } catch (Exception e) {
            e.printStackTrace();
        } // 此处没有 finally 块来释放资源

六、集合类使用不当

Java 中的集合类非常有力，但如果使用不当，也也许使问题。

1. 使用原始类型作为泛型参数

Java 的泛型机制不赞成原始类型，如 int、float 等，必须使用它们的包装类型，如 Integer、Float。


        List list = new ArrayList(); // 谬误
        List list = new ArrayList(); // 正确

2. 忽视线程保险

在使用集合类时，如果没有考虑线程保险，也许会使并发问题。


        List list = new ArrayList();
        // 多线程环境下使用 list，也许使线程保险问题

为了解决这个问题，可以使用线程保险的集合类，如 Vector、ConcurrentHashMap 等，或者使用同步代码块。

七、 equals() 和 hashCode() 方法不兼容

在 Java 中，重写 equals() 方法时，必须同时重写 hashCode() 方法，以确保两个方法的一致性。


        public class MyClass {
            private int value;
            @Override
            public boolean equals(Object obj) {
                if (this == obj) return true;
                if (obj == null || getClass() != obj.getClass()) return false;
                MyClass myClass = (MyClass) obj;
                return value == myClass.value;
            }
            // 如果没有重写 hashCode 方法，则 equals 和 hashCode 不兼容
        }

如果不这样做，也许会使一些不可预见的问题，特别是在使用 HashMap、HashSet 等基于哈希表的集合类时。

八、并发编程中的问题

Java 中的并发编程是一个繁复的领域，容易出错。

1. 竞态条件

当多个线程同时访问共享资源，并且至少有一个线程的操作依赖性于其他线程的操作因此时，就也许出现竞态条件。


        public class Counter {
            private int count = 0;
            public void increment() {
                count++; // 非原子操作
            }
            public int getCount() {
                return count;
            }
        }

为了解决这个问题，可以使用 synchronized 关键字或 Lock 接口来保证操作的原子性。

2. 死锁

当多个线程二者之间等待对方持有的锁时，也许会使死锁。


        public class DeadlockDemo {
            public static void main(String[] args) {
                final Object resource1 = "Resource1";
                final Object resource2 = "Resource2";
                Thread t1 = new Thread(() -> {
                    synchronized (resource1) {
                        System.out.println("Thread 1: Locked resource 1");
                        try { Thread.sleep(100); } catch (Exception e) {}
                        synchronized (resource2) {
                            System.out.println("Thread 1: Locked resource 2");
                        }
                    }
                });
                Thread t2 = new Thread(() -> {
                    synchronized (resource2) {
                        System.out.println("Thread 2: Locked resource 2");
                        try { Thread.sleep(100); } catch (Exception e) {}
                        synchronized (resource1) {
                            System.out.println("Thread 2: Locked resource 1");
                        }
                    }
                });
                t1.start();
                t2.start();
            }
        }