Spark算子---实战应用

Spark算子实战应用

数据集 ：http://grouplens.org/datasets/movielens/ MovieLens 1M Datase

相关数据文件 ：

users.dat ---UserID::Gender::Age::Occupation::Zip-code

movies.dat --- MovieID::Title::Genres

ratings.dat ---UserID::MovieID::Rating::Timestamp

SogouQ.mini

完成以下业务需求：

1. 年龄段在“18-24”的男性年轻人，最喜欢看哪10部

2.得分最高的10部电影；看过电影最多的前10个人；女性看多最多的10部电影；男性看过最多 的10部电影

3.利用数据集SogouQ2012.mini.tar.gz 将数据按照访问次数进行排序，求访问量前10的网站

scala实现代码如下：

package hw3
import org.apache.spark._

import scala.collection.immutable.HashSet
import org.apache.spark.rdd.RDD
/**
 * @author BIGDATA
 */
object spark_hw3{
  var sc:SparkContext=null
  def main(args: Array[String]): Unit = {
    val conf=new SparkConf().setAppName("MovieDemo")
              .setMaster("local")
    sc=new SparkContext(conf)
　　//准备数据
     val rating=sc.textFile("C:\\Users\\BIGDATA\\Desktop\\文件\\BigData\\Spark\\3.SparkCore_2\\data\\data\\ratings.dat")
              .map(_.split("::")).map {x => (x(0),x(1),x(2))}
　　//年龄段在“18-24”的男性年轻人，最喜欢看哪10部
    top10LookeMovie

　　//得分最高的10部电影
    val topKScoreMostMovie = rating.map{x =>
      (x._2, (x._3.toInt, 1))
    }.reduceByKey { (v1, v2) =>
      (v1._1 + v2._1, v1._2 + v2._2)
    }.map { x =>
      (x._2._1.toDouble / x._2._2.toDouble, x._1)
    }.sortByKey(false).
        take(10).
        foreach(println)
    
　　　//女性看最多的10部电影
    top10FaleLookMovie

　　//男性看最多的10部电影

    top10MaleLookMovie 

　　//看过电影最多的前10个人
    val topKmostPerson = rating.map{ x =>
      (x._1, 1)
    }.reduceByKey(_ + _).
        map(x =>(x._2, x._1)).
        sortByKey(false).
        take(10).
        foreach(println)

     val brower = sc.textFile("C:\\Users\\BIGDATA\\Desktop\\文件\\BigData\\Spark\\3.SparkCore_2\\SogouQ2012.mini\\SogouQ.mini")
     val brs=brower.map(_.split("\t")).map { x =>
          x(5)
    }.cache

    //访问量前10的网站
     val topKBrower = brs.flatMap(_.split(" ")).map((_, 1)).reduceByKey(_+_)
    .sortBy(_._2, false)
    .take(10)
    .foreach(println)

  }

  /**
    * @param sc SparkContext对象
    * @return 返回用户信息
    */
  def getUsers(sc:SparkContext):RDD[Array[String]]={
    val scobj=sc
    val users=scobj.textFile("C:\\Users\\BIGDATA\\Desktop\\文件\\BigData\\Spark\\3.SparkCore_2\\data\\data\\users.dat")
                  .map(_.split("::"))
    users
  }

  /**
    * @param sc
    * @return 返回电影信息
    */
  def getMovies(sc:SparkContext):RDD[Array[String]]={
    val scobj=sc
    val movies=scobj.textFile("C:\\Users\\BIGDATA\\Desktop\\文件\\BigData\\Spark\\3.SparkCore_2\\data\\data\\movies.dat")
                .map(_.split("::"))
    movies
  }

  /**
    *
    * @param sc
    * @return 电影评分信息
    */
  def getRatings(sc:SparkContext):RDD[Array[String]]={
    val scobj=sc
    val ratings=scobj.textFile("C:\\Users\\BIGDATA\\Desktop\\文件\\BigData\\Spark\\3.SparkCore_2\\data\\data\\ratings.dat")
              .map(_.split("::"))
    ratings
  }
  def top10LookeMovie: Unit ={
    //获取年龄段在“18-24”的男性年轻人的userid
    val users=getUsers(sc)
    val userList=users.filter(x=>x(1).equals("M") && x(2).toInt>=18 && x(2).toInt<=24)
      .map(x=>x(0)).collect()
    //注意：HashSet()后面要带小括号
    val userSet=HashSet() ++ userList
    //创建广播变量
    val broadcastUserSet=sc.broadcast(userSet)
    //统计出１８－２４岁男性喜欢看的前１０名电影的movieid和次数
    val ratings=getRatings(sc)
    val topNMovies=ratings.map(x=>(x(0),x(1))) //ratings中所有的(userid,movieid)
      //从rating数据过滤出“18-24”的男性年轻人的观影信息
      .filter(x=>broadcastUserSet.value.contains(x._1))
      .map(x=>(x._2,1))
      .reduceByKey(_+_) //(movieid,次数)
      .sortBy(_._2,false)
      .take(10) //(movieid,次数)

    val movies=getMovies(sc)
    //获取所有电影的(movieid,title)
    val movieTitle=movies.map(x=>(x(0),x(1))).collect().toMap
    topNMovies.map(x=>(movieTitle.getOrElse(x._1,null),x._2))
      .foreach(x=>println(x._1+"  "+x._2))
  }

  /**
    * 女性看过最多的10部电影
    */
  def top10FaleLookMovie: Unit ={
    val users = getUsers(sc)
    //获取所有女性的userid
    val faleUserId = users.filter(x => x(1).equals("F"))
      .map(x => x(0)).collect()
    val faleUserSet = HashSet() ++ faleUserId
    //创建广播变量，里面存储所有女性的userid
    val broadcastFaleSet = sc.broadcast(faleUserSet)

    val ratings = getRatings(sc)
    //统计出女性看过最多的１０部电影的(movieid,观看次数)
    val top10moiveid = ratings.map(x => (x(0), x(1))) //(userid,movieid)
      //过滤出女性观影数据
      .filter(x => broadcastFaleSet.value.contains(x._1))
      .map(x => (x._2, 1)) //(movieid,1)
      .reduceByKey(_ + _)
      .sortBy(_._2, false)
      .take(10)
    val top10movieRDD=sc.parallelize(top10moiveid) //(movieid,次数)

    val movies=getMovies(sc)
    val allmoviesRDD=movies.map(x=>(x(0),x(1))) //(movieid,title)
    //对两个ＲＤＤ进行join操作，取二者的共同匹配项
    allmoviesRDD.join(top10movieRDD) //(movieid,(title,次数))
      .map(x=>(x._1,x._2._1,x._2._2))
      .foreach(x=>println(x._1+"  "+x._2+"  "+x._3))
  }

  /**
    * 男性看过最多的10部电影
    */
  def top10MaleLookMovie: Unit ={
    val users = getUsers(sc)
    //获取所有男性的userid
    val faleUserId = users.filter(x => x(1).equals("M"))
      .map(x => x(0)).collect()
    val faleUserSet = HashSet() ++ faleUserId
    //创建广播变量，里面存储所有男性的userid
    val broadcastFaleSet = sc.broadcast(faleUserSet)

    val ratings = getRatings(sc)
    //统计出男性看过最多的１０部电影的(movieid,观看次数)
    val top10moiveid = ratings.map(x => (x(0), x(1))) //(userid,movieid)
      //过滤出男性观影数据
      .filter(x => broadcastFaleSet.value.contains(x._1))
      .map(x => (x._2, 1)) //(movieid,1)
      .reduceByKey(_ + _)
      .sortBy(_._2, false)
      .take(10)
    val top10movieRDD=sc.parallelize(top10moiveid) //(movieid,次数)

    val movies=getMovies(sc)
    val allmoviesRDD=movies.map(x=>(x(0),x(1))) //(movieid,title)
    //对两个ＲＤＤ进行join操作，取二者的共同匹配项
    allmoviesRDD.join(top10movieRDD) //(movieid,(title,次数))
      .map(x=>(x._1,x._2._1,x._2._2))
      .foreach(x=>println(x._1+"  "+x._2+"  "+x._3))
  }

}