除了保存代码行之外,lambda表达式还有什么用处吗？

Question

除了保存代码行之外,lambda表达式还有什么用处吗？

lambda提供的特殊功能是否解决了不容易解决的问题？我见过的典型用法是代替写这个:

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表达式不会改变您通常可以解决的问题集,但肯定会使解决某些问题变得更容易,只是出于同样的原因我们不再使用汇编语言进行编程.从程序员的工作中删除冗余任务可以使生活更轻松,并且允许执行您甚至不会触摸的事情,只需要生成(手动)生成的代码量.

但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表达式和第一类值.

Answer 2

编程语言不适用于机器执行.

它们是供程序员思考的.

语言是与编译器的对话,可以将我们的想法变成机器可以执行的东西.一位来自谁走到它与其他语言(或人关于Java的主诉离开它为其他语言)曾经是,它迫使对程序员有一定的心理模型(即一切都是一个类).

我不打算判断这是好还是坏:一切都是权衡取舍.但Java 8 lambdas允许程序员根据函数进行思考,这是您以前在Java中无法做到的.

这是同样的事情作为一个程序的程序员学习思考中的类而言,当他们来到Java的:你看他们是荣耀的结构类逐渐上移,并有一堆的静态方法"助手"类和移动上的东西,更接近于理性的OO设计(mea culpa).

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

Answer 3

如果能够以更短更清晰的方式编写大量逻辑,则可以将保存代码行视为一项新功能,从而缩短其他人阅读和理解的时间.

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

Answer 4

内部迭代

在迭代Java Collections时,大多数开发人员倾向于获取一个元素然后进行处理.这是,取出该项目,然后使用它,或重新插入它等.使用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接口,您可以做得更好:

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表达式

Answer 5

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

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

• 通过使用 lambda，您很乐意在元素流上使用函数式操作进行编程，例如集合上的映射缩减转换。请参阅java.util.function和java.util.stream包文档。

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

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

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

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