除了节省代码行之外，lambda 表达式还有其他用途吗？

Question

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());

Answer 1

Lambda 表达式一般不会改变您可以用 Java 解决的问题集，但肯定会使解决某些问题更容易，这与我们不再使用汇编语言编程的原因相同。从程序员的工作中删除多余的任务让生活变得更轻松，并允许做一些你甚至不会接触的事情，只是为了你必须（手动）生成的代码量。

但是 lambda 表达式不仅仅是节省代码行数。 Lambda 表达式允许您定义 函数，之前您可以使用匿名内部类作为解决方法，这就是为什么您可以在这些情况下替换匿名内部类，但不是一般情况。

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

此外，构造 new Type() { … } 保证产生一个新的不同实例（正如 new 总是这样做的）。如果在非static 上下文中创建匿名内部类实例，则始终保留对其外部实例的引用。相反，lambda 表达式仅在需要时捕获对this 的引用，即如果它们访问this 或非static 成员。它们会生成有意未指定身份的实例，这允许实现在运行时决定是否重用现有实例（另请参阅“Does a lambda expression create an object on the heap every time it's executed?”）。

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

鉴于语义和性能方面的差异，lambda 表达式可能会改变程序员未来解决某些问题的方式，当然，这也是由于新的 API 采用了利用新语言特性的函数式编程思想。另见Java 8 lambda expression and first-class values。

Answer 2

编程语言不是供机器执行的。

它们是供程序员思考的。

语言是与编译器的对话，将我们的想法转化为机器可以执行的东西。使用其他语言（或离开为其他语言）的人们对 Java 的主要抱怨之一是它强制 程序员的某种思维模式（即一切都是类）。

我不会去衡量这是好是坏：一切都是取舍。但是 Java 8 lambda 允许程序员根据 函数思考，这是你以前在 Java 中无法做到的。

这与程序程序员在学习 Java 时思考类是一回事：你会看到它们逐渐从那些美化结构的类转变为具有“辅助”类的一堆静态方法，然后转向更接近于理性 OO 设计的东西（mea culpa）。

如果您只是将它们视为表达匿名内部类的一种更短的方式，那么您可能不会发现它们非常令人印象深刻，就像上面的程序程序员可能不认为类有任何重大改进一样。

Answer 3

节省代码行可以被视为一项新功能，如果它使您能够以更短、更清晰的方式编写大量逻辑，从而减少其他人阅读和理解的时间。

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

例如，如果您将每个 lambda 表达式替换为匿名类实例，下面的 Stream 管道会是什么样子。

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 表达式和方法引用的情况下使其可读，您必须定义变量来保存此处使用的各种功能接口实例，这会拆分管道的逻辑，使其更难理解。

Answer 4

内部迭代

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

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 Predicate interface 你可以做得更好：

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 - Why We Need Lambda Expressions in Java

Answer 5

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

• 在不引入更多语言语法语义的情况下使代码更加紧凑和富有表现力。你已经在你的问题中举了一个例子。

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

• 编译器没有为 lambda 生成物理类文件。因此，它使您交付的应用程序更小。 How Memory assigns to lambda?

• 如果 lambda 不访问其范围之外的变量，编译器将优化 lambda 创建，这意味着 lambda 实例仅由 JVM 创建一次。有关更多详细信息，您可以查看@Holger 对问题Is method reference caching a good idea in Java 8? 的回答。

• Lambdas除了函数式接口外还可以实现多标记接口，但是匿名内部类不能实现更多的接口，例如：

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

Answer 6

Lambda 只是匿名类的语法糖。

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

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

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

Answer 7

为了回答你的问题，事实上 lambdas 不要让你做任何你在 java-8 之前不能做的事情，而是让你写更多的东西 简洁的代码。这样做的好处是，您的代码会更清晰、更灵活。

Answer 8

我还没有看到提到的一件事是 lambda 允许您定义使用它的功能。

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

Answer 9

是的，有很多优点。

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

Answer 10

函数组合和高阶函数。

Lambda 函数可用作构建“高阶函数”或执行“函数组合”的构建块。从这个意义上说，Lambda 函数可以被视为可重用的构建块。

通过 lambda 的高阶函数示例：

Function<IntUnaryOperator, IntUnaryOperator> twice = f -> f.andThen(f);
IntUnaryOperator plusThree = i -> i + 3;
var g = twice.apply(plusThree);
System.out.println(g.applyAsInt(7))

示例函数组合

Predicate<String> startsWithA = (text) -> text.startsWith("A");
Predicate<String> endsWithX   = (text) -> text.endsWith("x");

Predicate<String> startsWithAAndEndsWithX =
        (text) -> startsWithA.test(text) && endsWithX.test(text);

String  input  = "A hardworking person must relax";
boolean result = startsWithAAndEndsWithX.test(input);
System.out.println(result);

Answer 11

尚未提及的一个好处是我最喜欢的：lambdas 使延迟执行非常容易编写。

例如，Log4j2 使用此方法，您现在可以传递一个 lambda 来计算该昂贵值，而不是有条件地将值传递给 log（一个可能计算成本很高的值）。不同之处在于，以前，无论是否使用，每次都会计算该值，而现在使用 lambdas，如果您的日志级别决定不记录该语句，则永远不会调用 lambda，并且永远不会发生昂贵的计算 - - 性能提升！

可以在没有 lambda 的情况下完成吗？是的，通过使用 if() 检查包围每个日志语句，或者使用冗长的匿名类语法，但代价是可怕的代码噪音。

类似的例子比比皆是。 Lambda 就像吃蛋糕一样吃：粗糙的多行优化代码的所有效率都被压缩成单行代码的视觉优雅。

编辑：根据评论者的要求，举个例子：

老方法，无论这条日志语句是否实际使用它，总是调用昂贵的计算（）：

logger.trace("expensive value was {}", expensiveCalculation());

新的高效 lambda 方法，除非启用跟踪日志级别，否则不会发生调用昂贵的计算（）：

logger.trace("expensive value was {}", () -> expensiveCalculation());