1.有类型的转换算子

(1)转换

1.flatMap

通过 flatMap 可以将一条数据转为一个数组, 后再展开这个数组放入 Dataset

import spark.implicits._
val ds = Seq("hello world", "hello pc").toDS()
ds.flatMap( _.split(" ") ).show()

2.map

map 可以将数据集中每条数据转为另一种形式

import spark.implicits._
val ds = Seq(Person("zhangsan", 15), Person("lisi", 15)).toDS()
ds.map( person => Person(person.name, person.age * 2) ).show()

3.mapPartitions

mapPartitions 和 map 一样, 但是 map 的处理单位是每条数据, mapPartitions 的处理单位是每个分区
使用它可以增进map的执行效率.但是使用的前提条件是内存能一次性的容纳整个分区的数据,否则是不可以使用mapPartitions的

import spark.implicits._
val ds = Seq(Person("zhangsan", 15), Person("lisi", 15)).toDS()
ds.mapPartitions( iter => {//接收的是一个数据集合,我们要对数据集内每个元素进行转换操作后再生成一个新的数据集合
    val returnValue = iter.map(
      item => Person(item.name, item.age * 2)
    )
    returnValue
  } )
  .show()

4.transform

map 和 mapPartitions 以及 transform 都是转换, map 和 mapPartitions 是针对数据, 而 transform 是针对整个数据集, 这种方式最大的区别就是 transform 可以直接拿到 Dataset 进行操作

import spark.implicits._
val ds = spark.range(5)
ds.transform( dataset => dataset.withColumn("doubled", 'id * 2) )

5.as

as[Type] 算子的主要作用是将弱类型的 Dataset 转为强类型的 Dataset, 它有很多适用场景, 但是最常见的还是在读取数据的时候, 因为 DataFrameReader 体系大部分情况下是将读出来的数据转换为 DataFrame 的形式, 如果后续需要使用 Dataset 的强类型 API, 则需要将 DataFrame 转为 Dataset. 可以使用 as[Type] 算子完成这种操作

class asDemo {

  @Test
  def operationHive(): Unit = {
    //1.创建sparkSession
    val spark = SparkSession
      .builder()
      .master("local[4]")
      .appName("as example")
      .getOrCreate()
import spark.implicits._
//读取
val structType = StructType(
  Seq(
    StructField("name", StringType),
    StructField("age", IntegerType),
    StructField("gpa", FloatType)
  )
)

val sourceDF = spark.read
  .schema(structType)
  .option("delimiter", "\t")
  .csv("dataset/studenttab10k")
//转换
val dataset:Dataset[Stuent] = sourceDF.as[Student]
//输出
dataset.show()
	}
}
case class Student(name:String,age:Int,gpa:Float)

(2)过滤

1.filter

filter 用来按照条件过滤数据集

import spark.implicits._
val ds = Seq(Person("zhangsan", 15), Person("lisi", 15)).toDS()
ds.filter( person => person.name == "lisi" ).show()

(3)聚合

1.groupByKey

grouByKey 算子的返回结果是 KeyValueGroupedDataset, 而不是一个 Dataset, 所以必须要先经过 KeyValueGroupedDataset 中的方法进行聚合, 再转回 Dataset, 才能使用 Action 得出结果
其实这也印证了分组后必须聚合的道理

import spark.implicits._
val ds = Seq(Person("zhangsan", 15), Person("zhangsan", 15), Person("lisi", 15)).toDS()
ds.groupByKey( person => person.name ).count().show() //分组是必须要进行聚合的

(4)切分

1.randomSplit

randomSplit 会按照传入的权重随机将一个 Dataset 分为多个 Dataset, 传入 randomSplit 的数组有多少个权重, 最终就会生成多少个 Dataset, 这些权重的加倍和应该为 1, 否则将被标准化

val ds = spark.range(15)
val datasets: Array[Dataset[lang.Long]] = ds.randomSplit(Array[Double](2, 3))
datasets.foreach(dataset => dataset.show())

因为传入的数组有两个数,所以有两个权重,把0-15的ds随机变为2个ds

2.sample

sample 会随机在 Dataset 中抽样

val ds = spark.range(15)
ds.sample(withReplacement = false, fraction = 0.4).show()

不放回,随机抽取数据的40%

(5)排序

1.ordweBy,别名sort功能一样名称不同

orderBy 配合 Column 的 API, 可以实现正反序排列

import spark.implicits._
val ds = Seq(Person("zhangsan", 12), Person("zhangsan", 8), Person("lisi", 15)).toDS()
ds.orderBy("age".asc).show()
ds.orderBy('age.desc).show()

desc:从大到下,降序
asc:由小到大,升序

(6)分区

1.coalesce

减少分区, 此算子和 RDD 中的 coalesce 不同, Dataset 中的 coalesce 只能减少分区数, coalesce 会直接创建一个逻辑操作, 并且设置 Shuffle 为 false

val ds = spark.range(15)
ds.coalesce(1).explain(true)

2.repartitions

repartitions 有两个作用, 一个是重分区到特定的分区数, 另一个是按照某一列来分区, 类似于 SQL 中的 DISTRIBUTE BY

val ds = Seq(Person("zhangsan", 12), Person("zhangsan", 8), Person("lisi", 15)).toDS()
ds.repartition(4)
ds.repartition('name)

(7)去重

1.dropDuplicates

使用 dropDuplicates 可以去掉某一些列中重复的行

import spark.implicits._
val ds = spark.createDataset(Seq(Person("zhangsan", 15), Person("zhangsan", 15), Person("lisi", 15)))
ds.dropDuplicates("name").show()

2.distinct

当 dropDuplicates 中没有传入列名的时候, 其含义是根据所有列去重, dropDuplicates() 方法还有一个别名, 叫做 distinct
所以, 使用 distinct 也可以去重, 并且只能根据所有的列来去重

import spark.implicits._
val ds = spark.createDataset(Seq(Person("zhangsan", 15), Person("zhangsan", 15), Person("lisi", 15)))
ds.distinct().show()

(8)集合操作

1.except

except 和 SQL 语句中的 except 一个意思, 是求得 ds1 中不存在于 ds2 中的数据, 其实就是差集

val ds1 = spark.range(1, 10)
val ds2 = spark.range(5, 15)

ds1.except(ds2).show()

2.intersect

求得两个集合的交集

val ds1 = spark.range(1, 10)
val ds2 = spark.range(5, 15)

ds1.intersect(ds2).show()

3.union

求得两个集合的并集

val ds1 = spark.range(1, 10)
val ds2 = spark.range(5, 15)

ds1.union(ds2).show()

4.limit

限制结果集数量

val ds = spark.range(1, 10)
ds.limit(3).show()

2.无类型的算子

主要是操作列

(1)选择

1.select

select 用来选择某些列出现在结果集中

import spark.implicits._
val ds = Seq(Person("zhangsan", 12), Person("zhangsan", 8), Person("lisi", 15)).toDS()
ds.select($"name").show()

2.selectExpr

在 SQL 语句中, 经常可以在 select 子句中使用 count(age), rand() 等函数, 在 selectExpr 中就可以使用这样的 SQL 表达式, 同时使用 select 配合 expr 函数也可以做到类似的效果

import spark.implicits._
import org.apache.spark.sql.functions._
val ds = Seq(Person("zhangsan", 12), Person("zhangsan", 8), Person("lisi", 15)).toDS()
ds.selectExpr("count(age) as count").show()
ds.selectExpr("rand() as random").show()
ds.select(expr("count(age) as count")).show()

3.withColumn

通过 Column 对象在 Dataset 中创建一个新的列或者修改原来的列

import spark.implicits._
import org.apache.spark.sql.functions._
val ds = Seq(Person("zhangsan", 12), Person("zhangsan", 8), Person("lisi", 15)).toDS()
ds.withColumn("random", expr("rand()")).show()
ds.withColumn("name_new",'name).show
ds.withColumn("name_new",'name === "").show //这里可以使用===""来判断name列内容是否为空

4.withColumnRenamed

修改列名

import spark.implicits._
val ds = Seq(Person("zhangsan", 12), Person("zhangsan", 8), Person("lisi", 15)).toDS()
ds.withColumnRenamed("name", "new_name").show()

(2)剪除drop

剪掉某个列

import spark.implicits._
val ds = Seq(Person("zhangsan", 12), Person("zhangsan", 8), Person("lisi", 15)).toDS()
ds.drop('age).show()

(3)聚合groupBy

按照给定的行进行分组

import spark.implicits._
val ds = Seq(Person("zhangsan", 12), Person("zhangsan", 8), Person("lisi", 15)).toDS()
ds.groupBy('name).count().show()

大数据组件-sparkSQL:DataSet基础操作:有类型的转换算子,无类型的转换算子速查表

目录标题