除了保存代码行以外，lambda表达式还有什么用吗？

除了保存代码行以外，lambda表达式还有什么用吗？

lambdas是否提供任何特殊功能来解决难以解决的问题？我所看到的典型用法是代替编写此代码：

Comparator<Developer> byName = new Comparator<Developer>() {
  @Override
  public int compare(Developer o1, Developer o2) {
    return o1.getName().compareTo(o2.getName());
  }
};

我们可以使用lambda表达式来缩短代码：

Comparator<Developer> byName =
(Developer o1, Developer o2) -> o1.getName().compareTo(o2.getName());

Lambda表达式通常不会改变您可以使用Java解决的问题集，但是肯定会使解决某些问题变得更加容易，这是出于与我们不再使用汇编语言进行编程相同的原因。从程序员的工作中删除多余的任务可以使工作变得更轻松，并且可以执行您根本不会碰到的事情，而只是要产生大量的代码（手动）。

但是lambda表达式不仅节省了代码行。Lambda表达式使您可以定义函数，以前可以使用这些函数来使用匿名内部类作为变通方法，这就是为什么在这种情况下（但一般而言）不能替换匿名内部类的原因。

最值得注意的是，lambda表达式是独立于它们将要转换到的功能接口定义的，因此没有继承的成员可以访问，而且，它们不能访问实现该功能接口的类型的实例。在lambda表达式中，this并且super具有与周围环境相同的含义，另请参见此答案。同样，您不能创建新的局部变量来遮盖周围上下文的局部变量。对于定义函数的预期任务，这消除了许多错误源，但也意味着对于其他用例，可能存在匿名内部类，即使实现了功能接口，也无法将其转换为lambda表达式。

此外，该构造new Type() { … }保证产生一个新的独特实例（new一如既往）。如果在非static上下文中创建匿名内部类实例，则始终保留对其外部实例的引用。相反，lambda表达式仅this在需要时（即它们访问this或为非static成员时）捕获对的引用。它们会生成一个有意未指定身份的实例，这使实现可以在运行时决定是否重用现有实例（另请参见“ lambda表达式是否在每次执行时都会在堆上创建对象？ ”）。

这些差异适用于您的示例。您的匿名内部类构造将始终产生一个新实例，它也可能捕获对外部实例的引用，而您(Developer o1, Developer o2) -> o1.getName().compareTo(o2.getName())是一个不捕获的lambda表达式，在典型实现中其结果将为单例。此外，它不会.class在硬盘驱动器上生成文件。

考虑到语义和性能方面的差异，lambda表达式可能会改变程序员将来解决某些问题的方式，当然，这也是由于新的API包含了利用新语言功能的函数式编程思想。另请参见Java 8 lambda表达式和一等值。

编程语言不适合机器执行。

它们供程序员考虑。

语言是与编译器的对话，目的是将我们的思想转变为机器可以执行的东西。一个关于Java从谁走到它与其他语言（或人的主诉离开它为其他语言）曾经是，它迫使对程序员有一定的心理模型（即一切都是一个类）。

我不会权衡这是好是坏：一切都需要权衡。但是Java 8 lambda允许程序员从功能方面进行思考，这是您以前在Java中无法做到的。

与过程式程序员学习Java时要考虑的类一样，这是一回事：您会看到它们逐渐从具有美化结构的类中移出，并具有带有一堆静态方法的“辅助”类，并继续前进到更类似于理性的面向对象设计（mea culpa）。

如果您只是将它们视为表达匿名内部类的一种较短方法，那么您可能不会像上述过程程序员可能认为类没有什么大的改进那样发现它们给人留下深刻的印象。

如果使您能够以更短，更清晰的方式编写大量的逻辑块，那么节省代码行可以看作是一项新功能，从而使其他人阅读和理解的时间更少。

没有lambda表达式（和/或方法引用），Stream管道的可读性将大大降低。

例如，考虑一下，Stream如果用匿名类实例替换每个lambda表达式，那么下面的管道将是什么样子。

List<String> names =
    people.stream()
          .filter(p -> p.getAge() > 21)
          .map(p -> p.getName())
          .sorted((n1,n2) -> n1.compareToIgnoreCase(n2))
          .collect(Collectors.toList());

这将是：

List<String> names =
    people.stream()
          .filter(new Predicate<Person>() {
              @Override
              public boolean test(Person p) {
                  return p.getAge() > 21;
              }
          })
          .map(new Function<Person,String>() {
              @Override
              public String apply(Person p) {
                  return p.getName();
              }
          })
          .sorted(new Comparator<String>() {
              @Override
              public int compare(String n1, String n2) {
                  return n1.compareToIgnoreCase(n2);
              }
          })
          .collect(Collectors.toList());

这比带有lambda表达式的版本难写得多，而且容易出错。这也很难理解。

这是一条相对较短的管道。

为了使之在没有lambda表达式和方法引用的情况下也易于阅读，您必须定义一些变量，以容纳此处使用的各种功能接口实例，这些实例将分割流水线的逻辑，使其更难以理解。

内部迭代

在迭代Java Collections时，大多数开发人员倾向于获取一个元素，然后对其进行处理。也就是说，取出该项目，然后使用它，或重新插入它，等等。对于Java的8之前版本，您可以实现一个内部类并执行类似的操作：

numbers.forEach(new Consumer<Integer>() {
    public void accept(Integer value) {
        System.out.println(value);
    }
});

现在，使用Java 8，您可以通过以下操作实现更好而更少的冗长：

numbers.forEach((Integer value) -> System.out.println(value));

或更好

numbers.forEach(System.out::println);

行为作为论点

猜测以下情况：

public int sumAllEven(List<Integer> numbers) {
    int total = 0;

    for (int number : numbers) {
        if (number % 2 == 0) {
            total += number;
        }
    } 
    return total;
}

使用Java 8 谓词接口，您可以像这样做得更好：

public int sumAll(List<Integer> numbers, Predicate<Integer> p) {
    int total = 0;

    for (int number : numbers) {
        if (p.test(number)) {
            total += number;
        }
    }
    return total;
}

像这样调用：

sumAll(numbers, n -> n % 2 == 0);

来源：DZone-为什么我们需要Java中的Lambda表达式

使用lambda代替内部类有很多好处，如下所示：

• 使代码更紧凑，更富有表现力，而无需引入更多语言语法语义。您已经在问题中举了一个例子。

• 通过使用lambda，您很乐意对元素流使用函数式操作进行编程，例如对集合进行map-reduce转换。请参阅java.util.function和java.util.stream软件包文档。

• 编译器没有为lambda生成物理类文件。因此，它使您交付的应用程序更小。内存如何分配给lambda？

• 如果lambda不会访问超出其范围的变量，则编译器将优化lambda的创建，这意味着lambda实例仅由JVM创建一次。有关更多详细信息，请参见@Holger的问题答案。方法引用缓存在Java 8中是个好主意吗？ 。

• Lambda除了功能接口之外，还可以实现多标记接口，但是匿名内部类不能实现更多接口，例如：

  //                 v--- create the lambda locally.
  Consumer<Integer> action = (Consumer<Integer> & Serializable) it -> {/*TODO*/};

Lambda只是匿名类的语法糖。

在使用lambda之前，可以使用匿名类来实现同一目的。每个lambda表达式都可以转换为匿名类。

如果您使用的是IntelliJ IDEA，它可以为您完成转换：

• 将光标放在lambda中
• 按alt / option +输入

为了回答您的问题，事实上，lambdas 不允许您执行Java-8之前无法完成的任何工作，而是使您能够编写更简洁的代码。这样做的好处是您的代码将更清晰，更灵活。

我还没有提到的一件事是，lambda 允许您在使用的地方定义功能。

因此，如果您具有一些简单的选择功能，则无需将其放在一堆样板中放在单独的位置，只需编写一个简洁且与本地相关的lambda。

是的，那里有很多优势。

• 无需定义整个类，我们可以将其自身的功能实现作为参考传递。
  • 内部创建类将创建.class文件，而如果您使用lambda，则编译器将避免类创建，因为在lambda中，您传递的是函数实现而不是类。
• 代码重用性比以前高
• 正如您所说，代码比常规实现要短。