Scala 这两种函数格式之间的差异

我正在研究spark，而不是scala方面的专家。我得到了map函数的两个变体。你能解释一下它们之间的区别吗

第一种变体和已知格式

第一变体

val.map( (x,y) => x.size()) 

第二个变量->这已应用于元组

val.map({case (x, y) => y.toString()});

val的类型是

RDD[（可写，文本）]

。当我尝试使用第一个函数时，它给出了如下错误

类型失配； 发现：（org.apache.hadoop.io.intwriteable，org.apache.hadoop.io.Text）⇒ 单位 必需：（（org.apache.hadoop.io.intwriteable，org.apache.hadoop.io.Text））⇒ 单位

当我加上额外的括号时，它说

元组不能在方法或函数参数中直接解构

我试着回答这个问题：

scala> val l = List(("firstname", "tom"), ("secondname", "kate"))
l: List[(String, String)] = List((firstname,tom), (secondname,kate))

scala> l.map((x, y) => x.size)
<console>:9: error: missing parameter type
Note: The expected type requires a one-argument function accepting a    2-Tuple.
  Consider a pattern matching anonymous function, `{ case (x, y) =>  ... }`
          l.map((x, y) => x.size)

scala>val l=List（（“第一名”、“汤姆”）、（“第二名”、“凯特”））
l:List[（String，String）]=List（（第一个名字，汤姆），（第二个名字，凯特））
scala>l.map（（x，y）=>x.size）
：9:错误：缺少参数类型
注意：预期类型需要一个接受2元组的单参数函数。
考虑一个匹配匿名函数的模式：{{（x，y）＝>…}。
l、 地图（（x，y）=>x.size）

---

也许可以给你一些启发。

你的第一个例子是一个函数，它接受两个参数并返回一个字符串。这与此示例类似：

scala> val f = (x:Int,y:Int) => x + y
f: (Int, Int) => Int = <function2>

您可以看到函数

g

的返回类型现在是

（（Int，Int））=>Int

。你能看出区别吗？

g

的输入类型有两个括号。这表明

g

接受一个参数，该参数必须是

元组[Int，Int]

（简称

（Int，Int）

）

回到RDD，您拥有的是一组

元组[IntWritable，Text]

，因此第二个函数可以工作，而第一个函数不能工作

你说：

val的类型为RDD[（可写，文本）]

因此，它是一个arity2的元组，由

intwriteable

和

Text

作为组件

如果你说

val.map( (x,y) => x.size())

您所做的是将一个

Function2

传递给

map

函数，该函数具有两个参数。这将永远不会编译，因为

map

需要一个带有一个参数的函数。您可以执行以下操作：

val.map((xy: (IntWritable, Text)) => xy._2.toString)

使用

\u 2

获取元组的第二部分，该部分作为

xy

传入（类型注释不是必需的，但更清晰）

现在是第二个变体（您可以省略外部参数）：

这是一种特殊的scala语法，用于创建一个

PartialFunction

，该函数立即匹配传入的元组，以访问

x

和

y

部分。这是可能的，因为扩展来自常规类（

Function1[A，B]

可以用一个参数编写为

A=>B

）

---

希望这更清楚：）

第一个变量是两个参数的函数，第二个变量是一个参数的函数，应该是一个元组。

val.map((xy: (IntWritable, Text)) => xy._2.toString)

val.map { case (x, y) => y.toString() }