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()
}
}
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（）方法
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.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()
}
}
了解scala
Scala是Scalable Language的缩写，是一种多范式的编程语言，由洛桑联邦理工学院的马丁·奥德斯在2001年基于Funnel的工作开始设计，设计初衷是想集成面向对象编程和函数式编程的各种特性。
Scala 是一种纯粹的面向对象的语言，每个值都是对象。Scala也是一种函数式语言，因此函数可以当成值使用。
由于Scala整合了面向对象编程和函数式编程的特性，因此Scala相对于Java、C#、C++等其他语言更加简洁。
Scala源代码会被编译成Java字节码，因此Scala可以运行于Java虚拟机（Java Virtual Machine，JVM）之上，并可以调用现有的Java类库。
Scala特性
面向对象 函数式编程 静态类型 可扩展
运行Scala
Scala解释器也称为REPL（Read-Evaluate-Print-Loop，读取-执行-输出-循环）。
在命令行中输入“scala”，即可进入REPL，如下图。
REPL是一个交互式界面，用户输入命令时，可立即产生交互反馈。
输入“:quit”命令即可退出REPL，如下图。
下图是一个Scala类，该类实现了两个数相加的方法。如果要使用该方法，那么需要通过import加载该方法，如下图，其中，add是类名，addInt是方法名。
定义函数识别函数类型
了解数据类型
Scala会区分不同类型的值，并且会基于使用值的方式确定最终结果的数据类型，这称为类型推断。
Scala使用类型推断可以确定混合使用数据类型时最终结果的数据类型。
如在加法中混用Int和Double类型时，Scala将确定最终结果为Double类型
使用for循环
循环是指在某种条件下将一段代码按顺序重复执行。在Scala中有3种循环结构，分别为while循环、do…while循环和for循环。
for循环是相对较为常用的一种循环，for循环语法格式如下。
for(变量<- 集合) {循环语句}
多重循环是常见的for循环，多重循环也称为for循环嵌套，是指在两个或多个区间内循环反复，多个循环区间用分号隔开。
Scala可以在for循环中使用if判断过滤一些元素，多个过滤条件用分号隔开。
for循环使用yield可以将返回值作为一个变量存储，语法格式如下。
var retVar = for(var x <- List; if condition1; if condition2…) yield x
retVar是变量名，for关键字后的括号用于指明变量和条件，而yield会将每一次循环得到的返回值保存在一个集合中，循环结束后将返回该集合，并赋值给变量retVar。
使用yield对1～10的偶数进行记录，并保存至变量even中，
定义与使用列表
1.Scala 中常用的查看列表元素的方法有 head 、 init 、 last 、 tail 和 take() 。
• head ：查看列表的第一个元素。
• tail ：查看第一个元素之后的其余元素。
• last ：查看列表的最后一个元素。
• Init ：查看除最后一个元素外的所有元素。
• take() ：查看列表前 n 个元素。
2.如果需要合并两个列表，那么可以使用:::()。但需要注意，“列表1:::列表2”与“列表1.:::(列表2)”的结果是不一样的，对于前者，列表2的元素添加在列表1的后面；对于后者，列表2的元素添加在列表1的前面。合并两个列表还可以使用concat()方法。用户可以使用contains()方法判断列表中是否包含某个元素，若列表中存在指定的元素则返回true，否则返回false。
定义与使用集合
Scala Set( 集合 ) 是没有重复的对象集合，所有的元素都是唯一的 。
定义与使用映射
Ø 映射（ Map ） 是一种可迭代的键值对结构 。
Ø 所有的值都可以通过键来获取 ，并且映射中的键都是唯一的 。
Ø 集合操作常用方法同样也适合映射。
Ø 另外映射还可以通过 keys 方法获取所有的键，通过 values 方法获取所有值，也可以通过 isEmpty 方法判断映射的数据是否为空
定义与使用元组
Ø 元组（ Tuple ）是一种类似于列表的结构，但与列表不同的是，元组可以包含不同类型的元素。
Ø 元组的值是通过将单个的值包含在圆括号中构成的 。
Ø 目前， Scala 支持的元组最大长度为 22 ，即 Scala 元组最多只能包含 22 个元素。
Ø 访问元组元素可以通过“元组名称 ._ 元素索引”进行，索引从 1 开始。
用函数组合器
Ø map() 方法 可通过一个函数重新计算列表中的所有元素，并且返回一个包含相同数目元素的新列表
Ø foreach() 方法 和 map() 方法类似，但是 foreach() 方法没有返回值，只用于对参数的结果进行输出。
ØflatMap()方法结合了map()方法和flatten()方法的功能，接收一个可以处理嵌套列表的函 数，再对返回结果进行连接。
ØgroupBy()方法可对集合中的元素进行分组操作，返回的结果是一个映射。
扫一扫
156
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
