这可以归结为你最初的问题:你所说的扁平化是什么意思?

当您使用flatMap时，“多维”集合就变成了“一维”集合。

val array1d = Array ("1,2,3", "4,5,6", "7,8,9")  
//array1d is an array of strings

val array2d = array1d.map(x => x.split(","))
//array2d will be : Array( Array(1,2,3), Array(4,5,6), Array(7,8,9) )

val flatArray = array1d.flatMap(x => x.split(","))
//flatArray will be : Array (1,2,3,4,5,6,7,8,9)

当你想使用flatMap时，

你的地图功能的结果是创建多层结构 但所有你想要的是一个简单的-平面-一维结构，通过删除所有的内部分组

Flatmap和Map都转换集合。

的区别:

地图(函数) 返回一个新的分布式数据集，该数据集通过函数func传递源的每个元素。

flatMap(函数) 类似于map，但是每个输入项可以映射到0个或多个输出项(因此func应该返回Seq而不是单个项)。

变换函数为: map:输入一个元素->输出一个元素。 flatMap:输入一个元素->输出0个或更多元素(一个集合)。

map:它通过对RDD的每个元素应用函数来返回一个新的RDD。.map中的函数只能返回一个项。

flatMap:与map类似，它通过对RDD的每个元素应用函数来返回一个新的RDD，但输出是扁平的。

同样，flatMap中的函数可以返回一个元素列表(0或更多)

例如:

sc.parallelize([3,4,5]).map(lambda x: range(1,x)).collect()

输出:[[1,2]，[1,2,3]，[1,2,3,4]]

sc.parallelize([3,4,5]).flatMap(lambda x: range(1,x)).collect()

输出:注意o/p在单个列表[1,2,1,2,3， 1,2,3,4]

来源:https://www.linkedin.com/pulse/difference-between-map-flatmap-transformations-spark-pyspark-pandey/

map

通过将函数应用到该RDD的每个元素，返回一个新的RDD。

>>> rdd = sc.parallelize([2, 3, 4])
>>> sorted(rdd.map(lambda x: [(x, x), (x, x)]).collect())
[[(2, 2), (2, 2)], [(3, 3), (3, 3)], [(4, 4), (4, 4)]]

flatMap

返回一个新的RDD，首先对该RDD的所有元素应用一个函数，然后将结果平摊。 在这里，一个元素转化为多个元素是可能的

>>> rdd = sc.parallelize([2, 3, 4])
>>> sorted(rdd.flatMap(lambda x: [(x, x), (x, x)]).collect())
[(2, 2), (2, 2), (3, 3), (3, 3), (4, 4), (4, 4)]

所有的例子都很好....这是一个很好的视觉插图…资料来源:spark的DataFlair培训

Map: Map是Apache Spark中的转换操作。它应用于RDD的每个元素，并将结果作为新的RDD返回。在Map中，操作开发人员可以定义自己的自定义业务逻辑。同样的逻辑将应用于RDD的所有元素。

Spark RDD map函数以一个元素作为输入，根据自定义代码(由开发人员指定)处理它，每次返回一个元素。Map将一个长度为N的RDD转换为另一个长度为N的RDD。输入和输出RDD通常具有相同数量的记录。

使用scala的map示例:

val x = spark.sparkContext.parallelize(List("spark", "map", "example",  "sample", "example"), 3)
val y = x.map(x => (x, 1))
y.collect
// res0: Array[(String, Int)] = 
//    Array((spark,1), (map,1), (example,1), (sample,1), (example,1))

// rdd y can be re writen with shorter syntax in scala as 
val y = x.map((_, 1))
y.collect
// res1: Array[(String, Int)] = 
//    Array((spark,1), (map,1), (example,1), (sample,1), (example,1))

// Another example of making tuple with string and it's length
val y = x.map(x => (x, x.length))
y.collect
// res3: Array[(String, Int)] = 
//    Array((spark,5), (map,3), (example,7), (sample,6), (example,7))

FlatMap:

flatMap是一个转换操作。它应用于RDD的每个元素，并将结果作为新的RDD返回。它类似于Map，但是FlatMap允许从Map函数返回0,1或更多元素。在FlatMap操作中，开发人员可以定义自己的自定义业务逻辑。同样的逻辑将应用于RDD的所有元素。

“flatten the results”是什么意思?

FlatMap函数接受一个元素作为输入，根据自定义代码(由开发人员指定)处理它，并一次返回0个或多个元素。flatMap()将一个长度为N的RDD转换为另一个长度为M的RDD。

使用scala的flatMap示例:

val x = spark.sparkContext.parallelize(List("spark flatmap example",  "sample example"), 2)

// map operation will return Array of Arrays in following case : check type of res0
val y = x.map(x => x.split(" ")) // split(" ") returns an array of words
y.collect
// res0: Array[Array[String]] = 
//  Array(Array(spark, flatmap, example), Array(sample, example))

// flatMap operation will return Array of words in following case : Check type of res1
val y = x.flatMap(x => x.split(" "))
y.collect
//res1: Array[String] = 
//  Array(spark, flatmap, example, sample, example)

// RDD y can be re written with shorter syntax in scala as 
val y = x.flatMap(_.split(" "))
y.collect
//res2: Array[String] = 
//  Array(spark, flatmap, example, sample, example)

抽样。Map返回单个数组中的所有元素

抽样。flatMap返回数组数组中的元素

让我们假设在text.txt文件中有文本

Spark is an expressive framework
This text is to understand map and faltMap functions of Spark RDD

使用地图

val text=sc.textFile("text.txt").map(_.split(" ")).collect

输出:

text: **Array[Array[String]]** = Array(Array(Spark, is, an, expressive, framework), Array(This, text, is, to, understand, map, and, faltMap, functions, of, Spark, RDD))

使用flatMap

val text=sc.textFile("text.txt").flatMap(_.split(" ")).collect

输出:

 text: **Array[String]** = Array(Spark, is, an, expressive, framework, This, text, is, to, understand, map, and, faltMap, functions, of, Spark, RDD)