【问题标题】:Scala lambda function with map function具有映射功能的 Scala lambda 函数
【发布时间】:2018-12-16 01:05:17
【问题描述】:

我定义如下变量x

val x = Array((3,2), (4,5))

它的类型是Array[(Int, Int)]

当我执行以下操作时:

x.map((a: Int, b: Int) => "(" + a + ", " + b + ")")

我收到以下错误:

console:28: error: type mismatch;
found   : (Int, Int) => String
required: ((Int, Int)) => ?
             x.map((a: Int, b: Int) => "(" + a + ", " + b + ")")

为什么它期望第一个元素的类型是((Int, Int))

【问题讨论】:

    标签: scala dictionary lambda functional-programming


    【解决方案1】:

    Alexey Romanov 已经给出了错误的原因。如果您想使用模式匹配,也可以这样做:

    x.map(v=>{val (a,b)=v;"(" + a + ", " + b + ")"})
    

    在 Scala REPL 中:

    scala> val x = Array((3,2), (4,5))
    x: Array[(Int, Int)] = Array((3,2), (4,5))
    
    scala> x.map(v=>{val (a,b)=v;"(" + a + ", " + b + ")"})
    res2: Array[String] = Array((3, 2), (4, 5))
    

    【讨论】:

      【解决方案2】:

      这是 Scala 的一个有点不直观的怪癖,map(whatever=>...) 实际上是一回事 - 您正在映射的 Seq 类型,您可以/需要稍后解构。幸运的是,正如其他人所指出的那样,您可以使用模式匹配,为此您需要用大括号替换括号并添加 case 关键字所以 map {case (a,b) => } 等。

      【讨论】:

        【解决方案3】:

        您已经创建了一个元组数组。 Scala tuple 将固定数量的项目组合在一起,以便它们可以作为一个整体传递。与数组或列表不同,元组可以保存不同类型的对象,但它们也是不可变的。

        为了访问元组的值,Scala 提供了._1,._2 来访问元组的值。 例如

        scala> val tuple = (2,4)
        tuple: (Int, Int) = (2,4)
        
        scala> tuple._1
        res11: Int = 2
        
        scala> tuple._2
        res12: Int = 4
        

        如果元组中有两个以上的值,._3 将用于获取元组的第三个值。

        同样,您已经创建了 tuple2 的数组。

        scala> val arr = Array((1,1), (2,4), (3,9))
        arr: Array[(Int, Int)] = Array((1,1), (2,4), (3,9))
        
        scala> arr.map(tuple => "(" + tuple._1 + "," + tuple._2 + ")" )
        res13: Array[String] = Array((1,1), (2,4), (3,9))
        

        另一种可以使用模式匹配来获取值的方法。

        scala> arr.map{
             | case (a: Int, b: Int) => "(" + a + "," + b + ")" }
        res17: Array[String] = Array((1,1), (2,4), (3,9))
        

        【讨论】:

          【解决方案4】:

          (Int, Int) => ... 是具有两个参数的函数的类型,两个参数都是 Int(这就是 (a: Int, b: Int) => ... 将始终给出的)。

          ((Int, Int)) => ... 是具有一个 (Int, Int) 参数的函数的类型。 map on Array 需要一个带有一个参数的函数,对于 Array[(Int, Int)],此参数的类型必须是 (Int, Int)

          所以你需要写任何一个

          x.map(pair => "(" + pair._1 + ", " + pair._2 + ")")
          

          其中pair 的类型为(Int, Int),或者

          x.map { case (a, b) => "(" + a + ", " + b + ")" }
          

          (使用模式匹配)。请注意,在这种情况下,大括号是必需的。

          【讨论】:

            猜你喜欢
            • 2021-04-14
            • 1970-01-01
            • 2015-02-20
            • 1970-01-01
            • 1970-01-01
            • 1970-01-01
            • 2020-05-27
            • 1970-01-01
            • 1970-01-01
            相关资源
            最近更新 更多