Java Lambda 表达式 vs 匿名内部类

日月星辰Ace
402 阅读4分钟

Lambda 表达式和匿名内部类在 Java 中都可以用来简化代码，尤其是在需要实现接口或回调逻辑时。虽然它们在语法上看起来类似，但在实现、性能、内存管理、线程安全等方面有显著的区别。

1. 基本定义和语法

Lambda 表达式
  • 定义：Lambda 表达式是 Java 8 引入的一种简洁的语法，用于实现函数式接口（只有一个抽象方法的接口）。
  • 语法：
(parameters) -> expression
(parameters) -> { statements; }
匿名内部类
  • 定义：匿名内部类是一个没有名字的类，它在声明的同时实例化，用于实现接口或继承类。
  • 语法：
new InterfaceOrClass() {
    // 实现方法
};

2. 编译后的实现

Lambda 表达式

  • 编译结果：

    • Lambda 表达式在编译时会被转换为一个静态方法或匿名类的实例。
    • 使用 invokedynamic 字节码指令动态生成方法引用。

  • 特点：

    • 更轻量级，不会生成额外的类文件。
    • 运行时性能更高，因为它避免了匿名类的额外开销。
匿名内部类

  • 编译结果：

    • 匿名内部类会被编译为一个独立的 .class 文件，文件名类似于 OuterClass$1.class。

  • 特点：

    • 每个匿名内部类都会生成一个单独的类文件。
    • 运行时需要加载额外的类，性能稍逊于 Lambda。

3. 语法简洁性

Lambda 表达式
  • 更简洁，尤其是当接口只有一个方法时。
  • 示例：
Runnable lambdaRunnable = () -> System.out.println("Lambda Runnable");
匿名内部类
  • 语法较冗长，需要显式声明类和方法。
  • 示例：
Runnable anonymousRunnable = new Runnable() {
    @Override
    public void run() {
        System.out.println("Anonymous Runnable");
    }
};

4. 作用域和变量捕获

Lambda 表达式

  • 捕获外部变量：

    • Lambda 表达式可以捕获外部的有效最终变量（effectively final）。
    • 捕获的变量会被隐式地复制到 Lambda 表达式中。

  • 作用域：

    • Lambda 表达式的作用域与外部方法一致。

  • 示例：

int x = 10;
Runnable lambdaRunnable = () -> System.out.println(x); // x 必须是 effectively final
匿名内部类

  • 捕获外部变量：

    • 匿名内部类也可以捕获外部的有效最终变量。
    • 但匿名内部类会生成一个额外的字段来存储捕获的变量。

  • 作用域：

    • 匿名内部类有自己的作用域，可以定义与外部方法同名的变量。

  • 示例：

int x = 10;
Runnable anonymousRunnable = new Runnable() {
    @Override
    public void run() {
        System.out.println(x); // x 必须是 effectively final
    }
};

5. 性能

Lambda 表达式

  • 性能更高：

    • Lambda 表达式使用 invokedynamic 指令动态生成方法引用，避免了匿名类的额外开销。
    • 更少的内存占用，因为不需要生成额外的类文件。

  • 启动时间更快：

    • Lambda 表达式不需要加载额外的类，启动时间更短。
匿名内部类

  • 性能稍逊：

    • 匿名内部类需要生成额外的类文件，并在运行时加载这些类。
    • 每个匿名内部类实例都有额外的内存开销。

6. 垃圾回收

Lambda 表达式

  • 内存管理：

    • Lambda 表达式不会持有对外部类的强引用。
    • 捕获的外部变量会被复制到 Lambda 表达式中，因此不会阻止外部类被垃圾回收。

  • 更轻量：

    • Lambda 表达式的生命周期与其上下文一致，通常更容易被垃圾回收。
匿名内部类

  • 内存管理：

    • 匿名内部类会持有对外部类的强引用。
    • 如果匿名内部类的实例长期存在，可能会导致外部类无法被垃圾回收（内存泄漏）。

  • 示例：

class Outer {
    void createAnonymousClass() {
        Runnable r = new Runnable() {
            @Override
            public void run() {
                System.out.println("Anonymous class");
            }
        };
    }
}

7. 多线程和线程安全

Lambda 表达式

  • 线程安全：

    • Lambda 表达式本身是线程安全的，因为它通常是无状态的。
    • 如果 Lambda 表达式操作共享的可变状态，则需要额外的同步机制。

  • 示例：

Runnable lambdaRunnable = () -> System.out.println("Thread-safe Lambda");
匿名内部类

  • 线程安全：

    • 匿名内部类本身也是线程安全的，但如果它操作共享的可变状态，同样需要同步。

  • 示例：

Runnable anonymousRunnable = new Runnable() {
    @Override
    public void run() {
        System.out.println("Thread-safe Anonymous Class");
    }
};

8. 调试和可读性

Lambda 表达式

  • 调试难度：

    • Lambda 表达式没有名字，调试时可能不容易定位问题。

  • 可读性：

    • 对于简单逻辑，Lambda 表达式更简洁、更易读。
匿名内部类

  • 调试难度：

    • 匿名内部类有独立的类文件，调试时更容易定位。

  • 可读性：

    • 对于复杂逻辑，匿名内部类更清晰，因为可以包含多个方法和字段。

9. 使用场景

Lambda 表达式

  • 适用场景：

    • 简单的函数式接口实现。
    • 无状态或轻量级的逻辑。

  • 示例：

Runnable lambdaRunnable = () -> System.out.println("Lambda Runnable");
匿名内部类

  • 适用场景：

    • 需要实现多个方法或包含额外状态。
    • 需要更复杂的逻辑。

  • 示例：

Runnable anonymousRunnable = new Runnable() {
    @Override
    public void run() {
        System.out.println("Anonymous Runnable");
    }
};

总结对比表

特性Lambda 表达式匿名内部类
语法简洁冗长
编译结果静态方法或动态生成的方法引用独立的 .class 文件
性能更高稍逊
内存管理不持有外部类强引用，垃圾回收更高效持有外部类强引用，可能导致内存泄漏
线程安全本身线程安全，依赖共享状态时需注意本身线程安全，依赖共享状态时需注意
调试较难定位问题更容易定位问题
适用场景简单逻辑、无状态实现复杂逻辑、多方法实现

结论

  • Lambda 表达式：

    • 更适合简洁的、无状态的逻辑。
    • 性能更高，内存占用更少，垃圾回收更高效。
    • 适用于函数式接口的实现。

  • 匿名内部类：

    • 更适合复杂逻辑，尤其是需要实现多个方法或包含额外状态时。
    • 调试更容易，但性能稍逊。

在实际开发中，优先使用 Lambda 表达式，只有在需要更复杂的逻辑时才考虑使用 匿名内部类。

匿名内部类和 Lambda 表达式在垃圾回收阶段的回收时机

匿名内部类和 Lambda 表达式在垃圾回收阶段的回收时机

匿名内部类和 Lambda 表达式的回收时机取决于它们的生命周期和对它们的引用情况。它们的回收规则与普通对象一致：当没有任何强引用指向它们时，它们就会被垃圾回收（GC）回收。

1. 匿名内部类的垃圾回收

匿名内部类的生命周期
  • 匿名内部类是一个独立的类实例，它的生命周期与创建它的外部类或线程的生命周期相关。
  • 如果匿名内部类持有对外部类的强引用，那么只要匿名内部类存在，外部类也无法被回收。
回收时机
  • 当匿名内部类的实例没有任何强引用时，它会被垃圾回收。
  • 如果匿名内部类持有对外部类的强引用，则外部类也无法被回收，可能导致内存泄漏。
示例
class Outer {
    void createAnonymousClass() {
        Runnable r = new Runnable() {
            @Override
            public void run() {
                System.out.println("Anonymous class");
            }
        };
        r.run();
        // 此时 r 超出作用域，匿名内部类实例没有强引用，可以被回收
    }
}

回收条件：

  • 当 r 超出作用域且没有其他引用指向匿名内部类时，匿名内部类实例会被回收。
注意：内存泄漏风险

如果匿名内部类持有对外部类的强引用，可能导致外部类无法被回收：

class Outer {
    void createAnonymousClass() {
        Runnable r = new Runnable() {
            @Override
            public void run() {
                System.out.println(this); // 持有对匿名内部类的引用
                System.out.println(Outer.this); // 持有对外部类的引用
            }
        };
        r.run();
    }
}
  • 在这种情况下，匿名内部类持有对 Outer 的引用，导致 Outer 无法被回收。

2. Lambda 表达式的垃圾回收

Lambda 表达式的生命周期
  • Lambda 表达式本质上是一个函数式接口的实现，它在编译时被转换为一个静态方法或匿名类实例。
  • 如果 Lambda 表达式不捕获外部变量，它的生命周期通常与其上下文一致。
  • 如果 Lambda 表达式捕获了外部变量，它会将这些变量复制到内部，生命周期与 Lambda 表达式的上下文一致。
回收时机
  • 当 Lambda 表达式的实例没有任何强引用时，它会被垃圾回收。
  • 如果 Lambda 表达式捕获了外部变量，这些变量的生命周期与 Lambda 表达式一致。
示例
Runnable r = () -> System.out.println("Lambda expression");
r.run();
// 此时 r 超出作用域，Lambda 表达式实例没有强引用，可以被回收

回收条件：

  • 当 r 超出作用域且没有其他引用指向 Lambda 表达式时，Lambda 表达式实例会被回收。
注意：捕获外部变量的情况

如果 Lambda 表达式捕获了外部变量，这些变量会被复制到 Lambda 表达式内部：

int x = 10;
Runnable r = () -> System.out.println(x);
r.run();
// x 的值被复制到 Lambda 表达式内部，Lambda 表达式的生命周期与 r 一致
  • 捕获的变量不会阻止外部类被回收，因为 Lambda 表达式不会持有对外部类的强引用。

3. 匿名内部类 vs Lambda 表达式的垃圾回收

特性匿名内部类Lambda 表达式
编译结果编译为独立的 .class 文件（如 Outer$1.class）。编译为静态方法或匿名类实例，使用 invokedynamic 指令动态生成。
持有外部类引用持有对外部类的强引用（通过 Outer.this）。不持有对外部类的强引用，捕获的变量被复制到内部。
内存泄漏风险如果匿名内部类持有外部类引用，可能导致外部类无法被回收。通常不会导致内存泄漏，因为捕获的变量是复制的，不持有外部类的强引用。
回收时机当匿名内部类实例没有强引用时会被回收。当 Lambda 表达式实例没有强引用时会被回收。
性能需要生成额外的类文件，内存占用稍高。更轻量级，性能更高，避免了额外的类文件生成。

4. 垃圾回收的触发条件

无论是匿名内部类还是 Lambda 表达式，它们的回收都依赖于垃圾回收器（GC）的运行。垃圾回收的触发条件包括：

  1. 没有强引用：

    • 如果匿名内部类或 Lambda 表达式的实例没有任何强引用，GC 会将其标记为可回收。

  2. 内存压力：

    • 当 JVM 内存不足时，GC 会尝试回收不再使用的对象。

  3. 显式调用 System.gc() ：

    • 可以显式调用 System.gc() 提示 JVM 进行垃圾回收，但这只是一个建议，GC 不一定会立即执行。

5. 示例：匿名内部类和 Lambda 的回收对比

匿名内部类的回收
class Outer {
    void createAnonymousClass() {
        Runnable r = new Runnable() {
            @Override
            public void run() {
                System.out.println("Anonymous class");
            }
        };
        r.run();
        // 此时 r 超出作用域，匿名内部类实例可以被回收
    }
}
Lambda 表达式的回收
class Outer {
    void createLambda() {
        Runnable r = () -> System.out.println("Lambda expression");
        r.run();
        // 此时 r 超出作用域，Lambda 表达式实例可以被回收
    }
}

6. 内存泄漏的防范

匿名内部类
  • 避免匿名内部类持有对外部类的强引用。
  • 如果必须引用外部类，确保匿名内部类的生命周期短于外部类。
Lambda 表达式
  • Lambda 表达式通常不会导致内存泄漏，因为它不持有外部类的强引用。
  • 但如果 Lambda 表达式被长时间持有（如注册到全局事件监听器），仍需注意其生命周期。

总结

  1. 匿名内部类的回收：

    • 当匿名内部类实例没有强引用时会被回收。
    • 如果匿名内部类持有外部类的强引用，可能导致外部类无法被回收。

  2. Lambda 表达式的回收：

    • 当 Lambda 表达式实例没有强引用时会被回收。
    • Lambda 表达式不会持有外部类的强引用，因此通常不会导致内存泄漏。

  3. 垃圾回收的触发条件：

    • 没有强引用、内存压力或显式调用 System.gc()。

  4. 性能和内存管理：

    • Lambda 表达式更轻量级，性能更高，内存管理更高效。
    • 匿名内部类生成额外的类文件，可能稍微增加内存占用。

在实际开发中，优先使用 Lambda 表达式，除非需要更复杂的逻辑或多方法实现时才使用匿名内部类。

avatar
文章
阅读
粉丝