scala之集合练习案例

最新推荐文章于 2022-12-01 09:59:07 发布
最新推荐文章于 2022-12-01 09:59:07 发布
阅读量612 收藏 8
点赞数 4
分类专栏： scala
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_39743356/article/details/110007589
版权

练习1

1、求出哪些省份没有农产品市场
2、获取菜的种类最多的三个省份
3、获取每个省份菜的种类最多的三个农贸市场

//数据实例：

//省份：
/*
*山西
*辽宁
*吉林
*/

//菜品记录：
/*
*香菜	2.80	2018/1/1	山西汾阳市晋阳农副产品批发市场	山西	汾阳
*大葱	2.80	2018/1/1	山西汾阳市晋阳农副产品批发市场	山西	汾阳
*葱头	1.60	2018/1/1	山西汾阳市晋阳农副产品批发市场	山西	汾阳
*/



package com.test

import scala.io.Source

object Test {
  def main(args: Array[String]): Unit = {
    val source1 = Source.fromFile("D:\\省份数据.txt", "utf-8")
    val source2 = Source.fromFile("D:\\菜品.txt", "utf-8")
    val province = source1.getLines().toList
    val products = source2.getLines().toList

    println(m1(province, products))
    println(m2(products))
    m3(products).foreach(println)

    source1.close()
    source2.close()
  }

  /**
   * 1、求出哪些省份没有农产品市场
   */
  def m1(province: List[String], product: List[String]) = {
    //集合的差集
    province.diff(
      //过滤数据
      product.filter(_.split("\t").length == 6)
        //找处省份列
        .map(_.split("\t")(4))
        //去重
        .distinct
    )
  }

  /**
   * 2、获取菜的种类最多的三个省份
   */
  def m2(product: List[String]) = {
    //过滤数据
    product.filter(_.split("\t").length == 6)
      //找处数据：（省份，菜）
      .map(x => {
        val lines = x.split("\t")
        (lines(4), lines(0))
      })
      //去重
      .distinct
      //根据省份分组
      .groupBy(_._1)
      //计算省份的菜品数
      .map(x => {
        (x._1, x._2.length)
      })
      //转list
      .toList
      //排序，反转，取前三个
      .sortBy(_._2).reverse.take(3)
  }

  /**
   * 3、获取每个省份菜的种类最多的三个农贸市场
   */
  def m3(products: List[String]) = {
    //过滤
    products.filter(_.split("\t").length == 6)
      //取出列封装为元组：（省份，市场名，菜名）
      .map(x => {
        val line = x.split("\t")
        (line(4), line(3), line(0))
      })
      //根据（省份，市场）分组
      .groupBy(x => {
        (x._1, x._2)
      }).toList
      //去重
      .distinct
      //计算（省，店）的菜品数量
      .map(x => {
        (x._1, x._2.length)
      })
      //再根据省分组
      .groupBy(_._1._1)
      //再对数据进行排序，反转，取前三
      .map(x => {
        (x._1, x._2.sortBy(_._2).reverse.take(3))
      })
  }
}

练习2

需求: 每个区域的平均等客时间[每个区域所有司机的等客时间平均值]
	司机ID	上车区域ID	下次区域ID	上车时间	下车时间

	def main(args: Array[String]): Unit = {
	    val datas = List(
	      "A	龙华区	宝安区	2020-07-15 10:05:10	2020-07-15 10:25:02",
	      "B	宝安区	福田区	2020-07-15 11:43:22	2020-07-15 11:55:45",
	      "A	龙岗区	宝安区	2020-07-15 11:55:55	2020-07-15 12:12:23",
	      "B	福田区	宝安区	2020-07-15 12:05:05	2020-07-15 12:22:33",
	      "A	龙岗区	龙华区	2020-07-15 11:02:08	2020-07-15 11:17:15",
	      "A	宝安区	龙岗区	2020-07-15 10:35:15	2020-07-15 10:40:50",
	      "B	龙华区	龙岗区	2020-07-15 10:45:25	2020-07-15 10:50:00",
	      "A	龙华区	龙岗区	2020-07-15 11:33:12	2020-07-15 11:45:35",
	      "B	宝安区	龙岗区	2020-07-15 12:27:20	2020-07-15 12:43:31",
	      "A	宝安区	龙岗区	2020-07-15 12:17:10	2020-07-15 12:33:21",
	      "B	福田区	龙华区	2020-07-15 10:15:21	2020-07-15 10:35:12",
	      "B	龙岗区	宝安区	2020-07-15 11:12:18	2020-07-15 11:27:25")
	
	    datas.map(x => {
	      val strings = x.split("\t")
	      val format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss")
	      (strings(0),
	        strings(1),
	        strings(2),
	        format.parse(strings(3)).getTime / 1000,
	        format.parse(strings(4)).getTime / 1000)
	    })
	      .groupBy(_._1)
	      .map(x => {
	        x._2.sortBy(_._4).sliding(2).toList
	          .map(x => {
	            val l = x.last._4 - x.head._5
	            (x.head._3, l)
	          })
	      }).flatten.toList
	      .groupBy(x => {
	        x._1
	      })
	      .map(x => {
	        (x._1, x._2.map(_._2).sum / x._2.length)
	      })
	      .foreach(println)
	  }

练习3

需求: 统计每个用户一小时内的最大登录次数
user_id,login_time

	  def main(args: Array[String]): Unit = {
	    val datas = List(
	      "a,2020-07-11 10:51:12",
	      "a,2020-07-11 11:05:00",
	      "a,2020-07-11 11:15:20",
	      "a,2020-07-11 11:25:05",
	      "a,2020-07-11 11:45:00",
	      "a,2020-07-11 11:55:36",
	      "a,2020-07-11 11:59:56",
	      "a,2020-07-11 12:35:12",
	      "a,2020-07-11 12:58:59",
	      "b,2020-07-11 14:51:12",
	      "b,2020-07-11 14:05:00",
	      "b,2020-07-11 15:15:20",
	      "b,2020-07-11 15:25:05",
	      "b,2020-07-11 16:45:00",
	      "b,2020-07-11 16:55:36",
	      "b,2020-07-11 16:59:56",
	      "b,2020-07-11 17:35:12",
	      "b,2020-07-11 17:58:59")
	
	    datas.map(x => {
	      val strings = x.split(",")
	      val user = strings(0)
	      val timeStr = strings(1)
	      val date = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").parse(timeStr)
	      (user, date)
	    })
	      //按照时间升序排序
	      .sortBy(_._2)
	      //根据用户分组
	      .groupBy(_._1)
	      .map(x => {
	        //用户id
	        val id = x._1
	        //用户的登录记录list
	        val list = x._2
	        val result = list.map(x => {
	          //list中的登录时间
	          val startTime = x._2.getTime
	          //计算list中的登录时间跟上面时间比较少于一个小时的个数
	          list.count(f => {
	            val now = f._2.getTime
	            now - startTime >= 0 && now - startTime < 1000 * 60 * 60
	          })
	          //取最大值
	        }).max
	        (id, result)
	      })
	      .foreach(println)
	  }

练习4

统计每个用户每个会话（超过半个小时没有登录，归为下一个会话）内的行为轨迹

object Test {

  /**
   * 统计每个用户每个会话（超过半个小时没有登录，归为下一个会话）内的行为轨迹
   * 用户id  操作时间  操作页面
   */
  def main(args: Array[String]): Unit = {
    val list = List[(String, String, String)](
      ("1001", "2020-09-10 10:21:21", "home.html"),
      ("1001", "2020-09-10 10:28:10", "good_list.html"),
      ("1001", "2020-09-10 10:35:05", "good_detail.html"),
      ("1001", "2020-09-10 10:42:55", "cart.html"),
      ("1001", "2020-09-10 11:35:21", "home.html"),
      ("1001", "2020-09-10 11:36:10", "cart.html"),
      ("1001", "2020-09-10 11:38:12", "trade.html"),
      ("1001", "2020-09-10 11:40:00", "payment.html"),
      ("1002", "2020-09-10 09:40:00", "home.html"),
      ("1002", "2020-09-10 09:41:00", "mine.html"),
      ("1002", "2020-09-10 09:42:00", "favor.html"),
      ("1003", "2020-09-10 13:10:00", "home.html"),
      ("1003", "2020-09-10 13:15:00", "search.html"))

    //按照用户id分组
    list
      .map {
        case (userId, time, page) => {
          //将时间字符转换为Long
          val timeCost = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").parse(time).getTime
          //为每条记录提供一个唯一id
          val id = UUID.randomUUID().toString
          //封装数据
          UserInfo(id, userId, timeCost, page)
        }
      }
      //按照用户id分组
      .groupBy(_.userId)
      .map(x => {
        //x._2为每个用户的所有操作轨迹，根据时间戳升序排序
        x._2.sortBy(_.time)
          //再两两开窗
          .sliding(2).toList
          //遍历它
          .foreach(y => {
            val head = y.head
            val last = y.last
            //如果两个记录之间的时间超过半个小时，将第二个的标识id设置为第一个的
            if (last.time - head.time <= 60 * 30 * 1000) {
              last.id = head.id
            }
          })
        x._2
      })
      .toList
      .flatten
      //结果展示，id相同的标识为一个用户的一次会话内的操作轨迹
      .foreach(println)

  }

  case class UserInfo(var id: String, val userId: String, val time: Long, val page: String)

}
程序猿-瑞瑞
关注
  • 4
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
Scala(18) -- scala的集合（Iterable、Seq、Stack、Queue、Set、Map）
erainm
09-22 728
1. Iterable 2. Seq 3. Stack 4. Queue 5. Set 6.Map 7. 案例
Scala 强大的集合数据操作示例
热门推荐
05-23 9万+
Scala是数据挖掘算法领域最有力的编程语言之一，语言本身是面向函数，这也符合了数据挖掘算法的常用场景：在原始数据集上应用一系列的变换，语言本身也对集合操作提供了众多强大的函数，本文将以List类型为例子，介绍常见的集合变换操作。一、常用操作符（操作符其实也是函数）++ ++[B](that: GenTraversableOnce[B]): List[B] 从列表的尾部添加另外一个列表++: ++:
Scala之集合的理解和应用案例
u012798083的专栏
09-28 832
可变集合和不可变集合 Scala 集合类系统地区分了可变的和不可变的集合； 可变集合可以在适当的地方被更新或扩展。这意味着你可以修改，添加，移除一个集合的元素。默认情况下，Scala 一直采用不可变集合类。 而不可变集合类，相比之下，永远不会改变。因此，它是线程安全的；不过，你仍然可以模拟添加，移除或更新操作。但是这些操作将在每一种情况下都返回一个新的集合，同时使原来的集合不发生改变。...
Scala数组集合函数以及案例大全（一看就懂）！！！！
Better0417的博客
09-12 883
Scala数组大全++++：+：:+/::\addString(b)addString(b,sep)aggregateapplycanEqualcharAtclonecollectcollectFirstcombinationscomposecontainscontainsSlicecopyToArray(xs)copyToArray(xs, start)copyToArray(xs, start, len)copyToBuffercorrespondscountdiffdistinctdropdropRi
Scala | Scala集合的综合练习
XING_Gou的博客
08-04 669
综合练习： val l1=List((“tom”,“M”,23),(“rose”,“F”,18),(“jim”,“M”,30),(“jary”,“M”,25)) 练习1：统计出所有人的年龄和 练习2：返回男性年龄最高的前两个人的数据，返回的形式:List(“jim-M”,“jary-M”) val l2=List((“bj”,1),(“sh”,2),(“bj”,3),(“sh”,4)) 练习3:操作l2,返回按地区分组的结果 val l3=List(“hello world”,“hello scal
Scala 数组集合
01-07
Scala 常用数组集合简单总结 数组 Array-数组 //伴⽣对象创建数组 var a1=Array(1,2,3,5,4) //创建⻓度为5的数组，所有值都是0 var a2=new Array[Int](5) //获取⻓度 a1.length a2.size //修改 a1(1) = -1 a1.update...
头歌Scala中集合的使用
04-13
Scala中集合的使用 大学生 1. List 列表的使用 2. Set 集合的使用 3.Map 映射的使用 4. 元组的使用
Scala 集合数据操作示例
11-13
map[B](f: (A) ? B): List[B] 定义一个变换,把该变换应用到列表的每个元素中,原列表不变，返回一个新的列表数据
Scala的集合算子
01-07
Scala集合提供了丰富的计算算⼦，⽤于实现集合/数组的计算，这些计算⼦⼀般针对于List、Array、Set、Map、Range、Vector、Iterator等都可以适⽤。 排序 ① sorted scala> var a = Array(1,3,4,2,5) a: Array[Int] = ...
Scala-part2集合框架
11-13
快速掌握集合，Scala的集合有三大类：序列Seq、集Set、映射Map，所有的集合都扩展自Iterable特质 在Scala中集合有可变（mutable）和不可变（immutable）两种类型
Scala编程_中文高清完整版附带案例源码
05-22
第1章，“可伸展的语言”，给出了Scala的设计，和它后面的理由，历史的概要。 第2章，“Scala的第一步”，展示给你如何使用Scala完成若干种基本编程任务，而不牵涉过多关于如何工作的细节。本章的目的是让你的手指开始敲击并执行Scala代码。 第3章，“Scala的下一步”，演示更多的基本编程任务来帮助你更快速地上手Scala。本章之后，你将能够开始在简单的脚本任务中使用Scala。 第4章，“类和对象”，通过描述面向对象语言的基本建设模块和如何编译及运行Scala程序的教程开始有深度地覆盖Scala语言。 第5章，“基本类型和操作”，覆盖了Scala的基本类型，它们的文本，你可以执行的操作，优先级和关联性是如何工作的，还有什么是富包装器。 第6章，“函数式对象”，进入了Scala面向对象特征的更深层次，使用函数式（即，不可变）分数作为例子。 第7章，“内建控制结构”，显示了如何使用Scala的内建控制结构，如，if，while，for，try和match。 第8章，“函数和闭包”，深度讨论了函数式语言的基础建设模块，函数。 ...... 第31章，“组合子解析”，显示了如何使用Scala的解析器组合子库来创建解析器。 第32章，“GUI编程”，展示了使用Scala库简化基于Swing的GUI编程的快速旅程。 第33章，“SCell电子表”，通过展示一个完整的电子表的实现，集中演示了Scala的一切。
spark的scala练习代码（里面都有详细注解）
03-16
spark的学习过程中最重要的便是练习，我发布的都是详细注解的代码，帮助学习spark。
Scala集合习题Ⅱ
码到成龚的博客
12-01 950
练习题 3 ：求出各城市的平均温度 练习题4：请用scala得出以下的结果
Scala集合习题Ⅰ
码到成龚的博客
11-30 570
练习题 1：计算分组后的list 分别对应的长度，和累加值 练习题 2: 实现 wordcount
Spark scala编程练习题——通过日志统计网站访问量
qq_38151907的博客
11-30 1588
Spark scala编程练习题——通过日志统计网站访问量
scala算子综合案例（一）----- wordcount的多种实现
qq_824203453_的博客
07-12 4353
版权声明：本文为博主原创文章，未经博主允许不得转载!! 欢迎访问:https://blog.csdn.net/qq_21439395/article/details/81022890 交流QQ: 824203453   实现方案一：  map + flatten + groupBy 实现方式二：flatMap + groupBy object ScalaWordCount { d...
Scala(17) --scala的集合、Traversable集合
erainm
09-22 402
1. 集合 2. Traversable 3. 案例
Scala常用方法大全（附代码案例）会不定时更新
我的博客
01-30 319
转自：https://blog.csdn.net/JENREY/article/details/80727168 1.flatten 可以把嵌套的结构展开. scala&gt; List(List(1,2),List(3,4)).flatten res0: List[Int] = List(1, 2, 3, 4) 2、flatmap flatMap结合了map和flatten的功能。接收一...
scala并行集合
最新发布
05-25
Scala 并行集合是 Scala 标准库中提供的一种并行计算工具，它可以帮助我们在多核 CPU 上充分利用并行计算能力，提高程序的执行效率。Scala 并行集合主要有以下几种类型： 1. `ParArray`：并行数组，类似于普通的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

程序猿-瑞瑞

打赏不准超过你的一半工资哦~

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值