Scala 中的 Lambda 表达式

Lambda 表达式是指使用匿名函数而不是变量或值的表达式。当我们在一个地方使用一个简单的函数时，Lambda 表达式会更方便。这些表达式比定义整个函数更快、更具表现力。我们可以使我们的 lambda 表达式可重用于任何类型的转换。它可以遍历对象集合并对它们执行某种转换。
语法：

val lambda_exp = (variable:Type) => Transformation_Expression

示例：

// lambda expression to find double of x
val ex = (x:Int) => x + x

使用 Lambda 表达式

• 我们可以像普通函数调用一样将值传递给 lambda。
  例子 ：

  // Scala program to show
  // working of lambda expression
    
  // Creating object
  object GfG
  {
        
  // Main method
  def main(args:Array[String])
  { 
      // lambda expression
      val ex1 = (x:Int) => x + 2
    
      // with multiple parameters
      val ex2 = (x:Int, y:Int) => x * y
        
      println(ex1(7))
      println(ex2(2, 3))
  }
  }
  

  输出：

  9
  6

• 要将转换应用于任何集合，我们通常使用map()函数。它是一个高阶函数，我们可以将 lambda 作为参数传递，以便根据 lambda 表达式的定义转换集合中的每个元素。
  例子 ：

  // Scala program to apply
  // transformation on collection
    
  // Creating object
  object GfG
  {
        
  // Main method
  def main(args:Array[String])
  {
      // list of numbers
      val l = List(1, 1, 2, 3, 5, 8)
    
      // squaring each element of the list
      val res = l.map( (x:Int) => x * x )
    
  /* OR
  val res = l.map( x=> x * x )
  */
      println(res)
  }
  }
  

  输出：

  List(1, 1, 4, 9, 25, 64)

  我们可以看到，定义的执行平方操作的匿名函数是不可重用的。

• 我们将它作为参数传递。但是，我们可以使其可重用，并可以与不同的集合一起使用。
  例子 ：

  // Scala program to apply
  // transformation on collection
    
  // Creating object
  object GfG
  {
      // Main method
      def main(args:Array[String])
      {
          // list of numbers
          val l1 = List(1, 1, 2, 3, 5, 8)
          val l2 = List(13, 21, 34)
        
          // reusable lambda
          val func = (x:Int) => x * x
    
          // squaring each element of the lists
          val res1 = l1.map( func )
          val res2 = l2.map( func )
        
          println(res1)
          println(res2)
      }
  }
  

  输出：

  List(1, 1, 4, 9, 25, 64)
  List(169, 441, 1156)

• lambda 也可以用作函数的参数。
  例子 ：

  // Scala program to pass lambda
  // as parameter to a function
    
  // Creating object
  object GfG
  {
    
      // transform function with integer x and 
      // function f as parameter
      // f accepts Int and returns Double
      def transform( x:Int, f:Int => Double) 
      =
      f(x)
    
      // Main method
      def main(args:Array[String])
      {
        
          // lambda is passed to f:Int => Double
          val res = transform(2, r => 3.14 * r * r)
    
          println(res)
  }
  }
  

  输出：

  12.56

  在上面的例子中，变换函数接受整数 x 和函数f，将变换应用于 f 定义的 x。在函数调用中作为参数传递的 Lambda 返回Double类型。因此，参数f必须服从 lambda 定义。

• 我们也可以对任何集合执行相同的任务。在集合的情况下，我们需要对 transform函数进行的唯一更改是使用map函数将f定义的转换应用于列表l的每个元素。
  例子 ：

  // Scala program to pass lambda
  // as parameter to a function
    
  // Creating object
  object GfG
  {
    
      // transform function with integer list l and 
      // function f as parameter
      // f accepts Int and returns Double
      def transform( l:List[Int], f:Int => Double) 
      =
      l.map(f)
    
      // Main method
      def main(args:Array[String])
      {
          // lambda is passed to f:Int => Double
          val res = transform(List(1, 2, 3), r => 3.14 * r * r)
          println(res)
      }
  }
  

  输出：

  List(3.14, 12.56, 28.259999999999998)