sparkRDD教程之基本命令

作者：nchu可乐百香果

指导者：nchu-YoungDragon

1.前期准备

（1）从迅雷网盘上面下载这个项目，并且把scala，maven和java环境配置好

网盘链接：

分享文件：SparkRDD.zip

链接：https://pan.xunlei.com/s/VOGUwt7hVp1ZQB6V7n1j6e70A1?pwd=q87r#

复制这段内容后打开迅雷，查看更方便

打开项目后，其目录结构如下：

（2）新建一个scala object文件 （点击新建scala文件后选择第三个选项object）

固定模版

.appName("task5"),这个名字建议改为自己当前的文件名

package com.itheima

import org.apache.spark.sql.SparkSession


object task5 {
  def main(args: Array[String]): Unit = {
    // 创建SparkSession
    val spark = SparkSession
      .builder
      .appName("task5")
      .master("local")
      .getOrCreate()
    val sc = spark.sparkContext
    //在这里写代码
    

    spark.stop()
  }

}

2.sparkRDD的基本命令

x._1表示元组的第一项（从1开始数这里，反正这样的写法是从1开始数的）

当然，x(0)是从0开始数的

（1）创建sparkRDD和打印输出

第一种方式

    val rdd1=sc.parallelize(List(1,2,3,4))
    println(rdd1.collect().mkString("\n"))

结果

第二种方式

    val rdd2=sc.makeRDD(List(1,2,3,4))
    println(rdd2.collect().mkString("\n"))

结果

第三种方式

    var score_path="src\\main\\resources\\score.txt"
    val rdd3=sc.textFile(score_path)
    println(rdd3.collect().mkString("\n"))

score.txt

student_id,course_code,score
108,3-105,99
105,3-105,88
107,3-105,77
105,3-245,87
108,3-245,89
107,3-245,82
106,3-245,74
107,6-101,75
108,6-101,82
106,6-101,65
109,6-102,99
101,6-102,79
105,9-106,81
106,9-106,97
107,9-106,65
108,9-106,100
109,9-106,82
105,6-102,85

（2）map命令

代码1

    var rdd1=sc.parallelize(List(1,2,3,4))
    var res1=rdd1.map(x=>x*x*x)
    println(res1.collect().mkString("\n"))

结果 1

代码2

    var rdd2=sc.parallelize(List("a","b","c"))
    var res2=rdd2.map(x=>(x,1))
    println(res2.collect().mkString("\n"))

结果2

（3）flatmap命令（这个用起来有一些限制，所以使用的很少，我感觉不太好用，不如map简单直接）

代码 1

    val rdd2 = sc.parallelize(List("a b c", "d e f", "g h i"))
    val map_res = rdd2.map(x => x.split(" "))
    println(map_res.collect().mkString("\n"))

    val flatMap_res = rdd2.flatMap(x => x.split(" "))
    println(flatMap_res.collect().mkString("\n"))

结果1

（4）sortBy命令（默认值是true，表示升序排序）

代码1

    val rdd = sc.parallelize(List('a','b','c','d','e'))
    val res = rdd.map(x =>(x,1)).sortBy(x=>x._1, true)//true可以省略
    println(res.collect().mkString("\n"))

截图1

代码2

    val rdd = sc.parallelize(List('a','b','c','d','e'))
    val res = rdd.map(x =>(x,1)).sortBy(x=>x._1, false)
    println(res.collect().mkString("\n"))

截图2

代码3

    val rdd = sc.parallelize(1 to 10)
    val res = rdd.map(x =>(x,1)).sortBy(x=>x._1, false)
    println(res.collect().mkString("\n"))

截图3

（5）filter命令（满足条件的留下来，和sql中的where命令类似）

代码1

    val rdd = sc.parallelize(1 to 10)
    val res = rdd.filter(x=>x<=5)
    println(res.collect().mkString("\n"))

截图1

代码2

    val rdd = sc.parallelize(1 to 10)
    val res = rdd.filter(x=>x>=3 && x<=5)
    println(res.collect().mkString("\n"))

截图2

（6）distinct命令（去重）

代码1

    val rdd = sc.parallelize(List(1,2,2,3,3))
    val res = rdd.distinct()
    println(res.collect().mkString("\n"))

截图1

（7）union命令（类似于求并集，但是不会自动去重）

代码1

    val rdd1 = sc.parallelize(List(1,2,3,4))
    val rdd2 = sc.parallelize(List(3,4,5,6))
    val res = rdd1.union(rdd2)
    println(res.collect().mkString("\n"))

截图1

（8）intersection（类似于求交集）

代码1

    val rdd1 = sc.parallelize(List(1,2,3,4))
    val rdd2 = sc.parallelize(List(3,4,5,6))
    val res = rdd1.intersection(rdd2)
    println(res.collect().mkString("\n"))

截图1

（9）subtract（类似于求差集）

代码1

    val rdd1 = sc.parallelize(List(1,2,3,4))
    val rdd2 = sc.parallelize(List(3,4,5,6))
    val res1_2 = rdd1.subtract(rdd2)
    println(res1_2.collect().mkString("\n"))

截图1

代码2

    val rdd1 = sc.parallelize(List(1,2,3,4))
    val rdd2 = sc.parallelize(List(3,4,5,6))
    val res2_1 = rdd2.subtract(rdd1)
    println(res2_1.collect().mkString("\n"))

截图2

（10）cartesion（求笛卡尔积）

代码1

    val rdd1 = sc.parallelize(List(1,2,3,4))
    val rdd2 = sc.parallelize(List(3,4,5,6))
    val res = rdd1.cartesian(rdd2)
    println(res.collect().mkString("\n"))

截图1

（11）keyBy命令

代码1-3的前期准备，初始化rdd

val rdd = sc.parallelize(List('a','b','c','d','e'))

代码1

    val res1 = rdd.map(x => (1, 2, x)).keyBy(x => x._1)
    println(res1.collect().mkString("\n"))

截图1

代码2

    val res2 = rdd.map(x => (1, 2, x)).keyBy(x => x._2)
    println(res2.collect().mkString("\n"))

截图2

代码3

    val res3 = rdd.map(x => (1, 2, x)).keyBy(x => x._3)
    println(res3.collect().mkString("\n"))

截图3

总结

    val rdd = sc.parallelize(List('a', 'b', 'c', 'd', 'e'))
    val res1 = rdd.map(x => (1, 2, x)).keyBy(x => x._1)
    val res11 = rdd.map(x => (1, 2, x)).map(x=>(x._1,x)) //这2行代码等价
    println(res1.collect().mkString("\n"))
    println(res11.collect().mkString("\n"))

（12）mapValues（对所有值进行相同的操作，同时要求是二元组结构）

代码1

    val rdd = sc.parallelize(List('a', 'b', 'c', 'd', 'e'))
    val rdd2=rdd.map(x=>(x,1))
    println(rdd2.collect().mkString("\n"))

截图1 （显然此时它们的value都为1）

代码2

    val rdd = sc.parallelize(List('a', 'b', 'c', 'd', 'e'))
    val rdd2=rdd.map(x=>(x,1)).mapValues(x=>x*20)
    println(rdd2.collect().mkString("\n"))

截图2

（13）reduceByKey（对相同键的值进行操作，同时要求是二元组结构）

代码1

    val rdd = sc.parallelize(List('a', 'b', 'c', 'd', 'e'))
    val rdd2=rdd.map(x=>(x,1)).mapValues(x=>x*20)
    var rdd4=rdd2.union(rdd2).union(rdd2)
    println(rdd4.collect().mkString("\n"))

截图1

代码2

    val rdd = sc.parallelize(List('a', 'b', 'c', 'd', 'e'))
    val rdd2=rdd.map(x=>(x,1)).mapValues(x=>x*20)
    var rdd4=rdd2.union(rdd2).union(rdd2)
    var rdd5=rdd4.reduceByKey((y1,y2)=>(y1+y2))
    println(rdd5.collect().mkString("\n"))

截图2

（14）groupBy命令（我感觉使用的不多，了解即可）

代码1

    val rdd = sc.parallelize(0 to 9)
    val rdd2=rdd.groupBy(x=>{if( x % 2==0) "even" else "odd" })
    println(rdd2.collect().mkString("\n"))

截图1

（15）groupByKey命令（我感觉使用的不多，了解即可）

代码1

    val rdd = sc.parallelize(List(('a',1),('b',2),('c',3)))
    val rdd1 = sc.parallelize(List(('a',4),('b',5),('c',6)))
    val rdd2=rdd.union(rdd1)
    println(rdd2.collect().mkString("\n"))

截图1

代码2

    val rdd = sc.parallelize(List(('a',1),('b',2),('c',3)))
    val rdd1 = sc.parallelize(List(('a',4),('b',5),('c',6)))
    val rdd2=rdd.union(rdd1).groupByKey()
    println(rdd2.collect().mkString("\n"))

截图2

（16）join命令

代码1

    val rdd1 = sc.parallelize(List(("K1", "V1"), ("K2", "V2"), ("K3", "V3")))
    val rdd2 = sc.parallelize(List(("K1", "V2"), ("K2", "V3"), ("K4", "V4")))
    var join1 = rdd1.join(rdd2)
    println(join1.collect().mkString("\n"))

截图1

代码2 （利用其他方法来实现和join类似的效果）

    val rdd1 = sc.parallelize(List(("K1", "V1"), ("K2", "V2"), ("K3", "V3")))
    val rdd2 = sc.parallelize(List(("K1", "V2"), ("K2", "V3"), ("K4", "V4")))
    var res2 = rdd1.union(rdd2)
      .mapValues(x => (x, "V"))
      .reduceByKey((y1, y2) => (y1._1, y2._1))
      .filter(x => x._2._2 != "V")
      .sortBy(x => x._1)
    
    println(res2.collect().mkString("\n"))

截图2

（17）zip命令

代码1

    var rdd3=sc.makeRDD(1 to 5)
    var rdd4=sc.makeRDD(List('a','b','c','d','e'))
    var res3_4=rdd3.zip(rdd4)
    println(res3_4.collect().mkString("\n"))

截图1

代码2

    var rdd3 = sc.makeRDD(1 to 5)
    var rdd4 = sc.makeRDD(List('a', 'b', 'c', 'd', 'e'))
    var res4_3=rdd4.zip(rdd3)
    println(res4_3.collect().mkString("\n"))

截图2

（18）其他命令

3.总结一下

（1）第一点，也是重点

x._1表示元组的第一项（从1开始数这里，反正这样的写法是从1开始数的）

当然，x(0)是从0开始数的

count命令的返回值long类型，这一点要注意，经常需要使用toInt来转Int

（2）join命令的等价替换

这个其实主要还是为了方便自己更好理解这些命令

求点赞求收藏求关注

作者：nchu可乐百香果

指导者：nchu-YoungDragon