为什么在java中使用lambda表达式？

我知道使用lambda表达式（LE），我们可以为函数接口节省几行代码，比如对象创建。此外，LE将更具可读性。但我确信这不是提供此功能的主要原因。我在google上搜索了

为什么java中有Lambda表达式

，在这里我找到了这句有趣的话

在Java8之前，处理任何集合的元素都可以 通过从集合中获取迭代器，然后进行迭代来完成 然后对每个元素进行处理。如果符合要求 如果要并行处理这些元素，则将由客户端完成 代码。通过在Java8中引入流API，函数可以 传递给收集方法，现在由 集合以顺序或并行方式处理元素 态度

对我来说，这看起来像是流式api的优点，而不是简单的。即使不提供LE，开发人员也可以实现同样的效果 创建匿名消费者类。在这里，我可以看到支持LE的唯一优势是开发者不必记住其中的对象 需要创建功能接口。所以它把java带到了函数式编程中，dev说应用这个函数，而他并不在意 关于对象（让jvm处理这个问题）

这是乐的主要优势还是还有其他的优势

更新：-

我试着在下面这个简单的程序中用lambda表达式来衡量并行处理的性能。发现并行处理需要84个时间单位，而顺序处理只需要4个时间单位。是因为程序不够大，线程开销也可能在这里发挥作用吗？在更大的功能中是否可以看到优势

public class Java8Tester {

   final static String salutation = "Hello! ";

   public static void main(String args[]){
      List<String> stringList = new ArrayList<String>();


      for(int i=0;i <100;i++){
      stringList.add("Hello1");
      stringList.add("Hello2");
      }

     long startTime  = System.currentTimeMillis();
       System.out.println(startTime);
      stringList.parallelStream().forEach((string) -> {System.out.println("content is " + string);
      });
      long stopTime  = System.currentTimeMillis();
      System.out.println(stopTime);
      System.out.println("time taken in parallel processing" + (stopTime - startTime)); // took 84 units of time


       startTime  = System.currentTimeMillis();
       System.out.println(startTime);

     for(String str : stringList ) {
         System.out.println("content is " + str);
     }

       stopTime  = System.currentTimeMillis();
      System.out.println(stopTime);
      System.out.println("time taken in sequential processing" + (stopTime - startTime)); // // took 4 units of time
   }


}

公共类Java8Tester{
最后一个静态字符串称呼=“你好！”；
公共静态void main（字符串参数[]）{
List stringList=新建ArrayList（）；
for（inti=0；i{System.out.println）（“内容是”+字符串）；
});
长停止时间=System.currentTimeMillis（）；
系统输出打印LN（停止时间）；
System.out.println（“并行处理中花费的时间”+（stopTime-startTime））；//花费了84个时间单位
startTime=System.currentTimeMillis（）；
系统输出打印LN（开始时间）；
用于（字符串str:stringList）{
System.out.println（“内容为”+str）；
}
stopTime=System.currentTimeMillis（）；
系统输出打印LN（停止时间）；
System.out.println（“顺序处理中花费的时间”+（stopTime-startTime））；///花费了4个时间单位
}
}

总的来说，您是对的：流API可以在没有lambda函数的情况下存在，使用匿名类。虽然它看起来很难看，工作效率也会降低。至于时间测量，你的结果是完全不相关的。有关详细信息，请参阅。

我不认为lambda表达式有一个主要目的，而是有许多附加的小好处，它们共同产生巨大的影响

• lambda删除了很多样板代码

• 它们使代码更短，更易于阅读

• 减少了对匿名内部类的需求

• 允许更多的代码重用

还有更多的功能

我最喜欢的lambdas的优点之一是能够生成默认接口和方法。一些我认为我现在不能没有的东西

---

因此，lambdas的存在没有一个具体的原因。它们为更多的函数式编程打开了大门，允许Java不断发展，总体上使编码更加有趣。

Lambda表达式是Java 8中一个非常好的附加功能。它允许更快的开发，并且基于函数式编程。 根据编译器是否能够唯一地识别数据类型、返回类型和重载函数，在代码中使用lambda表达式有不同的方法（智能编译也称为类型推断）。对于词汇范围，可以参考。 以下是使用lambda表达式的方法：

a。如果要定义在函数接口内声明的方法， 例如，函数接口作为参数/参数提供给从main调用的方法

    @FunctionalInterface
    interface FInterface{
     int callMeLambda(String temp);
    }

   class ConcreteClass{

     void funcUsesAnonymousOrLambda(FInterface fi){
      System.out.println("===Executing method arg instantiated with Lambda==="));
     }

     public static void main(){
      // calls a method having FInterface as an argument.
      funcUsesAnonymousOrLambda(new FInterface() {

      int callMeLambda(String temp){ //define callMeLambda(){} here..
      return 0;
    }
    });

    /***********Can be replaced by Lambda below*********/
    funcUsesAnonymousOrLambda( (x) -> {
     return 0; //(1)
    }

    }

FInterface fi=（x）->{return 0；}

函数匿名或匿名（fi）

上面解释了lambda表达式的一个特殊用法，让我们以LOC为例，我们可以看到其他各种用法--

可以通过多种方式使用lambda expr实现 A.没有花括号，如果只有一个衬里--

b。没有上面的return语句（编译器非常聪明，可以自动识别return） FunctionsAnonymousorLambda（（字符串x）->0）

c。不指定参数的字符串类型

funcUsesAnonymousOrLambda((x) -> 0);

d、
用花括号和新的局部字段初始化

funcUsesAnonymousOrLambda( (String x) ->
{ //curly braces as we need more statements

String newVarString = " world";
Sysout("___" + x +  newVarString);

});

注意：上面的局部字段可以存在，但是如果外部范围（外部方法的局部变量）中的某个字段在内部被访问，它允许获取该字段，但不允许修改该字段。 裁判

Collections.sort（list，（o1，o2）->{返回o1.compareTo（o2）；}

---

Lambda Expr在实现Comparator接口（与上面的示例非常相似）和实现compare方法时也很有用。当需要快速开发时，Python有时优于java，但Lambda为java提供了一条新曲线。

谢谢。关于时间度量，我也尝试了第二次迭代（正如您所说，“在您的程序中，对流API的第一次调用总是非常慢…”在您提到的链接中）使用并行流，仍然需要8个时间单位，这比传统for循环要高。并行检索应该更快。对吗？可能是方法不够大，无法进行基准测试。是吗？@MSach，您的基准测试中存在更多问题，不仅仅是预热。其中之一是

System.out.println

调用是同步的ed.当在并行流中进行的唯一操作是

funcUsesAnonymousOrLambda((x) -> 0);

funcUsesAnonymousOrLambda( (String x) ->
{ //curly braces as we need more statements

String newVarString = " world";
Sysout("___" + x +  newVarString);

});