目录
1.Scala函数方法
1.1Map()方法
map()是一种高阶函数，通常用于对集合（比如List、Array等）中的每个元素进行映射转换。它接受一个函数作为参数，该函数会被应用到集合中的每个元素上，并返回一个新的集合，其中包含了原集合中每个元素经过函数转换后的结果
代码：
object one {
def main(args: Array[String]): Unit = {
// 定义一个列表
val a = List(1, 2, 3, 4, 5)
// 使用map()函数将列表中的每个元素乘以2
val b = a.map(x => x * 2)
// 打印转换后的列表
println(b)
}
}
结果：
1.2foreach()方法
foreach() 是 Scala 中常用的集合操作方法之一，用于对集合中的每个元素执行指定的操作，但不返回任何结果。与 map() 不同的是，foreach() 主要用于执行副作用操作，而不是对集合中的元素进行转换
代码：
object one {
def main(args: Array[String]): Unit = {
// 定义一个列表
val numbers = List(1, 2, 3, 4, 5)
// 使用 foreach() 方法打印列表中的每个元素
numbers.foreach(x => println(x))
}
}
结果：
1.3filter()方法
filter() 方法是 Scala 中常用的集合操作方法之一，用于筛选出集合中满足指定条件的元素，并返回一个新的集合包含满足条件的元素。这个方法接受一个函数作为参数，该函数会被应用到集合中的每个元素上，如果函数返回 true，则该元素会被包含在结果集合中，否则不包含。
代码：
object one {
def main(args: Array[String]): Unit = {
// 定义一个列表
val numbers = List(1, 2, 3, 4, 5)
// 使用 filter() 方法筛选出列表中大于 2 的元素
val filteredNumbers = numbers.filter(x => x > 2)
// 打印筛选后的列表
println(filteredNumbers)
}
}
结果：
1.4flatten()方法
flatten() 方法在 Scala 中用于将嵌套的集合结构“扁平化”，即将多层嵌套的集合转换为单层的集合。例如，如果你有一个包含多个列表的列表，你可以使用 flatten() 方法将其转换为一个单独的列表，其中包含了所有元素：
代码 :
object one {
def main(args: Array[String]): Unit = {
val nestedList = List(List(1, 2), List(3, 4), List(5, 6))
val flatList = nestedList.flatten
println(flatList)
}
}
结果：
1.5flatmap()方法
flatMap() 方法是一种结合了 map() 和 flatten() 的功能的高阶函数。它通常用于在集合上应用一个函数，并将结果扁平化成一个单层的集合。
具体来说，flatMap() 方法首先对集合中的每个元素应用一个函数，然后将结果集合中的每个子集合合并成一个大的集合。
代码：
object one {
def main(args: Array[String]): Unit = {
val list = List(List(1, 2), List(3, 4), List(5, 6))
// 使用 flatMap() 方法将嵌套的列表转换为单层列表
val flatMappedList = list.flatMap(x => x)
println(flatMappedList)
}
}
结果：
1.6.groupBy()方法
groupBy() 方法用于根据给定函数对集合中的元素进行分组，并返回一个 Map，其中键是分组的结果，而值是相应分组的元素列表。
代码：
object one {
def main(args: Array[String]): Unit = {
val list = List("apple", "banana", "grape", "apricot", "blueberry")
// 使用 groupBy() 方法根据字符串长度进行分组
val groupedMap = list.groupBy(_.length)
println(groupedMap)
}
}
结果：
2.spark编程基础
2.1parallelize()
parallelize() 方法是 Apache Spark 中的一个函数，用于将现有的集合转换为分布式数据集（RDD）。在 Spark 中，RDD（Resilient Distributed Dataset）是一种表示分布在多台计算机上的数据集合的数据结构。通过将数据集分布在多台计算机上，Spark 可以实现并行计算，加速数据处理过程。
代码：
import org.apache.spark.{SparkConf, SparkContext}
object one {
def main(args: Array[String]): Unit = {
val conf = new SparkConf().setAppName("example").setMaster("local[*]")
val sc = new SparkContext(conf)
// 创建一个包含整数的列表
val data = List(1, 2, 3, 4, 5)
// 使用 parallelize() 方法将列表转换为 RDD
val rdd = sc.parallelize(data)
// 对 RDD 执行一些操作
val sum = rdd.reduce(_ + _)
println("Sum of elements in RDD: " + sum)
}
}
结果：
2.2makeRDD()
makeRDD() 是一个用于创建 RDD（弹性分布式数据集）的方法。它可以将一个已存在的集合或数组转换为一个 RDD，使得数据能够在 Spark 集群上进行并行计算。
代码：
import org.apache.spark.{SparkConf, SparkContext}
object one {
def main(args: Array[String]): Unit = {
val conf = new SparkConf().setAppName("SparkApp").setMaster("local[*]")
val sc = new SparkContext(conf)
// 创建一个包含整数的列表
val data = List(1, 2, 3, 4, 5)
// 使用 makeRDD() 方法将列表转换为 RDD
val rdd = sc.makeRDD(data)
// 对 RDD 执行一些操作
val sum = rdd.reduce(_ + _)
println("Sum of elements in RDD: " + sum)
sc.stop()
}
}
结果：
2.3textfile()
textFile() 是一个用于读取文本文件并将其转换为 RDD 的方法。该方法可以接受一个或多个文件路径，并将它们转换为 RDD
代码：
import org.apache.spark.{SparkConf, SparkContext}
object SparkApp {
def main(args: Array[String]): Unit = {
val conf = new SparkConf().setAppName("SparkApp").setMaster("local[*]")
val sc = new SparkContext(conf)
// 使用 textFile() 方法读取文本文件并创建 RDD
val rdd = sc.textFile("C:\\Users\\Administrator\\Desktop\\a.txt")
// 对 RDD 执行一些操作
val count = rdd.count()
println("Number of lines in RDD: " + count)
sc.stop()
}
}
结果：
2.4Map()方法
Spark 中，map() 是一个用于对 RDD 中的每个元素执行转换操作的方法。该方法接受一个适用于 RDD 中每个元素的函数，并返回一个新的 RDD
代码：
import org.apache.spark.{SparkConf, SparkContext}
object SparkApp {
def main(args: Array[String]): Unit = {
val conf = new SparkConf().setAppName("SparkApp").setMaster("local[*]")
val sc = new SparkContext(conf)
// 创建一个包含整数的列表
val data = List(1, 2, 3, 4, 5)
// 使用 makeRDD() 方法将列表转换为 RDD
val rdd = sc.makeRDD(data)
// 对 RDD 中的每个元素执行平方操作
val squaredRDD = rdd.map(x => x * x)
// 输出转换后的 RDD 中的元素
squaredRDD.foreach(println)
sc.stop()
}
}
结果：
2.5sortBy()方法
在 Spark 中，sortBy() 是一个用于对 RDD 中的元素进行排序的方法。该方法接受一个排序函数和一个布尔值参数，用于指定排序方式（升序或降序），并返回一个新的已排序的 RDD。
代码：
import org.apache.spark.{SparkConf, SparkContext}
object SparkApp {
def main(args: Array[String]): Unit = {
val conf = new SparkConf().setAppName("SparkApp").setMaster("local[*]")
val sc = new SparkContext(conf)
// 创建一个包含整数的列表
val data = List(5, 3, 1, 4, 2)
// 使用 makeRDD() 方法将列表转换为 RDD
val rdd = sc.makeRDD(data)
// 对 RDD 中的元素进行排序
val sortedRDD = rdd.sortBy(x => x, ascending = true)
// 输出排序后的 RDD 中的元素
sortedRDD.foreach(println)
sc.stop()
}
}
结果：
2.6collect()方法
在 Spark 中，collect() 是一个用于将 RDD 中的所有元素收集到驱动程序中的方法。该方法会以数组的形式返回 RDD 中的所有元素，并且需要注意的是，如果 RDD 太大无法一次性放入内存中，则可能会导致内存溢出。
代码：
import org.apache.spark.{SparkConf, SparkContext}
object SparkApp {
def main(args: Array[String]): Unit = {
val conf = new SparkConf().setAppName("SparkApp").setMaster("local[*]")
val sc = new SparkContext(conf)
// 创建一个包含整数的列表
val data = List(1, 2, 3, 4, 5)
// 使用 makeRDD() 方法将列表转换为 RDD
val rdd = sc.makeRDD(data)
// 使用 collect() 方法将 RDD 中的所有元素收集到驱动程序中
val collected = rdd.collect()
// 输出收集到的 RDD 元素
collected.foreach(println)
sc.stop()
}
}
结果：
2.7flatMap()
flatMap() 方法是 Spark 中常用的一个转换操作，它可以将一个 RDD 中的每个元素映射成一个或多个新的元素，并将这些元素合并为一个新的 RDD。
代码：
import org.apache.spark.{SparkConf, SparkContext}
object SparkApp {
def main(args: Array[String]): Unit = {
val conf = new SparkConf().setAppName("SparkApp").setMaster("local[*]")
val sc = new SparkContext(conf)
val words = sc.parallelize(Seq("Hello", "world", "this", "is", "Spark"))
words.foreach(println)
val chars = words.flatMap(word => word.toCharArray)
chars.foreach(println)
}
}
结果：
2.8take（）方法
take() 方法用于从集合中获取指定数量的元素，返回一个新的集合。
代码：
package com
object one {
def main(args: Array[String]): Unit = {
val list = List(1, 2, 3, 4, 5)
// 取前3个元素
val result1 = list.take(3)
println(result1)
// 对于空集合，take() 方法返回一个空集合
val emptyList = List.empty[Int]
val result2 = emptyList.take(3)
println(result2)
// 如果指定的数量大于集合中的元素数量，将返回整个集合
val result3 = list.take(10)
println(result3)
}
}结果：
2.9union（）方法
union() 方法用于将两个集合合并成一个新的集合，去除重复的元素。它是集合类的方法之一，适用于 Set 和 Seq 类型的集合。
代码：
package com
object one {
def main(args: Array[String]): Unit = {
val set1 = Set(1, 2, 3)
val set2 = Set(3, 4, 5)
val result = set1.union(set2)
println(result)
}
}
结果：
3.0distinst()方法
distinct() 方法用于从集合中移除重复的元素，并返回一个包含唯一元素的新集合。这个方法适用于 Seq、Set 和 Map 类型的集合。
代码：
package com
object one {
def main(args: Array[String]): Unit = {
val list = List(1, 2, 2, 3, 3, 4, 5, 5)
val uniqueList = list.distinct
println(uniqueList)
}
}
结果：
3.1cartesian() 方法
用于计算两个 RDD 的笛卡尔积（Cartesian product）。笛卡尔积是两个集合之间的所有可能的组合，其中一个元素来自第一个集合，另一个元素来自第二个集合。
代码：
package com
import org.apache.spark.{SparkConf, SparkContext}
object one {
def main(args: Array[String]): Unit = {
val conf = new SparkConf().setAppName("RDDCartesianExample").setMaster("local[*]")
val sc = new SparkContext(conf)
// 创建两个RDD
val rdd1 = sc.parallelize(Seq("A", "B", "C"))
val rdd2 = sc.parallelize(Seq(1, 2, 3))
// 计算两个RDD的笛卡尔积
val cartesianRDD = rdd1.cartesian(rdd2)
// 打印结果
cartesianRDD.collect().foreach(println)
sc.stop()
}
}
结果：
3.2reduceByKey()
用于将具有相同键的元素进行归约操作。它接收一个函数作为参数，该函数定义了对具有相同键的值进行合并的方式，并返回一个新的 RDD。
代码：
package com
import org.apache.spark.{SparkConf, SparkContext}
object one {
def main(args: Array[String]): Unit = {
val conf = new SparkConf().setAppName("ReduceByKeyExample").setMaster("local[*]")
val sc = new SparkContext(conf)
// 创建一个包含键值对的RDD
val data = Seq(("a", 1), ("b", 2), ("a", 3), ("b", 4), ("c", 5))
val rdd = sc.parallelize(data)
// 对具有相同键的值进行求和
val result = rdd.reduceByKey(_ + _)
// 打印结果
result.collect().foreach(println)
sc.stop()
}
}
结果：
3.3groupBykey()
用于将具有相同键的元素进行分组。它接收一个键值对 RDD 作为输入，并返回一个新的 RDD，其中的元素是按键分组的。
代码：
package com
import org.apache.spark.{SparkConf, SparkContext}
object one {
def main(args: Array[String]): Unit = {
val conf = new SparkConf().setAppName("GroupByKeyExample").setMaster("local[*]")
val sc = new SparkContext(conf)
// 创建一个包含键值对的RDD
val data = Seq(("a", 1), ("b", 2), ("a", 3), ("b", 4), ("c", 5))
val rdd = sc.parallelize(data)
// 按键分组
val groupedRDD = rdd.groupByKey()
// 打印结果
groupedRDD.collect().foreach(println)
sc.stop()
}
}
结果：
3.4combineByKey()
用于执行基于键的聚合操作的高级转换函数之一。它提供了一种灵活的方式来对每个键的值进行聚合，而不需要事先进行预先聚合或排序。
代码：
package com
import org.apache.spark.{SparkConf, SparkContext}
object one {
def main(args: Array[String]): Unit = {
val conf = new SparkConf().setAppName("CombineByKeyExample").setMaster("local[*]")
val sc = new SparkContext(conf)
// 创建一个包含键值对的RDD
val rdd = sc.parallelize(Seq(("apple", 3), ("banana", 5), ("apple", 7), ("banana", 2), ("orange", 1)))
// 使用combineByKey方法进行基于键的聚合操作
val aggregatedRDD = rdd.combineByKey(
createCombiner = (v: Int) => (v, 1), // 初始化值为(v, 1)，其中v是值，1表示计数
mergeValue = (acc: (Int, Int), v: Int) => (acc._1 + v, acc._2 + 1), // 将新值合并到已存在的聚合值中，并更新计数
mergeCombiners = (acc1: (Int, Int), acc2: (Int, Int)) => (acc1._1 + acc2._1, acc1._2 + acc2._2) // 合并不同分区的聚合值，并更新计数
)
// 打印结果
aggregatedRDD.collect().foreach(println)
sc.stop()
}
}
结果：
3.5join()方法
用于将两个 RDD 按照键进行连接操作。它接收另一个键值对 RDD 作为参数，并返回一个新的 RDD，其中的元素是两个原始 RDD 中具有相同键的元素的笛卡尔积。
代码：
package com
import org.apache.spark.{SparkConf, SparkContext}
object one {
def main(args: Array[String]): Unit = {
val conf = new SparkConf().setAppName("JoinExample").setMaster("local[*]")
val sc = new SparkContext(conf)
// 创建两个包含键值对的RDD
val rdd1 = sc.parallelize(Seq(("a", 1), ("b", 2), ("c", 3)))
val rdd2 = sc.parallelize(Seq(("a", "apple"), ("b", "banana"), ("c", "cherry")))
// 使用join方法进行连接操作
val joinedRDD = rdd1.join(rdd2)
// 打印结果
joinedRDD.collect().foreach(println)
sc.stop()
}
}
结果：
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
