RDD编程初级实践

RDD编程初级实践

spark-shell交互式编程

写在前面

• Linux：CentOS7.5
• Spark: spark-3.0.0-bin-hadoop3.2
• IDE：IntelliJ IDEA2020.2.3

数据集

数据集包含了某大学计算机系的成绩，数据格式如下所示：

Tom,DataBase,80
Tom,Algorithm,50
Tom,DataStructure,60
Jim,DataBase,90
Jim,Algorithm,60
Jim,DataStructure,80
……

请根据给定的实验数据，在spark-shell中通过编程来计算以下内容：

• 该系总共有多少学生；
• 该系共开设来多少门课程；
• Tom同学的总成绩平均分是多少；
• 求每名同学的选修的课程门数；
• 该系DataBase课程共有多少人选修；
• 各门课程的平均分是多少；
• 使用累加器计算共有多少人选了DataBase这门课。

代码

scala>val lines =sc.textFile("file:///export/server/spark-3.0.0-bin-hadoop3.2/mydata/data01.txt")
lines:org.apache.spark.rdd.RDD[String]file:///export/server/spark-3.0.0-bin-hadoop3.2/mydata/datae
scala>val par lines.map(row =row.split(",")(0))
par:org.apache.spark.rdd.RDD[String]MapPartitionsRDD[16]at map at <console>:25
scala>val distinct_par par.distinct()
distinct_par:org.apache.spark.rdd.RDD[String]MapPartitionsRDD[19]at distinct at <console>:25
scala>distinct par.count

程序执行结果：

res2:Long
265

scala>val par lines.map(row=>row.split(",")(1))
par:org.apache.spark.rdd.RDD[String]MapPartitionsRDD[20]at map at <console>:2
scala>val distinct par par.distinct()
distinct_par:org.apache.spark.rdd.RDD[String]MapPartitionsRDD[23]at distinct
scala>distinct par.count

程序执行结果：

res3:
ong 8

scala>val pare = lines.filter(row=>row.split(",")(0)=="Tom")
pare:org.apache.spark.rdd.RDD[String]MapPartitionsRDD[24]at filter at <console>:25
scala>pare.foreach(println)
Tom,DataBase,26
Tom,Algorithm,12
Tom,OperatingSystem,16
Tom,Python,40
Tom,Software,60
scala>pare.map(row=>(row.split(",")(0),row.split(",")(2).toInt)).mapValues (x=>(x,1)).reduceByKey((x,y) => (x._1+y._1,x._2+y._2)).mapValues(x => (x._1 / x._2)).collect()

程序执行结果：

res5:Array[(String,Int)]=Array((Tom,30))

scala>val pare = lines.map(row=>(row.split(",")(0),row.split(",")(1)))
pare:org.apache.spark.rdd.RDD[(String,String)]MapPartitionsRDD[39]at map at <console>:25
scala>pare.mapValues(x =(x,1)).reduceByKey((x,y)=>("",x._2 y._2)).mapValues(x =>x._2).foreach(println)

程序执行结果：

(Ford,3)
(Enoch,3)
(Kim,4)
(Conrad,2)
(Marvin,3)
(Michael,5)
(Ernest,5)
(Marsh,4)
(Duke,4)
(Armand,3)
(Lester,4)
(Broderick,3)
(Hayden,3)
(Bertram,3)
(Bart,5)
(Duncann,5)
(Colby,4)
(Ward,4)
(Chester,6)
(Webster,2)
(Marshall,4)
(Cliff,5)
(Emmanuel,3)
(Jerome,3)
(Upton,5)
(Corey,4)
(Perry,5)
(Herbert,3)
(Maurice,2)
(Drew,5)
(Brandon,5)
(Adolph,4)
(Levi,2)
(Bing,6)
(Antonio,3)
(Stan,3)
(Les,6)
(Charles,3)
(Clement,5)
(Blithe,3)
(Brian,6)
(Matt,4)
(Archibald,5)
(Horace,5)
(Sebastian,6)
(Verne,3)

scala>val pare = lines.filter(row=>row.split(",")(1)=="DataBase")
are:org.apache.spark.rdd.RDD[String]MapPartitionsRDD[49]at filter at <console>:
scala>pare.count

程序执行结果：

res13:Long = 126

scalas val pare = tines.map(row->(row.split(","1(1).row.split(",")(2).toInt])
pare:org.apache.spark.rdd.RDD[(String.Int)]MapPartitionsRDD[50]at map at <console>:25
scala>pare.mapValues{(x=>p(x,1)}.reduceByKey({x,y) => (x,_1+y,_1,x._2+y._2)}.mapValues(x=>{x,_1/x._2}).collect()

程序执行结果：

res14:Array[(String,Int)]=Array((Python,57),(Cperatingsystem,54).(CLanguage,50).(Software,5B).(ALgorithn,48),(Datastructure,47).(DataBase,50).(ComputerNetwork,51))

scala>val pare = lines.filter(row=>row.split(",")(1)=="DataBase").map(row=>(row.split(",")(1),1))
pare:org.apache.spark.rdd.RDD[(String,Int)]MapPartitionsRDD[55]at map at <console>:25
scala>val accum sc.LongAccumulator("My Accumulator")
accum:org.apache.spark.util.LongAccumulator LongAccumulator(id:400,name:Some(My Accumulator),value:0)
scala>pare.values.foreach(x =accum.add(x))
scala>accum.value

程序执行结果：

res16:Long = 126

编写独立应用程序实现数据去重

题目

对于两个输入文件A和B，编写Spark独立应用程序，对两个文件进行合并，并剔除其中重复的内容，得到一个新文件C。下面是输入文件和输出文件的一个样例，供参考。

样例

输入文件A的样例如下：

20170101 x

20170102 y

20170103 x

20170104 y

20170105 z

20170106 z

输入文件B的样例如下：

20170101 y

20170102 y

20170103 x

20170104 z

20170105 y

根据输入的文件A和B合并得到的输出文件C的样例如下：

20170101 x

20170101 y

20170102 y

20170103 x

20170104 y

20170104 z

20170105 y

20170105 z

20170106 z

import org.apache.spark.SparkContext
import org.apache.spark.SparkConf
import org.apache.spark.HashPartitioner
import org.apache.spark.rdd.RDD

object t2 {
    def main(args: Array[String]) {
        val conf: SparkConf = new SparkConf().setMaster("local[2]").setAppName("RemDup")
        val sc: SparkContext = new SparkContext(conf)

        val dataFile = "dataset/ch04/t2_data"
        val data: RDD[String] = sc.textFile(dataFile,2)

        val res: RDD[String] = data
          .filter(_.trim().length > 0)
          .map(line => (line.trim, ""))
          .partitionBy(new HashPartitioner(1))
          .groupByKey()
          .sortByKey()
          .keys
        res.foreach(println)
    }
}

程序执行结果

编写独立应用程序实现求平均值问题

每个输入文件表示班级学生某个学科的成绩，每行内容由两个字段组成，第一个是学生名字，第二个是学生的成绩；编写Spark独立应用程序求出所有学生的平均成绩，并输出到一个新文件中。下面是输入文件和输出文件的一个样例，供参考。

• Algorithm成绩：

小明 92

小红 87

小新 82

小丽 90

• Database成绩：

小明 95

小红 81

小新 89

小丽 85

• Python成绩：

小明 82

小红 83

小新 94

小丽 91

• 平均成绩如下：

(小红,83.67)

(小新,88.33)

(小明,89.67)

(小丽,88.67)

代码

import org.apache.spark.rdd.RDD
import org.apache.spark.{HashPartitioner, SparkConf, SparkContext}
object t3 {
    def main(args: Array[String]): Unit = {
        val conf: SparkConf = new SparkConf().setMaster("local[2]").setAppName("AvgScore")
        val sc: SparkContext = new SparkContext(conf)
        val dataFile = "dataset/ch04/t3_data"
        val data: RDD[String] = sc.textFile(dataFile,3)

        val res: RDD[(String, Double)] = data
          .filter(_.trim().length > 0)
          .map(line => (line.split(" ")(0).trim(), line.split(" ")(1).trim().toInt))
          .partitionBy(new HashPartitioner(1))
          .groupByKey()
          .map(x => {
              var n = 0
              var sum = 0.0
              for (i <- x._2) {
                  sum = sum + i
                  n = n + 1
              }
              val avg = sum / n
              val format = f"$avg%1.2f".toDouble
              (x._1, format)
          })
        res.foreach(println)
    }
}

程序执行结果

全文结束！！！