大数据分析 RDD 实训作业

1、统计在春季赛中LPL，击杀次数最多5支队伍----显示队伍的名称、以及队伍击杀数

2、统计在整个赛年，死亡次数最多5支队伍------显示队伍的名称、以及队伍死亡次数

3、统计在春季赛中，LCK赛区ban选英雄前五是英雄名，以及ban选的次数（ban pick）

4、统计在春季赛中，LPL赛区ban选英雄前五是英雄名，以及ban选的次数（ban pick）

5、分别统计春季赛和夏季赛中，LPL赛区，胜场次数的最多的三只队伍

6、统计在整个赛年中获取5杀队伍次数最多的2支队伍

7、统计在整个赛年中胜率超过6成的，排名前三队伍

8、统计在春季赛中，red方的胜率，以及夏季赛中Blue方的胜率

9、统计在春季赛中，LPL赛区参赛场次最多的两支队伍

10、简单对文件进行数据去重工作。

package org.JLNU

import org.apache.spark.rdd.RDD
import org.apache.spark.{SparkConf, SparkContext}

object LolSpark {
  def main(args:Array[String]): Unit = {
    //获取spark开发环境
    val conf: SparkConf = new SparkConf().setAppName("lol").setMaster("local[*]")
    //获取SparkContext对象
    val sc:SparkContext = new SparkContext(conf)
    //获取RDD
    val textFile: RDD[String]= sc.textFile("D:\\spark-local-data\\input\\lol.txt")

    //ans.foreach(println)

    //1、统计在春季赛中LPL,击杀次数最多5支队伍----显示队伍的名称、以及队伍击杀数
    val sum1 = textFile.filter(!_.contains("agt")).filter(_.contains("Spring")).filter(_.contains("LPL")).map(x=>{
      val arrs = x.split("\t")
      (arrs(9),arrs(17).toInt)
    }).reduceByKey((_+_) ).sortBy(_._2,false).take(5)

    //2、统计在整个赛年，死亡次数最多5支队伍------显示队伍的名称、以及队伍死亡次数
    val sum2 = textFile.filter(!_.contains("agt")).map(x=>{
      val arrs = x.split("\t")
      (arrs(9),arrs(18).toInt)
    }).reduceByKey((_+_) ).sortBy(_._2,false).take(5)

    //3、统计在春季赛中，LCK赛区ban选英雄前五是英雄名，以及ban选的次数（ban pick）
    val sum3 = textFile.filter(!_.contains("agt")).filter(_.contains("Spring")).filter(_.contains("LCK")).map(x => {
      val array = x.split("\t")
      array(10)+","+array(11)+","+array(12)+","+array(13)+","+array(14)
    }).flatMap(_.split(",")).map((_,1)).reduceByKey(_+_).sortBy(_._2,false).take(5)

    //4、统计在春季赛中，LPL赛区ban选英雄前五是英雄名，以及ban选的次数（ban pick）
    val sum4 = textFile.filter(!_.contains("agt")).filter(_.contains("Spring")).filter(_.contains("LPL")).map(x => {
      val array = x.split("\t")
      array(10)+","+array(11)+","+array(12)+","+array(13)+","+array(14)
    }).flatMap(_.split(",")).map((_,1)).reduceByKey(_+_).sortBy(_._2,false).take(5)
    sum4.foreach(println)

    //5.1、统计春季赛中，LPL赛区，胜场次数的最多的三只队伍
    val sum51=textFile.filter(!_.contains("agt")).filter(_.contains("Spring")).filter(_.contains("LPL")).map(x => {
      val array = x.split("\t")
      (array(9),array(16).toInt)
    }).reduceByKey(_+_).sortBy(_._2,false).take(3)

    //5.2、统计夏季赛中，LPL赛区，胜场次数的最多的三只队伍
    val sum52=textFile.filter(!_.contains("agt")).filter(_.contains("Summer")).filter(_.contains("LPL")).map(x => {
      val array = x.split("\t")
      (array(9),array(16).toInt)
    }).reduceByKey(_+_).sortBy(_._2,false).take(3)

    //6、 整个赛年中，五杀最多的2支队伍
    val sum6 = textFile.filter(!_.contains("agt")).map(x=>{
      val arrs = x.split("\t")
      (arrs(9),arrs(23).toInt)
    } ).reduceByKey((_+_) ).sortBy(_._2,false).take(2)
    //sc.parallelize(sum6).repartition( 1).saveAsTextFile( path = "D:\\spark-local-data\\output\\out5")

    //7、统计在整个赛年中省略超过6成的，排名前三队伍
    val sum7 = textFile.filter(!_.contains("agt")).map(x => {
      val array = x.split("\t")
      (array(9), 1)
    }).reduceByKey((_ + _))
    val win = textFile.filter(!_.contains("agt")).filter(x => {
      val arrs = x.split("\t")
      arrs(16).toInt == 1
    }).map(x => {
      val array = x.split("\t")
      (array(9), 1)
    }).reduceByKey((_ + _))
    val takeThree0 = win.join(sum7).map(x=>{
      (x._1,100*x._2._1/x._2._2)
    }).filter(x=>{
      x._2>=60
    }).sortBy(_._2,false).map(x=>{
      x._1+" : "+x._2+"%"
    }).take(3)

    //8.1、 春季赛中Red方的胜率
    val sum81 = textFile.filter(!_.contains("agt")).filter(_.contains("Spring")).filter( _.contains("Red")).map(x=>{
      val arrs=x.split("\t")
      (arrs(8),1)
    } ).reduceByKey((_+_))
    val win1 = textFile.filter(!_.contains("agt")).filter(_.contains("Spring")).filter(_.contains("Red")).filter(x=>{
      val arrs = x.split("\t")
      arrs(16).toInt==1
    }).map(x=>{
      val arrs=x.split("\t")
      (arrs(8),1)
    }).reduceByKey((_+_))
    val takeThree1 = win1.join(sum81).map(x=>{
      (x._1,100*x._2._1/x._2._2+"%")
    }).take(1)
    //sc.parallelize(takeThree1).repartition( numPartitions = 1).saveAsTextFile( path = "D:\\spark-local-data\\output\\out1")

    //8.2、 夏季赛中Blue方的胜率
    val sum82 = textFile.filter(!_.contains("agt")).filter(_.contains("Summer")).filter( _.contains("Blue")).map(x=>{
      val arrs = x.split("\t")
      (arrs(8),1)
    } ).reduceByKey((_+_))
    val win2 = textFile.filter(!_.contains("agt")).filter(_.contains("Summer")).filter(_.contains("Blue")).filter(x=>{
      val arrs = x.split("\t")
      arrs(16).toInt==1
    }).map(x=>{
      val arrs=x.split("\t")
      (arrs(8),1)
    }).reduceByKey((_+_))
    val takeThree2 = win2.join(sum82).map(x=>{
      (x._1,100*x._2._1/x._2._2+"%")
    }).take(1)
    //sc.parallelize(takeThree2).repartition( numPartitions = 1).saveAsTextFile( path = "D:\\spark-local-data\\output\\out2")

    //9、  春季赛中LPL赛区参赛场次最多的两只队伍
    val sum9 = textFile.filter(!_.contains("agt")).filter(_.contains("Spring")).filter(_.contains("LPL")).map(x=>{
      val arrs = x.split("\t")
      (arrs( 9),1)
    }).reduceByKey((_+_) ).sortBy(_._2,false).take(2)
    //sc.parallelize(sum3).repartition(1).saveAsTextFile( path= "D:\\spark-local-data\\output\\out3")

    //10、  红队春季赛LPl赛区，首杀总数
    val sum10 = textFile.filter(!_.contains("agt")).filter(_.contains("Spring")).filter( _.contains("Red")).filter( _.contains("LPL")).map(x=>{
      val arrs=x.split("\t")
      ("红队首杀总数：",arrs(24).toInt)
    } ).reduceByKey((_+_) ).take(1)
    //sc.parallelize(sum10).repartition( 1).saveAsTextFile( path = "D:\\spark-local-data\\output\\out4")

    //11、   春季赛LPL赛区，四杀最多的三支队伍
    val sum11 = textFile.filter(!_.contains("agt")).filter(_.contains("Spring")).filter( _.contains("LPL")).map(x=>{
      val arrs = x.split("\t")
      (arrs(9),arrs(22).toInt)
    } ).reduceByKey((_+_) ).sortBy(_._2,false).take( 3)
    //sc.parallelize(sum11).repartition( 1).saveAsTextFile( path = "D:\\spark-local-data\\output\\out5")


    //12、  统计首杀次数最多的队伍前三名的总游戏时间
    val sum12 = textFile.filter(!_.contains("agt")).map(x=>{
      val arrs = x.split("\t")
      (arrs( 9),arrs(24).toInt)
    }).reduceByKey((_+_) )
    val time = textFile.filter(!_.contains("agt")).map(x=>{
      val arrs = x.split("\t")
      (arrs( 9),arrs(15).toInt)
      }).reduceByKey((_+_))
      val take = sum12.join(time).map( x=> {
        (x._1,x._2)
      }).sortBy(_._2,false).map(x=>{
        x._1 + " 游戏时长： " + x._2
      }).take(3)
    //sc.parallelize(take).repartition(1).saveAsTextFile( path= "D:\\spark-local-data\\output\\out6")

    //13、  计算总参赛次数最多的队伍的总KD比
    val team = textFile.filter(!_.contains("agt")).map(x=>{
      val arrs = x.split("\t")
      (arrs(9),1)
    }).reduceByKey((_+_) ).sortBy(_._2,false).take( 1)
    val tem = team(0)._1
    val killsum = textFile.filter(!_.contains("agt")).filter(_.contains(tem)).map(x=>{
      val arrs = x.split("\t")
      (arrs( 9),arrs(17).toInt)
    }).reduceByKey((_+_))
    val deathsum = textFile.filter(!_.contains("agt")).filter(_.contains(tem)).map(x=>{
      val arrs = x.split("\t")
      (arrs( 9),arrs(18).toInt)
    }).reduceByKey((_+_))
    val sum13 = killsum.join(deathsum).map(x=>{
      (x._1,(x._2._1 * 1.0)/(x._2._2 * 1.0))
    }).take(1)
    //sc.parallelize(sum13).repartition(1).saveAsTextFile( path= "D:\\spark-local-data\\output\\out7")

    //14、  统计在春季赛中LCK,死亡次数最多的2支队伍
    val sum14 = textFile.filter(!_.contains("agt")).filter(_.contains("Spring")).filter(_.contains("LCK")).map(x=>{
      val arrs = x.split("\t")
      (arrs(9),arrs(18).toInt)
    }).reduceByKey((_+_) ).sortBy(_._2,false).take( 2)
    //sc.parallelize(sum14).repartition(1).saveAsTextFile( path= "D:\\spark-local-data\\output\\out8")

    Thread.sleep(500)

    println("======================")
    println("1、统计在春季赛中LPL,击杀次数最多5支队伍")
    sum1.foreach(println)

    println("======================")
    println("2、统计在整个赛年，死亡次数最多5支队伍")
    sum2.foreach(println)

    println("======================")
    println("3、统计在春季赛中，LCK赛区ban选英雄前五是英雄名，以及ban选的次数（ban pick）")
    sum3.foreach(println)

    println("======================")
    println("4、统计在春季赛中，LPL赛区ban选英雄前五是英雄名，以及ban选的次数（ban pick）")
    sum4.foreach(println)

    println("======================")
    println("5.1、统计春季赛中，LPL赛区，胜场次数的最多的三只队伍")
    sum51.foreach(println)

    println("======================")
    println("5.2、统计夏季赛中，LPL赛区，胜场次数的最多的三只队伍")
    sum52.foreach(println)

    println("======================")
    println("6、整个赛年中，五杀最多的2支队伍")
    sum6.foreach(println)

    println("======================")
    println("7、统计在整个赛年中省略超过6成的，排名前三队伍")
    takeThree0.foreach(println)

    println("======================")
    println("8.1、春季赛中Red方的胜率")
    takeThree1.foreach(println)

    println("======================")
    println("8.2、夏季赛中Blue方的胜率")
    takeThree2.foreach(println)

    println("======================")
    println("9、春季赛中LPL赛区参赛场次最多的两只队伍")
    sum9.foreach(println)

    println("======================")
    println("10、红队春季赛LPl赛区，首杀总数")
    sum10.foreach(println)

    println("======================")
    println("11、春季赛LPL赛区，四杀最多的三支队伍 ")
    sum11.foreach(println)

    println("======================")
    println("12、统计首杀次数最多的队伍前三名的总游戏时间")
    take.foreach(println)

    println("======================")
    println("13、计算总参赛次数最多的队伍的总KD比")
    sum13.foreach(println)

    println("======================")
    println("14、统计在春季赛中LCK,死亡次数最多的2支队伍")
    sum14.foreach(println)
    println("======================")

    //15、简单去重
    sc.textFile("D:\\study\\idealU\\inputdata\\lol.txt").distinct().repartition(1).saveAsTextFile("D:\\study\\idealU\\outputdata\\out10")
  }
}