目录
Spark 计算框架为了能够进行高并发和高吞吐的数据处理，封装了三大数据结构，用于处理不同的应用场景。三大数据结构分别是：
- RDD : 弹性分布式数据集
- 累加器：分布式共享只写变量
- 广播变量：分布式共享只读变量
接下来我们一起看看这三大数据结构是如何在数据处理中使用的。
1.1 什么是RDD
RDD（Resilient Distributed Dataset）叫做弹性分布式数据集，是 Spark 中最基本的数据处理模型。代码中是一个抽象类，它代表一个弹性的、不可变、可分区、里面的元素可并行计算的集合。
- 弹性
-
- 存储的弹性：内存与磁盘的自动切换；
-
- 容错的弹性：数据丢失可以自动恢复；
-
- 计算的弹性：计算出错重试机制；
-
- 分片的弹性：可根据需要重新分片。
- 分布式：数据存储在大数据集群不同节点上
- 数据集：RDD 封装了计算逻辑，并不保存数据
- 数据抽象：RDD 是一个抽象类，需要子类具体实现
- 不可变：RDD 封装了计算逻辑，是不可以改变的，想要改变，只能产生新的RDD，在新的RDD 里面封装计算逻辑
- 可分区、并行计算
1.2 核心属性
- 分区列表
RDD 数据结构中存在分区列表，用于执行任务时并行计算，是实现分布式计算的重要属性
- 分区计算函数
Spark 在计算时，是使用分区函数对每一个分区进行计算
- RDD 之间的依赖关系
RDD 是计算模型的封装，当需求中需要将多个计算模型进行组合时，就需要将多个 RDD 建立依赖关系
- 分区器（可选）
当数据为 KV 类型数据时，可以通过设定分区器自定义数据的分区
- 首选位置（可选）
计算数据时，可以根据计算节点的状态选择不同的节点位置进行计算
1.3 执行原理
从计算的角度来讲，数据处理过程中需要计算资源（内存 & CPU）和计算模型（逻辑）。执行时，需要将计算资源和计算模型进行协调和整合。
Spark 框架在执行时，先申请资源，然后将应用程序的数据处理逻辑分解成一个一个的计算任务。然后将任务发到已经分配资源的计算节点上, 按照指定的计算模型进行数据计算。最后得到计算结果。
RDD 是 Spark 框架中用于数据处理的核心模型，接下来我们看看，在 Yarn 环境中，RDD 的工作原理:
1）启动 Yarn 集群环境
2）Spark 通过申请资源创建调度节点和计算节点
3）Spark 框架根据需求将计算逻辑根据分区划分成不同的任务
4）调度节点将任务根据计算节点状态发送到对应的计算节点进行计算
从以上流程可以看出 RDD 在整个流程中主要用于将逻辑进行封装，并生成 Task 发送给Executor 节点执行计算，接下来我们就一起看看 Spark 框架中RDD 是具体是如何进行数据处理的。
1.4 基础编程
1.4.1 创建RDD
在 Spark 中创建RDD 的创建方式可以分为四种：
1）从集合（内存）中创建 RDD
从集合中创建RDD，Spark 主要提供了两个方法：parallelize 和makeRDD
// 准备环境 local[*] *代表CPU最大核心数
val sparkConf: SparkConf = new SparkConf().setMaster("local[*]").setAppName("RDD")
val sc = new SparkContext(sparkConf)
// 创建RDD
// 从内存中创建RDD，内存集合中的数据作为处理的数据源
val seq = Seq[Int](1, 2, 3, 4)
//val rdd: RDD[Int] = sc.parallelize(seq) // parallelize:并行
val rdd: RDD[Int] = sc.makeRDD(seq) // makeRDD就是调用了parallelize，更容易理解
rdd.collect().foreach(println)
// 关闭环境
sc.stop()2）从外部存储（文件）创建RDD
// 准备环境 local[*] *代表CPU最大核心数
val sparkConf: SparkConf = new SparkConf().setMaster("local[*]").setAppName("RDD")
val sc = new SparkContext(sparkConf)
// 创建RDD
// 从文件中创建RDD，文件中的数据作为处理的数据源
// path路径默认以项目的根路径为基准，也可以写绝对路径
//val rdd: RDD[String] = sc.textFile("data/1.txt")
// path可以是文件，也可以是文件夹
//val rdd: RDD[String] = sc.textFile("data/")
// path支持通配符
//val rdd: RDD[String] = sc.textFile("data/1*.txt")
// path支持hdfs路径
val rdd: RDD[String] = sc.textFile("hdfs://hadoop102:8080//test.txt")
rdd.collect().foreach(println)
// 创建RDD
// 从文件中创建RDD，文件中的数据作为处理的数据源
val rdd: RDD[(String, String)] = sc.wholeTextFiles("data")
rdd.collect().foreach(println)
"""
|(file:/B:/pycharm_project/mingyu-classes/data/1.txt,Hello world
|Hello spark)
|(file:/B:/pycharm_project/mingyu-classes/data/11.txt,Hello world
|Hello spark)
|(file:/B:/pycharm_project/mingyu-classes/data/2.txt,Hello scala
|Hello Hive)
""".stripMargin
// 关闭环境
sc.stop()3）从其他 RDD 创建
主要是通过一个RDD 运算完后，再产生新的RDD。
4）直接创建 RDD（new）
使用 new 的方式直接构造RDD，一般由Spark 框架自身使用。
1.4.2 RDD 并行度与分区
默认情况下，Spark 可以将一个作业切分多个任务后，发送给 Executor 节点并行计算，而能够并行计算的任务数量我们称之为并行度。这个数量可以在构建RDD 时指定。记住，这里的并行执行的任务数量，并不是指的切分任务的数量，不要混淆了
① 内存中的数据分区
// 准备环境 local[*] *代表CPU最大核心数
val sparkConf: SparkConf = new SparkConf().setMaster("local[*]").setAppName("RDD")
val sc = new SparkContext(sparkConf)
// 创建RDD
// 从内存中创建RDD,numSlices表示划分成多少个任务
val rdd = sc.makeRDD(
List(1, 2, 3, 4), 2
)
// 将处理的数据保存成分区文件
rdd.saveAsTextFile("output")
rdd.collect().foreach(println)
// 关闭环境
sc.stop() 
分区数目默认值为最大可用CPU核心数 ，也可以配置
// 准备环境 local[*] *代表CPU最大核心数
val sparkConf: SparkConf = new SparkConf().setMaster("local[*]").setAppName("RDD")
sparkConf.set("spark.default.parallelism","5")
val sc = new SparkContext(sparkConf)② 从文件中读取数据进行分区
读取文件数据时，数据是按照Hadoop 文件读取的规则进行切片分区，而切片规则和数据读取的规则有些差异
// 准备环境 local[*] *代表CPU最大核心数
val sparkConf: SparkConf = new SparkConf().setMaster("local[*]").setAppName("RDD")
val sc = new SparkContext(sparkConf)
"""
| 1. 数据以行为单位进行读取
| Spark读取文件时，采用的是以Hadoop方式读取，
| 因此一行一行读取，和文件字节数没有关系
|
| 2. 数据读取时以偏移量为单位，偏移量不会重复读取
| 1@@ => 012
| 2@@ => 345
| 3 => 6
|
| 3. 数据分区的偏移量范围的计算
| 分区号 文件内容索引范围 内容 解释
| 0 => [0,3] => 12 (因为[0,3]是左闭右闭，把2也读进来了，意味着[3,5]都读进来了）
| 1 => [3,6] => 3 (因为[3,5]已经被读出，不能再读，只能读[6,7],就是数字3)
| 2 => [6,7]
""".stripMargin
val rdd: RDD[String] = sc.textFile("data/1.txt", 2)
"""
| word.txt 14byte
| 1234567@@ => 012345678
| 89@@ => 9101112
| 0 => 13
|
| 2个分区
| [0,7] => 1234567
| [7,14] => 890
""".stripMargin1.4.3 RDD转换算子
单Value类型
RDD 根据数据处理方式的不同将算子整体上分为Value 类型、双 Value 类型和Key-Value
类型
- 将处理的数据逐条进行映射转换，这里的转换可以是类型的转换，也可以是值的转换、
-
map
def map[U: ClassTag](f: T => U): RDD[U]val sparkConf: SparkConf = new SparkConf().setMaster("local[*]").setAppName("Operator")
val sc = new SparkContext(sparkConf)
val rdd: RDD[Int] = sc.makeRDD(List(1, 2, 3, 4))
val valueRdd: RDD[Int] = rdd.map(_ * 2)
valueRdd.collect().foreach(println) // 2,4,6,8map方法的性能比较差， 但是基本不会造成内存溢出
val sparkConf: SparkConf = new SparkConf().setMaster("local[*]").setAppName("Operator")
val sc = new SparkContext(sparkConf)
// 1 RDD的计算一个分区内的数据是一个一个执行的
// 只有前面的数据所有流程都执行完了才会执行下一个数据
// 2 不同分区的数据计算是无序的
val rdd: RDD[Int] = sc.makeRDD(List(1, 2, 3, 4), 1)
val mapRdd = rdd.map(
num => {
println(">>>>>>>>>>" + num)
num
}
)
val mapRdd1 = mapRdd.map(
num => {
println("##########" + num)
num
}
)
mapRdd1.collect()
"""
|>>>>>>>>>>1
|##########1
|>>>>>>>>>>2
|##########2
|>>>>>>>>>>3
|##########3
|>>>>>>>>>>4
|##########4
""".stripMarginrdd.mapPartitions
方法性能更高一些，但是易造成内存溢出
def mapPartitions[U: ClassTag](
f: Iterator[T] => Iterator[U],
preservesPartitioning: Boolean = false
): RDD[U]
val rdd: RDD[Int] = sc.makeRDD(List(1, 2, 3, 4), 2)
// 将一个分区中的数据全部拿到之后才进行下一个分区计算
// 但是会将整个分区中的数据加载到内存中
// 如果处理的数据不被释放，存在对象引用
// 内存小，数据量大，易造成内存溢出
val mapParti = rdd.mapPartitions(
iter => {
println(">>>>>>>>>")
iter.map(_ * 2)
}
)
mapParti.collect().foreach(println)
"""
|>>>>>>>>>
|>>>>>>>>>
|2
|4
|6
|8
""".stripMargin val rdd: RDD[Int] = sc.makeRDD(List(1, 2, 3, 4), 2)
// 将一个分区中的数据全部拿到之后才进行下一个分区计算
// 但是会将整个分区中的数据加载到内存中
// 如果处理的数据不被释放，存在对象引用
// 内存小，数据量大，易造成内存溢出
val mapParti = rdd.mapPartitions(
iter => {
List(iter.max).iterator
}
)
mapParti.collect().foreach(println) // 2 4map 和 mapPartitions 的区别
- 数据处理角度
Map 算子是分区内一个数据一个数据的执行，类似于串行操作。而 mapPartitions 算子是以分区为单位进行批处理操作。
- 功能的角度
Map 算子主要目的将数据源中的数据进行转换和改变。但是不会减少或增多数据。MapPartitions 算子需要传递一个迭代器，返回一个迭代器，没有要求的元素的个数保持不变， 所以可以增加或减少数据
- 性能的角度
Map 算子因为类似于串行操作，所以性能比较低，而是 mapPartitions 算子类似于批处理，所以性能较高。但是mapPartitions 算子会长时间占用内存，那么这样会导致内存可能不够用，出现内存溢出的错误。所以在内存有限的情况下，不推荐使用。使用 map 操作。
mapPartitionsWithIndex
将待处理的数据以分区为单位发送到计算节点进行处理，这里的处理是指可以进行任意的处理，哪怕是过滤数据，在处理时同时可以获取当前分区索引。
def mapPartitionsWithIndex[U: ClassTag](
f: (Int, Iterator[T]) => Iterator[U],
preservesPartitioning: Boolean = false
): RDD[U]
回去第二个分区的数据
val rdd: RDD[Int] = sc.makeRDD(List(1, 2, 3, 4), 2)
// mapPartitionsWithIndex根据分区索引操作
val mapParti = rdd.mapPartitionsWithIndex(
(index, iter) => {
if (index == 1) {
iter
} else {
Nil.iterator
}
}
)
mapParti.collect().foreach(println) // 3,4flatMap
将处理的数据进行扁平化后再进行映射处理，所以算子也称之为扁平映射
def flatMap[U: ClassTag](f: T => TraversableOnce[U]): RDD[U] val rdd = sc.makeRDD(List(List(1, 2), List(3, 4)), 1)
// 将处理的数据进行扁平化后再进行映射处理
val mapParti = rdd.flatMap(
list => list
)
mapParti.collect().foreach(println) // 1 2 3 4将 List(List(1,2),3,List(4,5))进行扁平化操作
// 创建RDD
val rdd = sc.parallelize(List(List(1, 2), 3, List(4, 5)), 1)
// 扁平化操作
val flattenedRdd = rdd.flatMap {
case x: List[_] => x
case x: Int => List(x)
}
// 输出结果
flattenedRdd.foreach(println)glom
将同一个分区的数据直接转换为相同类型的内存数组进行处理，分区不变
def glom(): RDD[Array[T]]// 创建RDD
val rdd = sc.makeRDD(List(1, 2, 3, 4, 5, 6), 3)
// glom
val glomRdd = rdd.glom()
// 输出结果
glomRdd.foreach(arr => println(arr.mkString(" ")))
3 4
1 2
5 6计算所有分区最大值求和（分区内取最大值，分区间最大值求和）
// 创建RDD
val rdd = sc.makeRDD(List(1, 2, 3, 4, 5, 6), 3)
// glom
val glomRdd = rdd.glom()
// 输出结果
val maxRdd: RDD[Int] = glomRdd.map(_.max)
val sum: Int = maxRdd.reduce(_ + _)
maxRdd.foreach(a => println(s"最大值${a}"))
println(sum / 3)groupBy
- 函数签名
def groupBy[K](f: T => K)(implicit kt: ClassTag[K]): RDD[(K, Iterable[T])]- 函数说明
将数据根据指定的规则进行分组, 分区默认不变，但是数据会被打乱重新组合，我们将这样的操作称之为shuffle。极限情况下，数据可能被分在同一个分区中，一个组的数据在一个分区中，但是并不是说一个分区中只有一个组
// 创建RDD
val rdd = sc.makeRDD(List(1, 2, 3, 4, 5, 6), 3)
def fun(num: Int): Int = num % 2
val groupRdd: RDD[(Int, Iterable[Int])] = rdd.groupBy(fun)
groupRdd.collect().foreach(println)
// (0,CompactBuffer(2, 4, 6))
// (1,CompactBuffer(1, 3, 5))filter
- 函数签名
def filter(f: T => Boolean): RDD[T]- 函数说明
将数据根据指定的规则进行筛选过滤，符合规则的数据保留，不符合规则的数据丢弃。
当数据进行筛选过滤后，分区不变，但是分区内的数据可能不均衡，生产环境下，可能会出现数据倾斜。
val sc = new SparkContext(sparkConf)
// 创建RDD
val rdd = sc.makeRDD(List(1, 2, 3, 4, 5, 6), 3)
val filterRdd: RDD[Int] = rdd.filter(i => i % 2 != 0)
filterRdd.collect().foreach(println)
// 1
// 3
// 5sample
- 函数签名
def sample( withReplacement: Boolean,
fraction: Double,
seed: Long = Utils.random.nextLong
): RDD[T]- 函数说明
根据指定的规则从数据集中抽取数据
// 创建RDD
val rdd = sc.makeRDD(List(1, 2, 3, 4, 5, 6), 3)
// 抽取数据不放回（伯努利算法）
// 伯努利算法：又叫 0、1 分布。例如扔硬币，要么正面，要么反面。
// 具体实现：根据种子和随机算法算出一个数和第二个参数设置几率比较，小于第二个参数要，大于不要
// 第一个参数：抽取的数据是否放回，false：不放回
// 第二个参数：抽取的几率，范围在[0,1]之间,0：全不取；1：全取；
// 第三个参数：随机数种子
val sampleRdd: RDD[Int] = rdd.sample(false, 0.2, 472634629875426L)
val sampleRdd2: RDD[Int] = rdd.sample(false, 1)
sampleRdd.collect().foreach(println)
// 抽取数据放回（泊松算法）
// 第一个参数：抽取的数据是否放回，true：放回；false：不放回
// 第二个参数：重复数据的几率，范围大于等于 0.表示每一个元素被期望抽取到的次数
// 第三个参数：随机数种子
val bsRdd: RDD[Int] = rdd.sample(true, 2)distinct
- 函数签名
def distinct()(implicit ord: Ordering[T] = null): RDD[T]
def distinct(numPartitions: Int)(implicit ord: Ordering[T] = null): RDD[T]- 函数说明
数据集中重复的数据去重
// 创建RDD
val rdd = sc.makeRDD(List(1, 2, 3, 4, 1, 2), 3)
val distinctRdd: RDD[Int] = rdd.distinct(3)
distinctRdd.collect().foreach(x => print(s"${x} "))
// 3 4 1 2 coalesce
- 函数签名
def coalesce(numPartitions: Int, shuffle: Boolean = false,
partitionCoalescer: Option[PartitionCoalescer] = Option.empty)
(implicit ord:Ordering[T] = null)
: RDD[T]- 函数说明
根据数据量缩减分区，用于大数据集过滤后，提高小数据集的执行效率
当 spark 程序中，存在过多的小任务的时候，可以通过 coalesce 方法，收缩合并分区，减少分区的个数，减小任务调度成本
// 创建RDD
val rdd = sc.makeRDD(1 to 100, 10)
val coalesceRdd: RDD[Int] = rdd.coalesce(2)
println(s"转换后的分区数：${coalesceRdd.getNumPartitions}")
//转换后的分区数：2repartition
- 函数签名
def repartition(numPartitions: Int)(implicit ord: Ordering[T] = null): RDD[T]- 函数说明
该操作内部其实执行的是 coalesce 操作，参数 shuffle 的默认值为 true。无论是将分区数多的RDD 转换为分区数少的RDD，还是将分区数少的 RDD 转换为分区数多的RDD，repartition 操作都可以完成，因为无论如何都会经 shuffle 过程。
// 创建RDD
val rdd = sc.makeRDD(List(1, 2, 3, 4, 5, 6), 3)
val repartitionRdd: RDD[Int] = rdd.repartition(1)
println(repartitionRdd.getNumPartitions) // 1
val repartitionRdd5: RDD[Int] = rdd.repartition(5)
println(repartitionRdd5.getNumPartitions) // 51）coalesce可以不进行shuffle,repartition必须进行shuffle
2）coalesce只能减少分区，而repartition可以减少和增加
sortBy
函数签名
def sortBy[K]( f：(T) => K,
ascending: Boolean = true, numPartitions: Int = this.partitions.length)
(implicit ord: Ordering[K], ctag: ClassTag[K]): RDD[T]- 函数说明
该操作用于排序数据。在排序之前，可以将数据通过 f 函数进行处理，之后按照 f 函数处理的结果进行排序，默认为升序排列。排序后新产生的 RDD 的分区数与原RDD 的分区数一致。中间存在 shuffle 的过程
// 创建RDD
val rdd = sc.makeRDD(List(8, 2, 4, 3, 6, 5, 1, 3), 3)
val sortedRdd: RDD[Int] = rdd.sortBy((num: Int) => num)
sortedRdd.collect().foreach(x => print(s"${x} "))
// 1 2 3 3 4 5 6 8双Value类型
intersection
- 函数签名
def intersection(other: RDD[T]): RDD[T]- 函数说明
|
|
// 创建RDD
val dataRdd = sc.makeRDD(List(1, 2, 3, 4, 5), 3)
val dataRdd2 = sc.makeRDD(List(4, 5, 6, 7), 3)
val isRdd: RDD[Int] = dataRdd.intersection(dataRdd2)
isRdd.collect().foreach(x => print(s"${x} ")) // 4 5
println(isRdd.getNumPartitions) //3思考一个问题：如果两个RDD 数据类型不一致怎么办？
// 创建RDD
val dataRdd = sc.makeRDD(List(1, 2, 3, 4, 5), 3)
val dataRdd2 = sc.makeRDD(List("4", "5", "6", "7"), 3)
// 转换成List[Int]
val intRdd: RDD[Int] = dataRdd2.map(_.toInt)
val isRdd = dataRdd.intersection(intRdd)
isRdd.collect().foreach(x => print(s"${x} ")) // 4 5
println(isRdd.getNumPartitions) //3union
- 函数签名
def union(other: RDD[T]): RDD[T]- 函数说明
|
对源RDD 和参数RDD 求并集后返回一个新的RDD |
// 创建RDD
val dataRdd = sc.makeRDD(List(1, 2, 3), 3)
val dataRdd2 = sc.makeRDD(List(3, 4, 5, 6), 3)
val unionRdd = dataRdd.union(dataRdd2)
unionRdd.collect().foreach(x => print(s"${x} "))
// 1 2 3 3 4 5 6 subtract
- 函数签名
def subtract(other: RDD[T]): RDD[T]- 函数说明
以一个 RDD 元素为主，去除两个 RDD 中重复元素，将其他元素保留下来。求差集
// 创建RDD
val dataRdd = sc.makeRDD(List(1, 2, 3), 3)
val dataRdd2 = sc.makeRDD(List(3, 4, 5, 6), 3)
val subtractRdd = dataRdd.subtract(dataRdd2)
subtractRdd.collect().foreach(x => print(s"${x} "))
// 1 2 zip
- 函数签名
def zip[U: ClassTag](other: RDD[U]): RDD[(T, U)]- 函数说明
将两个 RDD 中的元素，以键值对的形式进行合并。其中，键值对中的Key 为第 1 个 RDD中的元素，Value 为第 2 个 RDD 中的相同位置的元素。
// 创建RDD
val dataRdd = sc.makeRDD(List(1, 2, 3), 3)
val dataRdd2 = sc.makeRDD(List(3, 4, 5), 3)
val dataRdd3 = sc.makeRDD(List("a", "b", "c"), 3)
val zipRdd = dataRdd.zip(dataRdd2)
zipRdd.collect().foreach(x => print(s"${x} "))
// (1,3) (2,4) (3,5)
// (1,a) (2,b) (3,c)
分区数量不一致
// 创建RDD
val dataRdd = sc.makeRDD(List(1, 2, 3), 3)
val dataRdd2 = sc.makeRDD(List("a", "b", "c"), 2)
// 分区数目不一致
//val zipRdd = dataRdd.zip(dataRdd2.repartition(3))
val zipRdd = dataRdd2.zip(dataRdd.coalesce(2, false))
zipRdd.collect().foreach(x => print(s"${x} "))
//(a,1) (b,2) (c,3)数据量不一致
// 创建RDD
val dataRdd = sc.makeRDD(List(1, 2, 3), 3)
val dataRdd2 = sc.makeRDD(List("a", "b", "c", "d"), 3)
// 创建索引
val zipWithIndexRdd: RDD[(Long, Int)] = dataRdd.zipWithIndex().map { case (value, index) => (index, value) }
val zipWithIndexRdd2: RDD[(Long, String)] = dataRdd2.zipWithIndex().map { case (value, index) => (index, value) }
val result = zipWithIndexRdd.join(zipWithIndexRdd2).map { case (index, (value1, value2)) => (value1, value2) }
// 数据量不一致
result.collect().foreach(x => print(s"${x} "))
//(1,a) (2,b) (3,c)需要注意的是，使用zipWithIndex操作可能会影响性能，因为它需要为每个元素添加一个索引。如果你的RDD数据量很大，那么可能需要考虑使用其他方法来实现zip操作。
Key-Value类型
partitionBy
- 函数签名
def partitionBy(partitioner: Partitioner): RDD[(K, V)]
- 函数说明
将数据按照指定Partitioner 重新进行分区。Spark 默认的分区器是HashPartitioner
val rdd: RDD[(Int, String)] = sc.makeRDD(Array((1,"aaa"),(2,"bbb"),(3,"ccc")),3)
import org.apache.spark.HashPartitioner
val rdd2: RDD[(Int, String)] = rdd.partitionBy(new HashPartitioner(2))reduceByKey
- 函数签名
def reduceByKey(func: (V, V) => V): RDD[(K, V)]
def reduceByKey(func: (V, V) => V, numPartitions: Int): RDD[(K, V)]
- 函数说明
可以将数据按照相同的Key 对Value 进行聚合
// 创建RDD
val dataRdd = sc.makeRDD(Array(("aaa", 1), ("bbb", 2), ("ccc", 3), ("ccc", 3)), 3)
val reduceRdd: RDD[(String, Int)] = dataRdd.reduceByKey(_ + _)
reduceRdd.collect().foreach(x => print(s"${x} "))
// (bbb,2) (ccc,6) (aaa,1) groupByKey
- 函数签名
def groupByKey(): RDD[(K, Iterable[V])]
def groupByKey(numPartitions: Int): RDD[(K, Iterable[V])]
def groupByKey(partitioner: Partitioner): RDD[(K, Iterable[V])]- 函数说明
将数据源的数据根据 key 对 value 进行分组
val dataRDD1 =
sparkContext.makeRDD(List(("a",1),("b",2),("c",3)))
val dataRDD2 = dataRDD1.groupByKey()
val dataRDD3 = dataRDD1.groupByKey(2)
val dataRDD4 = dataRDD1.groupByKey(new HashPartitioner(2))
reduceByKey和groupByKey区别
- 从shuffle的角度：reduceByKey和groupByKey都存在shuffle的操作，但是reduceByKey可以在shuffle前对分区内相同key的数据进行预聚合（combine）功能，这样会减少落盘的数据量，而groupByKey只是进行分组，不存在数据量减少的问题，reduceByKey性能比较高。
- 从功能的角度：reduceByKey其实包含分组和聚合的功能。groupByKey只能分组，不能聚合，所以在分组聚合的场合下，推荐使用reduceByKey，如果仅仅是分组而不需要聚合。那么还是只能使用groupByKey
aggregateByKey
- 函数签名
def aggregateByKey[U: ClassTag](zeroValue: U)(seqOp: (U, V) => U,
combOp: (U, U) => U): RDD[(K, U)]- 函数说明
将数据根据不同的规则进行分区内计算和分区间计算
// 创建RDD
val dataRdd = sc.makeRDD(Array(("aaa", 1), ("aaa", 2), ("bbb", 3), ("bbb", 4), ("bbb", 5), ("aaa", 6)), 2)
// TODO : 取出每个分区内相同 key 的最大值然后分区间相加
// aggregateByKey 算子是函数柯里化，存在两个参数列表
// 1. 第一个参数列表中的参数表示初始值
// 2. 第二个参数列表中含有两个参数
// 2.1 第一个参数表示分区内的计算规则
// 2.2 第二个参数表示分区间的计算规则
val aggregateByKeyRdd = dataRdd.aggregateByKey(0)(
(x, y) => math.max(x, y),
(x, y) => x + y
)
aggregateByKeyRdd.collect().foreach(x => print(s"${x} "))
// (bbb,8) (aaa,8) foldByKey
- 函数签名
def foldByKey(zeroValue: V)(func: (V, V) => V): RDD[(K, V)]
- 函数说明
当分区内计算规则和分区间计算规则相同时，aggregateByKey 就可以简化为foldByKey
// 创建RDD
val dataRdd = sc.makeRDD(Array(("aaa", 1), ("aaa", 2), ("bbb", 3), ("bbb", 4), ("bbb", 5), ("aaa", 6)), 2)
// 就可以简化为foldByKey 算子是函数柯里化，存在两个参数列表
// 当分区内计算规则和分区间计算规则相同时，aggregateByKey 就可以简化为foldByKey
val aggregateByKeyRdd = dataRdd.foldByKey(0)((x, y) => x + y)
aggregateByKeyRdd.collect().foreach(x => print(s"${x} "))
// (bbb,12) (aaa,9) combineByKey
- 函数签名
def combineByKey[C]( createCombiner: V => C, mergeValue: (C, V) => C,
mergeCombiners: (C, C) => C): RDD[(K, C)]- 函数说明
最通用的对key-value 型 rdd 进行聚集操作的聚集函数（aggregation function）。类似于aggregate()，combineByKey()允许用户返回值的类型与输入不一致。
val list: List[(String, Int)] = List(("a", 88), ("b", 95), ("a", 91), ("b", 93),
("a", 95), ("b", 98))
val input: RDD[(String, Int)] = sc.makeRDD(list, 2)
// 第一个参数：将相同key的第一个数据进行结构的转换，实现操作
// 第二个参数：分区内计算规则
// 底单个参数：分区间计算规则
val combineRdd: RDD[(String, (Int, Int))] = input.combineByKey((_, 1),
(acc: (Int, Int), v) => (acc._1 + v, acc._2 + 1),
(acc1: (Int, Int), acc2: (Int, Int)) => (acc1._1 + acc2._1, acc1._2 + acc2._2)
)
combineRdd.mapValues {
case (num, count) => {
num / count
}
}.collect().foreach(x => print(s"${x} "))reduceByKey、foldByKey、aggregateByKey、combineByKey的区别？
- reduceByKey:相同key的第一个数据不进行任何计算，分区内和分区间计算规则相同
- foldByKey: 相同key的第一个数据和初始值进行分区内计算，分区内和分区间计算规则相同
- aggregateByKey：相同key的第一个数据和初始值进行分区内计算，分区内和分区间计算规则可以不相同
- combineByKey:当计算时，发现数据结构不满足要求时，可以让第一个数据转换结构。分区内和分区间计算规则不相同。
sortByKey
- 函数签名
def sortByKey(ascending: Boolean = true, numPartitions: Int = self.partitions.length)
: RDD[(K, V)]- 函数说明
在一个(K,V)的 RDD 上调用，K 必须实现 Ordered 接口(特质)，返回一个按照 key 进行排序的
val dataRDD1 = sparkContext.makeRDD(List(("a",1),("b",2),("c",3)))
val sortRDD1: RDD[(String, Int)] = dataRDD1.sortByKey(true)
val sortRDD1: RDD[(String, Int)] = dataRDD1.sortByKey(false)join
- 函数签名
def join[W](other: RDD[(K, W)]): RDD[(K, (V, W))]- 函数说明
在类型为(K,V)和(K,W)的RDD 上调用，返回一个相同 key 对应的所有元素连接在一起的(K,(V,W))的RDD
val input: RDD[(String, Int)] = sc.makeRDD(List(("a", 1), ("b", 2), ("c", 3)), 2)
val input2: RDD[(String, Int)] = sc.makeRDD(List(("a", 4), ("b", 5), ("c", 6)), 2)
input.join(input2).collect().foreach(x => print(s"${x} "))
// (b,(2,5)) (a,(1,4)) (c,(3,6)) leftOuterJoin
- 函数签名
def leftOuterJoin[W](other: RDD[(K, W)]): RDD[(K, (V, Option[W]))]- 函数说明
类似于 SQL 语句的左外连接
val input: RDD[(String, Int)] = sc.makeRDD(List(("a", 1), ("b", 2), ("c", 3)), 2)
val input2: RDD[(String, Int)] = sc.makeRDD(List(("a", 4), ("b", 5)), 2)
input.leftOuterJoin(input2).collect().foreach(x => print(s"${x} "))
// (b,(2,Some(5))) (a,(1,Some(4))) (c,(3,None)) cogroup
- 函数签名
def cogroup[W](other: RDD[(K, W)]): RDD[(K, (Iterable[V], Iterable[W]))]- 函数说明
在类型为(K,V)和(K,W)的RDD 上调用，返回一个(K,(Iterable<V>,Iterable<W>))类型的 RDD
cogroup => connect + group
val input: RDD[(String, Int)] = sc.makeRDD(List(("a", 1), ("b", 2), ("c", 3)), 2)
val input2: RDD[(String, Int)] = sc.makeRDD(List(("a", 4), ("b", 5), ("c", 6), ("c", 7)), 2)
input.cogroup(input2).collect().foreach(x => print(s"${x} "))
//input.cogroup(input2).collect().foreach(println)
// (b,(CompactBuffer(2),CompactBuffer(5))) (a,(CompactBuffer(1),CompactBuffer(4))) (c,(CompactBuffer(3),CompactBuffer(6, 7)))
案例
数据：agent.log：时间戳，省份，城市，用户，广告，中间字段使用空格分隔。
需求：统计出每一个省份每个广告被点击数量排行的 Top3
先写需求，再写代码
// 1、获取数据
// 时间戳 省份 城市 用户 广告
val dataRdd: RDD[String] = sc.textFile("data/agent.log")
// 2、结构化数据
// 时间戳 省份 城市 用户 广告
// =>
// ((省份,广告),1)
val mapRdd: RDD[((String, String), Int)] = dataRdd.map {
line => {
val lineData: Array[String] = line.split(" ")
((lineData(1), lineData(4)), 1)
}
}
// 3、求和
// ((省份,广告),1) => ((省份,广告),sum)
val reduceRdd: RDD[((String, String), Int)] = mapRdd.reduceByKey(_ + _)
// 4、再次结构化数据
// (省份,(广告,sum))
val reMapRdd: RDD[(String, (String, Int))] = reduceRdd.map {
case ((pro, ad), sum) => {
(pro, (ad, sum))
}
}
// 5、分组
// 【(省份A,List((广告1,sum1),(广告2,sum2),...)),...】
val groupRdd: RDD[(String, Iterable[(String, Int)])] = reMapRdd.groupByKey()
// 6、降序取前三名
val result: RDD[(String, List[(String, Int)])] = groupRdd.mapValues(
iter => {
iter.toList.sortBy(_._2)(Ordering.Int.reverse).take(3)
}
)
// 6.5、按省份升序输出
result.sortByKey(true).collect().foreach(println)
// 7、输出
//result.collect().foreach(println)
//result.collect().foreach(println)
/*
(0,List((2,29), (24,25), (26,24)))
(1,List((3,25), (6,23), (5,22)))
(2,List((6,24), (21,23), (29,20)))
(3,List((14,28), (28,27), (22,25)))
(4,List((12,25), (2,22), (16,22)))
(5,List((14,26), (21,21), (12,21)))
(6,List((16,23), (24,21), (22,20)))
(7,List((16,26), (26,25), (1,23)))
(8,List((2,27), (20,23), (11,22)))
(9,List((1,31), (28,21), (0,20)))
*/1.4.4 RDD行动算子
reduce
- 函数签名
def reduce(f: (T, T) => T): T- 函数说明
聚集RDD 中的所有元素，先聚合分区内数据，再聚合分区间数据
val rdd: RDD[Int] = sc.makeRDD(List(1, 2, 3, 4))
// 聚合数据
val reduceResult: Int = rdd.reduce(_ + _)
println(reduceResult) // 10collect
def collect(): Array[T]- 函数说明
在驱动程序中，以数组Array 的形式返回数据集的所有元素
val rdd: RDD[Int] = sc.makeRDD(List(1,2,3,4))
rdd.collect().foreach(println)
// 收 集 数 据 到 Driver
count
- 函数签名
def count(): Long- 函数说明
返回RDD 中元素的个数
val rdd: RDD[Int] = sc.makeRDD(List(1, 2, 3, 4))
println(rdd.count())// 4first
- 函数签名
def first(): T- 函数说明
返回RDD 中的第一个元素
val rdd: RDD[Int] = sc.makeRDD(List(1, 2, 3, 4))
println(rdd.first())// 1take
- 函数签名
def take(num: Int): Array[T]- 函数说明
返回一个由RDD 的前 n 个元素组成的数组
val rdd: RDD[Int] = sc.makeRDD(List(1, 2, 3, 4))
println(rdd.take(2).mkString(" ")) // 1 2takeOrdered
- 函数签名
def takeOrdered(num: Int)(implicit ord: Ordering[T]): Array[T]- 函数说明
返回该 RDD 排序后的前 n 个元素组成的数组
val rdd: RDD[Int] = sc.makeRDD(List(2, 1, 4, 6))
println(rdd.takeOrdered(2).mkString(" ")) // 1 2aggregate
- 函数签名
def aggregate[U: ClassTag](zeroValue: U)(seqOp: (U, T) => U, combOp: (U, U) => U): U- 函数说明
分区的数据通过初始值和分区内的数据进行聚合，然后再和初始值进行分区间的数据聚合
val rdd: RDD[Int] = sc.makeRDD(List(4, 6, 8, 9), 8)
val i: Int = rdd.aggregate(0)(_ + _, _ + _)
val i2: Int = rdd.aggregate(10)(_ + _, _ + _)
println(i)// 27 =
println(i2) //117 = [(4+10) + (6+10) + (8+10) + (9+10) + 4*(0+10)] + 10fold
- 函数签名
def fold(zeroValue: T)(op: (T, T) => T): T- 函数说明
折叠操作，aggregate 的简化版操作
val rdd: RDD[Int] = sc.makeRDD(List(4, 6, 8, 9), 8)
val i: Int = rdd.fold(0)(_ + _)
println(i) // 27countByKey
- 函数签名
def countByKey(): Map[K, Long]- 函数说明
统计每种 key 的个数
val rdd: RDD[(Int, String)] = sc.makeRDD(List((1, "a"), (2, "b"), (1, "c"), (2, "6"), (3, "c"), (1, "f")), 8)
val intToLong: collection.Map[Int, Long] = rdd.countByKey()
intToLong.foreach(x => print(s"${x} "))
// (1,3) (2,2) (3,1)save相关算子
- 函数签名
def saveAsTextFile(path: String): Unit
def saveAsObjectFile(path: String): Unit
def saveAsSequenceFile(
path: String,
codec: Option[Class[_ <: CompressionCodec]] = None)
: Unit- 函数说明
将数据保存到不同格式的文件中
val rdd: RDD[(Int, String)] = sc.makeRDD(List((1, "a"), (2, "b"), (1, "c"), (2, "6"), (3, "c"), (1, "f")), 1)
rdd.saveAsTextFile("data/save.txt")
val rdd: RDD[(Int, String)] = sc.makeRDD(List((1, "a"), (2, "b"), (1, "c"), (2, "6"), (3, "c"), (1, "f")), 1)
rdd.saveAsObjectFile("data/save2.txt") 
val rdd: RDD[(Int, String)] = sc.makeRDD(List((1, "a"), (2, "b"), (1, "c"), (2, "6"), (3, "c"), (1, "f")), 1)
rdd.saveAsSequenceFile("data/save3.txt")
foreach
- 函数签名
def foreach(f: T => Unit): Unit = withScope {
val cleanF = sc.clean(f)
sc.runJob(this, (iter: Iterator[T]) => iter.foreach(cleanF))
}- 函数说明
分布式遍历RDD 中的每一个元素，调用指定函数
val rdd: RDD[Int] = sc.makeRDD(List(1,2,3,4))
// 收集后打印
rdd.map(num=>num).collect().foreach(println) println("****************")
// 分布式打印
rdd.foreach(println)
1.4.5 RDD序列化
闭包检查
从计算的角度, 算子以外的代码都是在Driver 端执行, 算子里面的代码都是在 Executor 端执行。那么在 scala 的函数式编程中，就会导致算子内经常会用到算子外的数据，这样就形成了闭包的效果，如果使用的算子外的数据无法序列化，就意味着无法传值给Executor 端执行，就会发生错误，所以需要在执行任务计算前，检测闭包内的对象是否可以进行序列化，这个操作我们称之为闭包检测。Scala2.12 版本后闭包编译方式发生了改变
序列化方法和属性
从计算的角度, 算子以外的代码都是在Driver 端执行, 算子里面的代码都是在 Executor端执行
package com.mingyu.spark.core.rdd.operator.serial
import org.apache.spark.rdd.RDD
import org.apache.spark.{SparkConf, SparkContext}
object Serial {
def main(args: Array[String]): Unit = {
val sparkConf: SparkConf = new SparkConf().setMaster("local[*]").setAppName("Action")
val sc = new SparkContext(sparkConf)
val rdd: RDD[String] = sc.makeRDD(Array("hello world", "hello spark", "hive", "lalala"))
val search = new Search("h")
//search.getMatch1(rdd).collect().foreach(println)
search.getMatch2(rdd).collect().foreach(println)
sc.stop()
}
}
// 类的构造参数未被val/var修饰时，类内方法用到了构造参数
// 则会将构造参数自动提升为类的属性
// 若构造参数未被val/var修饰，类内方法也没有用到构造参数
// 不会成为属性
class Search(val query: String) extends Serializable {
def isMatch(s: String): Boolean = {
s.contains(query)
}
// 函数序列化案例-外部函数
def getMatch1(rdd: RDD[String]): RDD[String] = {
rdd.filter(isMatch)
}
// 属性序列化案例-匿名函数
def getMatch2(rdd: RDD[String]): RDD[String] = {
//val s = query // s:String，局部变量，能被序列化，通过闭包检测
rdd.filter(x => x.contains(query)) // 运行在Executor中，形成闭包
}
}
Kryo序列化框架
参考地址: https://github.com/EsotericSoftware/kryo
Java 的序列化能够序列化任何的类。但是比较重（字节多），序列化后，对象的提交也比较大。Spark 出于性能的考虑，Spark2.0 开始支持另外一种Kryo 序列化机制。Kryo 速度是 Serializable 的 10 倍。当 RDD 在 Shuffle 数据的时候，简单数据类型、数组和字符串类型已经在 Spark 内部使用 Kryo 来序列化。
注意：即使使用Kryo 序列化，也要继承Serializable 接口
import org.apache.spark.{SparkConf, SparkContext}
import org.apache.spark.rdd.RDD
object serializable_Kryo {
def main(args: Array[String]): Unit = {
val conf: SparkConf = new SparkConf()
.setAppName("SerDemo")
.setMaster("local[*]")
// 替换默认的序列化机制
.set("spark.serializer", "org.apache.spark.serializer.KryoSerializer")
// 注册需要使用 kryo 序列化的自定义类
.registerKryoClasses(Array(classOf[Searcher]))
val sc = new SparkContext(conf)
val rdd: RDD[String] = sc.makeRDD(Array("hello world", "hello atguigu", "atguigu", "hahah"), 2)
val searcher = new Searcher("hello")
val result: RDD[String] = searcher.getMatchedRDD1(rdd)
result.collect.foreach(println)
}
}
case class Searcher(val query: String) {
def isMatch(s: String) = {
s.contains(query)
}
def getMatchedRDD1(rdd: RDD[String]) = {
rdd.filter(isMatch)
}
def getMatchedRDD2(rdd: RDD[String]) = {
val q = query
rdd.filter(_.contains(q))
}
}RDD 依赖关系
RDD 只支持粗粒度转换，即在大量记录上执行的单个操作。将创建 RDD 的一系列Lineage（血统）记录下来，以便恢复丢失的分区。RDD 的Lineage 会记录RDD 的元数据信息和转换行为，当该RDD 的部分分区数据丢失时，它可以根据这些信息来重新运算和恢复丢失的数据分区
val sc = new SparkContext(conf)
sc.textFile("data/1.txt")
.flatMap(_.split(" "))
.map((_,1))
.reduceByKey(_+_)
.collect()
- RDD 窄依赖
窄依赖表示每一个父(上游)RDD 的 Partition 最多被子（下游）RDD 的一个 Partition 使用， 窄依赖我们形象的比喻为独生子女。
class OneToOneDependency[T](rdd: RDD[T]) extends NarrowDependency[T](rdd) 
- RDD 宽依赖
宽依赖表示同一个父（上游）RDD 的 Partition 被多个子（下游）RDD 的 Partition 依赖，会引起 Shuffle，总结：宽依赖我们形象的比喻为多生
class ShuffleDependency[K: ClassTag,
V: ClassTag,
C: ClassTag]
(
@transient private val _rdd: RDD[_ <: Product2[K, V]],
val partitioner: Partitioner,
val serializer: Serializer = SparkEnv.get.serializer,
val keyOrdering: Option[Ordering[K]] = None,
val aggregator: Option[Aggregator[K, V, C]] = None,
val mapSideCombine: Boolean = false
)
RDD阶段划分
DAG（Directed Acyclic Graph）有向无环图是由点和线组成的拓扑图形，该图形具有方向， 不会闭环。例如，DAG 记录了RDD 的转换过程和任务的阶段。
RDD任务划分
RDD 任务切分中间分为：Application、Job、Stage 和 Task
- Application：初始化一个 SparkContext 即生成一个Application；、
- Job：一个Action 算子就会生成一个Job；
- Stage：Stage 等于宽依赖(ShuffleDependency)的个数加 1；
- Task：一个 Stage 阶段中，最后一个RDD 的分区个数就是Task 的个数。
注意：Application->Job->Stage->Task 每一层都是 1 对 n 的关系。
RDD持久化
1）RDD Cache缓存
RDD 通过Cache 或者 Persist 方法将前面的计算结果缓存，默认情况下会把数据以缓存在 JVM 的堆内存中。但是并不是这两个方法被调用时立即缓存，而是触发后面的 action 算子时，该RDD 将会被缓存在计算节点的内存中，并供后面重用
val rdd: RDD[String] = sc.makeRDD(List("hello spark", "hello scala"))
val bufferRdd: RDD[(String, Int)] = rdd.flatMap(_.split(" ")).map((_, 1))
// bufferRdd对象重用意义不大，RDD不存储数据，重用导致前面代码会重新执行一遍
//bufferRdd.reduceByKey(_ + _).collect().foreach(println)
//bufferRdd.groupByKey().collect().foreach(println)
// 数据缓存,内存
//bufferRdd.cache()
bufferRdd.persist(StorageLevel.DISK_ONLY)
缓存有可能丢失，或者存储于内存的数据由于内存不足而被删除，RDD 的缓存容错机制保证了即使缓存丢失也能保证计算的正确执行。通过基于RDD 的一系列转换，丢失的数据会被重算，由于RDD 的各个 Partition 是相对独立的，因此只需要计算丢失的部分即可， 并不需要重算全部Partition。
Spark 会自动对一些 Shuffle 操作的中间数据做持久化操作(比如：reduceByKey)。这样做的目的是为了当一个节点 Shuffle 失败了避免重新计算整个输入。但是，在实际使用的时候，如果想重用数据，仍然建议调用 persist 或 cache。
一些比较耗时的重要数据在操作时也可以使用Cache
2) checkpoint检查点
// checkpoint 检查点路径：hdfs或者本地
sc.setCheckpointDir("data/")
val rdd: RDD[String] = sc.makeRDD(List("hello spark", "hello scala"))
val bufferRdd: RDD[(String, Int)] = rdd.flatMap(_.split(" ")).map((_, 1))
// checkpoint 需要落盘，需要指定检查点保存路径
// 需要注意的是，checkpoint遇到Action算子之后，会独立执行作业（Action算子之前的操作再做一遍）
// 因此，配合Cache使用效率更高
bufferRdd.cache()
bufferRdd.checkpoint()
bufferRdd.collect()
3）缓存和检查点区别
- Cache 缓存只是将数据保存起来，不切断血缘依赖。Checkpoint 检查点切断血缘依赖。
- Cache 缓存的数据通常存储在磁盘、内存等地方，可靠性低。Checkpoint 的数据通常存储在HDFS 等容错、高可用的文件系统，可靠性高。
- 建议对checkpoint()的RDD 使用Cache 缓存，这样 checkpoint 的 job 只需从 Cache 缓存中读取数据即可，否则需要再从头计算一次RDD。
1.4.6 RDD分区器
Spark 目前支持Hash 分区和 Range 分区，和用户自定义分区。Hash 分区为当前的默认分区。分区器直接决定了RDD 中分区的个数、RDD 中每条数据经过Shuffle 后进入哪个分区，进而决定了Reduce 的个数。
- 只有Key-Value 类型的RDD 才有分区器，非 Key-Value 类型的RDD 分区的值是 None
- 每个RDD 的分区 ID 范围：0 ~ (numPartitions - 1)，决定这个值是属于那个分区的。
用户自定义分区：
val rdd: RDD[(String, String)] = sc.makeRDD(List(
("nba", "xxxxxxxxx"),
("cba", "xxxxxxxxx"),
("wnba", "xxxxxxxxx"),
("nba", "xxxxxxxxx")
), 3)
val partRdd: RDD[(String, String)] = rdd.partitionBy(new MyPartitioner)
partRdd.saveAsTextFile("output")
class MyPartitioner extends Partitioner {
// 分区数量
override def numPartitions: Int = 3
// 根据数据的key值返回数据所在的分区索引（从0开始）
override def getPartition(key: Any): Int = {
key match {
case "nba" => 0
case "wnba" => 1
case _ => 2
}
}
}1.4.7 RDD 文件读取与保存
Spark 的数据读取及数据保存可以从两个维度来作区分：文件格式以及文件系统。文件格式分为：text 文件、csv 文件、sequence 文件以及Object 文件；
文件系统分为：本地文件系统、HDFS、HBASE 以及数据库。
- text 文件
// 读取输入文件
val inputRDD: RDD[String] = sc.textFile("input/1.txt")
// 保存数据
inputRDD.saveAsTextFile("output")- sequence 文件
SequenceFile 文件是Hadoop 用来存储二进制形式的key-value 对而设计的一种平面文件(Flat File)。在 SparkContext 中，可以调用sequenceFile[keyClass, valueClass](path)。
// 保 存 数 据 为 SequenceFile
dataRDD.saveAsSequenceFile("output")
// 读取 SequenceFile 文件
sc.sequenceFile[Int,Int]("output").collect().foreach(println)- object 对象文件
对象文件是将对象序列化后保存的文件，采用 Java 的序列化机制。可以通过objectFile[T: ClassTag](path)函数接收一个路径，读取对象文件，返回对应的 RDD，也可以通过调用saveAsObjectFile()实现对对象文件的输出。因为是序列化所以要指定类型。
// 保存数据
dataRDD.saveAsObjectFile("output")
// 读取数据
sc.objectFile[Int]("output").collect().foreach(println)
545
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
