案例实操-Top10热门品类

最新推荐文章于 2024-03-07 10:37:19 发布
最新推荐文章于 2024-03-07 10:37:19 发布
阅读量700 收藏 2
点赞数 1
分类专栏： Spark 文章标签： big data scala hive
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/mynameisgt/article/details/123364888
版权

需求1：分别统计每个品类的点击次数，下单次数和支付次数

（品类，点击总数）（品类，下单总数）（品类，支付总数）

排名顺序如：点击总数>下单总数>支付总数

方案一

def main(args: Array[String]): Unit = {

    //TODO : TOP10热门品类
    val sparkConf = new SparkConf().setMaster("local[*]").setAppName("HotCategoryTop10Analysis")
    val sc = new SparkContext(sparkConf)

    //  1.读取原始日志数据
    val actionRDD = sc.textFile("datas/user_visit_action.txt")

    //  2.统计品类的点击数量：(品类ID,点击数量)
    val clickActionRDD = actionRDD.filter(
      action => {
        val datas = action.split("_")
        datas(6) != "-1"
      }
    )

    val clickCountRDD: RDD[(String, Int)] = clickActionRDD.map(
      action => {
        val datas = action.split("_")
        (datas(6), 1)
      }
    ).reduceByKey(_ + _)

    //  3.统计品类的下单数量：(品类ID，下单数量)
    val orderActionRDD = actionRDD.filter(
      action => {
        val datas = action.split("_")
        datas(8) != "null"
      }
    )

    //orderid => 1,2,3
    //[(1,1),(2,1),(3,1)]
    val orderCountRDD = orderActionRDD.flatMap(
      action => {
        val datas = action.split("_")
        val cid = datas(8)
        val cids = cid.split(",")
        cids.map(id => (id, 1))
      }
    ).reduceByKey(_ + _)


    //  4.统计品类的支付数量：(品类ID，支付数量)
    val payActionRDD = actionRDD.filter(
      action => {
        val datas = action.split("_")
        datas(10) != "null"
      }
    )

    //orderid => 1,2,3
    //[(1,1),(2,1),(3,1)]
    val payCountRDD = orderActionRDD.flatMap(
      action => {
        val datas = action.split("_")
        val cid = datas(10)
        val cids = cid.split(",")
        cids.map(id => (id, 1))
      }
    ).reduceByKey(_ + _)

    //  5.将品类进行排序，并且取前10名
    //    点击数量排序，下单数量排序，支付数量排序
    //    元组排序：先比较第一个，再比较第二个，再比较第三个，依次类推
    //    (品类ID，(点击数量，下单数量，支付数量))
    // cogroup = connect + group
    val cogroupRDD: RDD[(String, (Iterable[Int], Iterable[Int], Iterable[Int]))] =
    clickCountRDD.cogroup(orderCountRDD, payCountRDD)

    val analysisRDD = cogroupRDD.mapValues {
      case (clickIter, orderIter, payIter) => {
        var clickCnt = 0
        var iter1 = clickIter.iterator
        if (iter1.hasNext) {
          clickCnt = iter1.next()
        }

        var orderCnt = 0
        var iter2 = orderIter.iterator
        if (iter2.hasNext) {
          orderCnt = iter2.next()
        }

        var payCnt = 0
        var iter3 = payIter.iterator
        if (iter3.hasNext){
          payCnt = iter3.next()
        }

        (clickCnt, orderCnt, payCnt)
      }
    }

    val resultRDD = analysisRDD.sortBy(_._2, false).take(10)

    //  6.将结果采集到控制台打印出来
    resultRDD.foreach(println)


    sc.stop()
  }

方案二

def main(args: Array[String]): Unit = {

    //TODO : TOP10热门品类
    val sparkConf = new SparkConf().setMaster("local[*]").setAppName("HotCategoryTop10Analysis")
    val sc = new SparkContext(sparkConf)

    //  Q : actionRDD重复使用
    //  Q : cogroup性能可能较低

    //  1.读取原始日志数据
    val actionRDD = sc.textFile("datas/user_visit_action.txt")
    actionRDD.cache()

    //  2.统计品类的点击数量：(品类ID,点击数量)
    val clickActionRDD = actionRDD.filter(
      action => {
        val datas = action.split("_")
        datas(6) != "-1"
      }
    )

    val clickCountRDD: RDD[(String, Int)] = clickActionRDD.map(
      action => {
        val datas = action.split("_")
        (datas(6), 1)
      }
    ).reduceByKey(_ + _)

    //  3.统计品类的下单数量：(品类ID，下单数量)
    val orderActionRDD = actionRDD.filter(
      action => {
        val datas = action.split("_")
        datas(8) != "null"
      }
    )

    val orderCountRDD = orderActionRDD.flatMap(
      action => {
        val datas = action.split("_")
        val cid = datas(8)
        val cids = cid.split(",")
        cids.map(id => (id, 1))
      }
    ).reduceByKey(_ + _)


    //  4.统计品类的支付数量：(品类ID，支付数量)
    val payActionRDD = actionRDD.filter(
      action => {
        val datas = action.split("_")
        datas(10) != "null"
      }
    )

    val payCountRDD = orderActionRDD.flatMap(
      action => {
        val datas = action.split("_")
        val cid = datas(10)
        val cids = cid.split(",")
        cids.map(id => (id, 1))
      }
    ).reduceByKey(_ + _)

    //  (品类ID,点击数量) => (品类ID,(点击数量,0,0))
    //  (品类ID,下单数量) => (品类ID,(0,下单数量,0))
    //  (品类ID,支付数量) => (品类ID,(0,0,支付数量))
    //  (品类ID,(点击数量,下单数量,支付数量))


    //  5.将品类进行排序，并且取前10名
    //    点击数量排序，下单数量排序，支付数量排序
    //    元组排序：先比较第一个，再比较第二个，再比较第三个，依次类推
    //    (品类ID，(点击数量，下单数量，支付数量))

    val rdd1 = clickCountRDD.map {
      case (cid, cnt) => {
        (cid, (cnt, 0, 0))
      }
    }

    val rdd2 = orderCountRDD.map {
      case (cid, cnt) => {
        (cid, (0, cnt, 0))
      }
    }

    val rdd3 = payCountRDD.map {
      case (cid, cnt) => {
        (cid, (0, 0, cnt))
      }
    }

    //  将三个数据源合并在一起，统一进行聚合计算
    val soruceRDD: RDD[(String, (Int, Int, Int))] = rdd1.union(rdd2).union(rdd3)

    val analysisRDD = soruceRDD.reduceByKey(
      (t1, t2) => {
        (t1._1 + t2._1, t1._2 + t2._2, t1._3 + t2._3)
      }
    )

    val resultRDD = analysisRDD.sortBy(_._2, false).take(10)

    //  6.将结果采集到控制台打印出来
    resultRDD.foreach(println)


    sc.stop()
  }

方案三

def main(args: Array[String]): Unit = {

    //TODO : TOP10热门品类
    val sparkConf = new SparkConf().setMaster("local[*]").setAppName("HotCategoryTop10Analysis")
    val sc = new SparkContext(sparkConf)

    //  Q : 存在大量的shuffle操作（reduceByKey）
    //  reduceByKey 聚合算子；spark会提供优化，缓存

    //  1.读取原始日志数据
    val actionRDD = sc.textFile("datas/user_visit_action.txt")

    //  2.将数据转换结构
    //  点击的场合：(品类ID,(1,0,0))
    //  下单的场合：(品类ID,(0,1,0))
    //  支付的场合：(品类ID,(0,0,1))
    val flatRDD: RDD[(String, (Int, Int, Int))] = actionRDD.flatMap(
      action => {
        val datas = action.split("_")
        if (datas(6) != "-1") {
          //点击的场合
          List((datas(6), (1, 0, 0)))
        } else if (datas(8) != "null") {
          //下单的场合
          val ids = datas(8).split(",")
          ids.map(id => (id, (0, 1, 0)))
        } else if (datas(10) != "null") {
          //支付的场合
          val ids = datas(10).split(",")
          ids.map(id => (id, (0, 0, 1)))
        } else {
          Nil
        }
      }
    )

    //  3.将相同的品类ID的数据进行分组聚合
    //  (品类ID，(点击数量，下单数量，支付数量))
    val analysisRDD = flatRDD.reduceByKey(
      (t1, t2) => {
        (t1._1 + t2._1, t1._2 + t2._2, t1._3 + t2._3)
      }
    )

    //  4.将统计结构根据数量进行降序处理，取前10名
    val resultRDD = analysisRDD.sortBy(_._2, false).take(10)

    //  5.将结果采集到控制台打印出来
    resultRDD.foreach(println)

    sc.stop()
  }

方案四

  def main(args: Array[String]): Unit = {

    //TODO : TOP10热门品类
    val sparkConf = new SparkConf().setMaster("local[*]").setAppName("HotCategoryTop10Analysis")
    val sc = new SparkContext(sparkConf)

    //  Q : 存在大量的shuffle操作（reduceByKey）
    //  reduceByKey 聚合算子；spark会提供优化，缓存

    //  1.读取原始日志数据
    val actionRDD = sc.textFile("datas/user_visit_action.txt")

    val acc = new HotCategoryAccmulator
    sc.register(acc, "hotCategory")

    //  2.将数据转换结构
    actionRDD.foreach(
      action => {
        val datas = action.split("_")
        if (datas(6) != "-1") {
          //点击的场合
          acc.add((datas(6), "click"))
        } else if (datas(8) != "null") {
          //下单的场合
          val ids = datas(8).split(",")
          ids.foreach(
            id => {
              acc.add((id, "order"))
            }
          )
        } else if (datas(10) != "null") {
          //支付的场合
          val ids = datas(10).split(",")
          ids.foreach(
            id => {
              acc.add((id, "pay"))
            }
          )
        } else {
          Nil
        }
      }
    )

    val accVal: mutable.Map[String, HotCategory] = acc.value
    val categories: mutable.Iterable[HotCategory] = accVal.map(_._2)

    val sort = categories.toList.sortWith(
      (left, right) => {
        if (left.clickCnt > right.clickCnt) {
          true
        } else if (left.clickCnt == right.clickCnt) {
          if (left.orderCnt > right.orderCnt) {
            true
          } else if (left.orderCnt == right.orderCnt) {
            left.payCnt > right.payCnt
          } else {
            false
          }
        }
        else {
          false
        }
      }

    )
    //  5.将结果采集到控制台打印出来
    sort.take(10).foreach(println)

    sc.stop()
  }

  case class HotCategory(cid: String, var clickCnt: Int, var orderCnt: Int, var payCnt: Int) {

  }


  /**
   * 自定义累加器
   * 1.继承AccumulatorV2,定义泛型
   * IN:（品类ID,行为类型）
   * OUT: mutable.Map[String,HotCategory]
   * 2.重写方法(6)
   */
  class HotCategoryAccmulator extends AccumulatorV2[(String, String), mutable.Map[String, HotCategory]] {

    private val hcMap = mutable.Map[String, HotCategory]()

    override def isZero: Boolean = {
      hcMap.isEmpty
    }

    override def copy(): AccumulatorV2[(String, String), mutable.Map[String, HotCategory]] = {
      new HotCategoryAccmulator()
    }

    override def reset(): Unit = {
      hcMap.clear()
    }

    override def add(v: (String, String)): Unit = {
      val cid = v._1
      val actionType = v._2
      val category: HotCategory = hcMap.getOrElse(cid, HotCategory(cid, 0, 0, 0))
      if (actionType == "click") {
        category.clickCnt += 1
      } else if (actionType == "order") {
        category.orderCnt += 1
      } else if (actionType == "pay") {
        category.payCnt += 1
      }
      hcMap.update(cid, category)
    }

    override def merge(other: AccumulatorV2[(String, String), mutable.Map[String, HotCategory]]): Unit = {
      val map1 = this.hcMap
      val map2 = other.value

      map2.foreach {
        case (cid, hc) => {
          val category: HotCategory = map1.getOrElse(cid, HotCategory(cid, 0, 0, 0))
          category.clickCnt += hc.clickCnt
          category.orderCnt += hc.orderCnt
          category.payCnt += hc.payCnt
          map1.update(cid, category)
        }
      }
    }

    override def value: mutable.Map[String, HotCategory] = hcMap
  }

需求2：在需求一的基础上，增加每个品类用户 session 的点击统计

  def main(args: Array[String]): Unit = {

    //TODO : TOP10热门品类
    val sparkConf = new SparkConf().setMaster("local[*]").setAppName("HotCategoryTop10Analysis")
    val sc = new SparkContext(sparkConf)

    val actionRDD = sc.textFile("datas/user_visit_action.txt")
    actionRDD.cache()

    val top10Ids = top10Category(actionRDD)

    //  1.过滤原始数据，保留点击和前10品类ID
    val filterActionRDD = actionRDD.filter(
      action => {
        val datas = action.split("_")
        if (datas(6) != "-1") {
          top10Ids.contains(datas(6))
        } else {
          false
        }
      }
    )

    //2.根据品类ID和sessionid进行点击量的统计
    val reduceRDD: RDD[((String, String), Int)] = filterActionRDD.map(
      action => {
        val datas = action.split("_")
        ((datas(6), datas(2)), 1)
      }
    ).reduceByKey(_ + _)

    //3.将统计的结果进行结构的转换
    //((品类ID，sessionId),sum) => (品类ID，(sessionId,sum))
    val mapRDD = reduceRDD.map {
      case ((cid, sid), sum) => {
        (cid, (sid, sum))
      }
    }

    //4.相同的品类进行分组
    val groupRDD: RDD[(String,Iterable[(String,Int)])] = mapRDD.groupByKey()

    //5.将分组后的数据进行点击量的排序，取前10名
    val resultRDD = groupRDD.mapValues(
      iter => {
        iter.toList.sortBy(_._2)(Ordering.Int).take(10)
      }
    )
    resultRDD.collect().foreach(println)

    sc.stop()
  }

  def top10Category(actionRDD: RDD[String]) = {

    val flatRDD: RDD[(String, (Int, Int, Int))] = actionRDD.flatMap(
      action => {
        val datas = action.split("_")
        if (datas(6) != "-1") {
          //点击的场合
          List((datas(6), (1, 0, 0)))
        } else if (datas(8) != "null") {
          //下单的场合
          val ids = datas(8).split(",")
          ids.map(id => (id, (0, 1, 0)))
        } else if (datas(10) != "null") {
          //支付的场合
          val ids = datas(10).split(",")
          ids.map(id => (id, (0, 0, 1)))
        } else {
          Nil
        }
      }
    )

    val analysisRDD = flatRDD.reduceByKey(
      (t1, t2) => {
        (t1._1 + t2._1, t1._2 + t2._2, t1._3 + t2._3)
      }
    )

    analysisRDD.sortBy(_._2, false).take(10).map(_._1)
  }
未来影子
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
user_visit_action1.txt
10-31
spark sql操作hive表数据源，
电商平台分析平台----需求三:热门top10商品
zisuu的博客
05-26 1097
做什么? 在符合条件的用户行为数据中，获取点击、下单和支付数量排名前10的品类。在Top10的排序中，按照点击数量、下单数量、支付数量的次序进行排序，即优先考虑点击数量。 需求分析 首先我们想要得到的是在符合条件的action中,统计排名前十的热门商品.并且排名的依据是根据点击数量、下单数量、支付数量的次序进行排序的.所以通过逆推: top10商品–>(id,(clickCount=83|orderCount=67|payCount=63))------>分别统计(id,clickCount=
spark案例：Top10 热门品类
csncd的博客
04-09 2698
数据格式： 数据文件中每行数据采用下划线分隔数据 每一行数据表示用户的一次行为，这个行为只能是 4 种行为的一种 如果搜索关键字为 null,表示数据不是搜索数据 如果点击的品类 ID 和产品 ID 为-1，表示数据不是点击数据 针对于下单行为，一次可以下单多个商品，所以品类 ID 和产品 ID 可以是多个，id 之 间采用逗号分隔，如果本次不是下单行为，则数据采用 null 表示 支付行为和下单行为类似 需求：按照每个品类的点击、下单、支付的量来统计热门品类（先按照点击数排名，靠前的就.
SparkCore项目实战|Top10热门品类|Top10热门品类中每个品类的Top10活跃Session统计|页面单跳转化率统计
SmallScorpion
04-21 1578
数据分析 本项目的数据是采集电商网站的用户行为数据，主要包含用户的4种行为：搜索、点击、下单和支付。 （1）数据采用_分割字段 （2）每一行表示用户的一个行为，所以每一行只能是四种行为中的一种。 （3）如果搜索关键字是null，表示这次不是搜索 （4）如果点击的品类id和产品id是-1表示这次不是点击 （5）下单行为来说一次可以下单多个产品，所以品类id和产品id都是多个，id之间使用逗号...
spark：商品热门品类TOP10统计（案例）
qq_55906442的博客
07-31 2245
品类是指产品的分类，大型电商网站品类分多级，一般为三级分类，此次项目中品类只有一级。不同的公司对热门的定义不一样。此次按照每个品类的点击---->下单---->支付的量来统计热门品类。先按照点击数排名，数量决定排名；点击数相同，比较下单数；下单数相同，比较支付数。...
20210825-招商证券-东鹏控股-003012-品类齐全渠道占优，陶瓷龙头再展鹏翼.pdf
08-26
报告标题：“20210825-招商证券-东鹏控股-003012-品类齐全渠道占优，陶瓷龙头再展鹏翼.pdf” 报告摘要：本报告聚焦于陶瓷行业的领军企业东鹏控股，分析了其在中游制造/建材领域的市场地位、业务模式以及发展前景。...
《2019JDATA-用户对品类下店铺的购买预测数据》京东用户行为数据分析数据集
03-12
2019JDATA-用户对品类下店铺的购买预测数据。地址链接如下： https://jdata.jd.com/html/detail.html?id=2，这个京东用户行为数据分析的数据集：《用户购买时间预测》。
中国年轻人低度潮饮酒Alco-pop品类文化白皮书.pdf
06-02
中国年轻人低度潮饮酒Alco-pop品类文化白皮书.pdf
分众传媒介绍-中高端品类.ppt
03-01
分众传媒介绍-中高端品类.ppt
2022年优秀-超市品类分析与评估经营数据分析.pptx
11-30
2022年优秀-超市品类分析与评估经营数据分析 本资源主要围绕超市品类分析与评估的经营数据分析进行阐述。通过对销售数据的收集、销售报表的编制和汇总、经营分析报告的内容等方面的讲解，帮助零售企业更好地了解...
top10热门品类之需求以及实现思路分析
chbxw
07-12 2818
一、 需求：top10热门品类 计算出来通过筛选条件的那些session，他们访问过的所有品类（点击、下单、支付），按照各个品类的点击、下单和支付次数，降序排序，获取前10个品类，也就是筛选条件下的那一批session的top10热门品类； 点击、下单和支付次数：优先按照点击次数排序、如果点击次数相等，那么按照下单次数排序、如果下单次数相当，那么按照支付次数排序 这个需求是很有意义的，因为这...
基于spark的机器学习项目实战
09-17
 根据图识，项目将分为三个部分。整个项目基本思路是如何通过爬虫爬取大量数据放到Hbase，然后通过ETL工具初步转化筛选将数据存到mongodb，抽取mongodb的数据进行清洗处理算出模型放到hdfs。后续进来数据通过模型运算出数据的类型。项目系统主要包括前端+后端+机器学习，前端采用React Native，Native，后端采用Dubbo+Spring+java，机器学习采用Spark进行实现，本项目机器学习-spark代码运行在mesos上。本课程我们只针对以上图示的浅蓝色部分内容（即与机器学习相关的内容），通过用真实的智能客户项目系统作为案例（案例附带源码，可以直接做二次开发），主要根据项目实例穿讲机器学习以及相关知识，包括有：数据提取，数据清洗以及分词，数据特征值提取、机器学习模型计算、数据分类等等，进行详细讲解。本课程所需掌握的技术：java、scala、IK、Hdfs、Spark ml、Spark Streaming、Spark SQL、Kafka、Zookeeper、Mongodb、Spring-Data-Mongodb，由于每个技术需要掌握的程度不一样，对于我们用到的一些开源技术，课程中将会是简单介绍如何使用，不会着重讲解。课程重点讲解spark ml、spark Streaming，以及如何使用这些技术进行项目的实战，贯穿项目系统并且最后串联所有技术。spark基于2.0.1版本讲解
Spark实战案例-需求1-Top10热门品类
冰冰冰
03-09 4998
文章目录第5章 Spark案例实操6.1 需求1：Top10热门品类6.1.1 需求说明6.1.2 实现方案一6.1.2.1 需求分析6.1.2.2 需求实现6.1.3 实现方案二6.1.3.1 需求分析6.1.3.2 需求实现6.1.4 实现方案三6.1.4.1 需求分析6.1.4.2 需求实现 第5章 Spark案例实操 在之前的学习中，我们已经学习了Spark的基础编程方式，接下来，我们看看在实际的工作中如何使用这些API实现具体的需求。这些需求是电商网站的真实需求，所以在实现功能前，咱们必须先将
spark项目实战-电商分析平台
热门推荐
lukabruce的博客
03-25 1万+
第1章 项目概述 电商分析平台是对用户访问电商平台的行为进行分析。 1.1 项目简介   本项目主要讲解一个大型电商网站后台的企业级大数据统计分析平台，该平台以 Spark 为主，对电商网站的流量进行离线和实时的分析。   该大数据分析平台对电商网站的各类用户行为（访问行为、购物行为、广告点击行为等）进行复杂的分析。用统计分析出来的数据，辅助公司中的 PM（产品经理）、数据分析师以及管理人员分析现有产品的状况，并根据用户行为分析结果持续改进产品的设计，以及调整公司的战略和业务。最终达到用大数...
Spark项目实战，详细操作图文详解（基于Spark MLlib的鸢尾花聚类项目实战、基于Spark GraphX的航班飞行网图分析）
weixin_45440484的博客
05-08 3601
Spark项目实战，图文教程详解释，小白可上手 1）基于MLlib的鸢尾花聚类项目实战 2）基于GraphX的航班飞行网图分析
【大数据学习篇10】Spark项目实战~网站转化率统计
m0_56073435的博客
05-24 1970
通过页面单跳转化率的计算公式得知，若要计算单跳A→B的页面单跳转化率，首先需要获取页面A的访问次数，然后需要获取单跳A→B的次数，最终将这两部分数据代入页面单跳转化率的计算公式中计算单跳A→B的页面单跳转化率。在计算每个单跳的页面单跳转化率之前，需要将每个页面与每个单跳进行一一对应，也就是说如果计算单跳A→B的页面单跳转化率，那么代入页面单跳转化率计算公式中的一定是页面A的访问次数，而不能是页面B或C的访问次数。本章我们将对用户浏览网页数据进行分析，从而统计出页面单跳转化率。
Spark Streaming综合实战(一)(史上最详细)
天涯芳草
05-19 9645
很多企业为了支持决策分析而构建的数据仓库系统，其中存放的大量历史数据就是静态数据。技术人员可以利用数据挖掘和OLAP（On-Line Analytical Processing）分析工具从静态数据中找到对企业有价值的信息 对静态数据和流数据的处理，对应着两种截然...
Spark实战-基于Spark日志清洗与数据统计以及Zeppelin使用
最新发布
m0_56525833的博客
03-07 1851
基于spark的数据清洗与统计，以及Zeppelin的配置与使用
大数据项目实战Hive on Spark电信用户行为分析
weixin_54688252的博客
02-29 1891
对于我们常用的关系型数据库, 对于数据一致性要求比较高, 基本都是我们的OLTP系统，而对于我们常见的数据分析系统, 主要是根据已有的业务数据进行统计分析, 比如管理驾驶舱数据统计分析,比如做BI报表, 做机器学习等, 这些我们会专门在一个数据分析系统OLAP系统进行统计分析。首先用户行为产生的日志数据通过Flume采集到HDFS集群中，接下来是hive数仓搭建工作，最后将应用层数据使用DataX同步到MySQL数据库中，通过QuickBI展示出相应的指标，如下图所示。下图为集群启动成果后的效果。
Scala实现统计热门品类top10
06-07
要实现统计热门品类top10，可以按照以下步骤进行： 1. 从数据源中读入商品数据，每个商品包含商品ID、商品名称、商品所属品类等信息。 2. 根据商品所属品类进行分组，将同一品类的商品放到一起。 3. 统计每个品类下的商品数量，得到每个品类的商品总数。 4. 对每个品类下的商品数量进行排序，得到每个品类的商品数量排名。 5. 取出数量排名前10的品类，即为热门品类top10。 Scala代码示例： ```scala // 从数据源中读入商品数据，每个商品包含商品ID、商品名称、商品所属品类等信息 val products = Seq( ("p1", "商品1", "品类1"), ("p2", "商品2", "品类2"), ("p3", "商品3", "品类1"), ("p4", "商品4", "品类2"), ("p5", "商品5", "品类1"), ("p6", "商品6", "品类3"), ("p7", "商品7", "品类2"), ("p8", "商品8", "品类1"), ("p9", "商品9", "品类2"), ("p10", "商品10", "品类3"), ("p11", "商品11", "品类1"), ("p12", "商品12", "品类2"), ("p13", "商品13", "品类3"), ("p14", "商品14", "品类1"), ("p15", "商品15", "品类2") ) // 根据商品所属品类进行分组，将同一品类的商品放到一起 val productsByCategory = products.groupBy(_._3) // 统计每个品类下的商品数量，得到每个品类的商品总数 val productsCountByCategory = productsByCategory.mapValues(_.size) // 对每个品类下的商品数量进行排序，得到每个品类的商品数量排名 val categoryCountRank = productsCountByCategory.toSeq.sortBy(-_._2).zipWithIndex // 取出数量排名前10的品类，即为热门品类top10 val top10Categories = categoryCountRank.take(10).map(_._1._1) // 打印结果 println("热门品类top10:") top10Categories.foreach(println) ``` 输出结果： ``` 热门品类top10: 品类1 品类2 品类3 ```
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值