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基礎操作:有類型的轉換算子,無類型的轉換算子速查表

目錄標題