Java8 Lambda 与匿名类

Question

由于最近发布了 Java8，而且它全新的 lambda 表达式看起来非常酷，我想知道这是否意味着我们习惯的 Anonymous 类的消亡。

我对此进行了一些研究，并找到了一些关于 Lambda 表达式如何系统地替换这些类的很酷的示例，例如 Collection 的 sort 方法，该方法用于获取 Comparator 的匿名实例来执行排序：

Collections.sort(personList, new Comparator<Person>(){
  public int compare(Person p1, Person p2){
    return p1.firstName.compareTo(p2.firstName);
  }
});

现在可以使用 Lambda 来完成：

Collections.sort(personList, (Person p1, Person p2) -> p1.firstName.compareTo(p2.firstName));

而且看起来非常简洁。所以我的问题是，有什么理由继续在 Java8 中使用这些类而不是 Lambdas？

编辑

同样的问题，但方向相反，使用 Lambdas 而不是 Anonymous 类有什么好处，因为 Lambdas 只能与单一方法接口一起使用，这个新功能是仅在少数情况下使用的快捷方式还是真的有用吗？

Answer 1

匿名内部类 (AIC) 可用于创建抽象类或具体类的子类。 AIC 还可以提供接口的具体实现，包括添加状态（字段）。 AIC 的实例可以在其方法体中使用this 来引用，因此可以在其上调用更多方法，其状态可以随时间变化等。这些都不适用于 lambda。

我猜 AIC 的大部分用途是提供单个函数的无状态实现，因此可以用 lambda 表达式代替，但 AIC 的其他用途不能使用 lambda。 AIC 将继续存在。

更新

AIC 和 lambda 表达式之间的另一个区别是 AIC 引入了一个新的范围。也就是说，名称是从 AIC 的超类和接口中解析出来的，并且可以隐藏出现在词法封闭环境中的名称。对于 lambda，所有名称都按词法解析。

Answer 2

Lambdas 虽然是一项很棒的功能，但仅适用于 SAM 类型。也就是说，只有一个抽象方法的接口。只要您的接口包含超过 1 个抽象方法，它就会失败。这就是匿名类有用的地方。

所以，不，我们不能忽略匿名类。仅供参考，您的sort() 方法可以更加简化，通过跳过p1 和p2 的类型声明：

Collections.sort(personList, (p1, p2) -> p1.firstName.compareTo(p2.firstName));

您也可以在此处使用方法参考。要么在 Person 类中添加 compareByFirstName() 方法，然后使用：

Collections.sort(personList, Person::compareByFirstName);

或者，为firstName添加一个getter，直接从Comparator.comparing()方法中获取Comparator：

Collections.sort(personList, Comparator.comparing(Person::getFirstName));

Answer 3

匿名类的 Lambda 性能

应用程序启动时，必须加载并验证每个类文件。

编译器将匿名类作为给定类或接口的新子类型处理，因此将为每个类生成一个新的类文件。

Lambdas 在字节码生成方面有所不同，它们更高效，使用 JDK7 自带的 invokedynamic 指令。

对于 Lambda，此指令用于延迟在字节码中转换 lambda 表达式，直到运行时。 （指令只会在第一次被调用）

结果 Lambda 表达式将成为一个静态方法（在运行时创建）。 （stateles 和 statefull case 有一点区别，它们是通过生成的方法参数来解决的）

Answer 4

有以下区别：

1) 语法

与匿名内部类 (AIC) 相比，Lambda 表达式看起来更简洁

public static void main(String[] args) {
    Runnable r = new Runnable() {
        @Override
        public void run() {
            System.out.println("in run");
        }
    };

    Thread t = new Thread(r);
    t.start(); 
}

//syntax of lambda expression 
public static void main(String[] args) {
    Runnable r = ()->{System.out.println("in run");};
    Thread t = new Thread(r);
    t.start();
}

2)范围

匿名内部类是一个类，这意味着它具有内部类中定义的变量的范围。

然而，lambda 表达式不是它自己的范围，而是封闭范围的一部分。

在匿名内部类和 lambda 表达式中使用 super 和 this 关键字时，类似的规则适用。在匿名内部类的情况下，这个关键字是指本地范围，而超级关键字是指匿名类的超类。而在 lambda 表达式的情况下，此关键字引用封闭类型的对象，而 super 将引用封闭类的超类。

//AIC
    public static void main(String[] args) {
        final int cnt = 0; 
        Runnable r = new Runnable() {
            @Override
            public void run() {
                int cnt = 5;    
                System.out.println("in run" + cnt);
            }
        };

        Thread t = new Thread(r);
        t.start();
    }

//Lambda
    public static void main(String[] args) {
        final int cnt = 0; 
        Runnable r = ()->{
            int cnt = 5; //compilation error
            System.out.println("in run"+cnt);};
        Thread t = new Thread(r);
        t.start();
    }

3) 性能

在运行时匿名内部类需要类加载、内存分配和对象初始化以及非静态方法的调用，而 lambda 表达式是纯编译时活动，在运行时不会产生额外成本。因此，与匿名内部类相比，lambda 表达式的性能更好。**

**我确实意识到这一点并不完全正确。详情请参考以下问题。 Lambda vs anonymous inner class performance: reducing the load on the ClassLoader?

Answer 5

Java 8 中的 Lambda 被引入用于函数式编程。在哪里可以避免样板代码。我偶然发现了一篇关于 lambda 的有趣文章。

http://radar.oreilly.com/2014/04/whats-new-in-java-8-lambdas.html

建议将 lambda 函数用于简单的逻辑。如果使用 lambdas 实现复杂的逻辑将是在出现问题时调试代码的开销。

Answer 6

+----------------------------------+----------------------------------------------------------+---------------------------------------------+
|                                  |                                       Lambdas            |              Anonymous classes              |
+----------------------------------+----------------------------------------------------------+---------------------------------------------+
| Definition                       | An anonymous method that can be created without belonging| An inner class without a name.              |
|                                  | to any class                                             |                                             |
+----------------------------------+----------------------------------------------------------+---------------------------------------------+
| Scope of variables of main class | Available                                                | Not available                               |
| (this and super keywords also)   |                                                          |                                             |
+----------------------------------+----------------------------------------------------------+---------------------------------------------+
| Lines of codes                   | Reduced the lines of code. It’s a short form of          | Have more lines of code compared to lambdas |
|                                  | anonymous class.                                         |                                             |
+----------------------------------+----------------------------------------------------------+---------------------------------------------+
| Criteria for creating            | Needs to be Functional Interface, ie interface with      | Can use interfaces(including Functional     |
|                                  | only one abstract method. Example : Runnable Interface   | interfaces) and abstract classes to create. |
+----------------------------------+----------------------------------------------------------+---------------------------------------------+
| Example:                         | Runnable r = ()->{System.out.println("Hello World");};   | Runnable r = new Runnable() {               |
|                                  |                                                          |         @Override                           |
|                                  |                                                          |         public void run() {                 |
|                                  |                                                          |          System.out.println("Hello World"); |
|                                  |                                                          |                                        }    |
|                                  |                                                          |     };                                      |
+----------------------------------+----------------------------------------------------------+---------------------------------------------+

Answer 7

• lambda 语法不需要编写 java 可以推断的明显代码。
• 通过使用invoke dynamic，lambda在编译时不会转换回匿名类（Java不必经过创建对象，只关心方法的签名，可以绑定到不创建对象的方法
• lambda 更加强调我们想要做的事情，而不是我们在做之前必须做的事情

Answer 8

匿名类将继续存在，因为 lambda 适用于具有单个抽象方法的函数，但对于所有其他情况，匿名内部类是您的救星。

Answer 9

Lambdas 表达式仅涵盖匿名内部类的一个非常特殊的情况。你可以认为匿名内部类是 Lambda 表达式的超集

Lambdas Expression ⊂ Anonymous Inner classes

在某些场景中，Anno.内部类可以替换为 Lambda 表达式：

1. 如果要实现的内部类是函数式接口（只有一个抽象方法）

例如：

Interface A{
 public void m1();
 public void m2();
}

Interface B{
 public void m();
}

Class Temp{
 public static void main(String[] args){
  // Anonymous inner class implementation
  A a = new A()
  {
   public void m1(){
    //
   }
   public void m2(){
    //
   }
  };
  a.m1(); or a.m2();
 
  // Here B is a functional Interface so we can replace the anonymous class to Lambda Expression
  B b = () => { ... }
  b.m();
  
 }
}

除此之外，两者的编译风格也有一些不同。对于 Lambda 表达式，编译器不会生成任何其他类，但会为 Anon 生成。内部类