Scala(最终9/10/11章)

news/2024/11/27 21:11:45/

第 9 章 异常

语法处理上和 Java 类似，但是又不尽相同。

9.1java的异常处理

Scala
public class ExceptionDemo {
 public static void main(String[] args) {
 try {
 int a = 10;
 int b = 0;
 int c = a / b;
 }catch (ArithmeticException e){
// catch 时，需要将范围小的写到前面
 e.printStackTrace();
 }catch (Exception e){
 e.printStackTrace();
 }finally {
 System.out.println("finally");
 }
 }
}

注意事项

（1）Java 语言按照 try—catch—finally 的方式来处理异常

（2）不管有没有异常捕获，都会执行 finally，因此通常可以在 finally 代码块中释放资源。

（3）可以有多个 catch，分别捕获对应的异常，这时需要把范围小的异常类写在前面，把范围大的异常类写在后面，否则编译错误。

9.2 Scala 异常处理

Scala
def main(args: Array[String]): Unit = {
 try {
 var n= 10 / 0
 }catch {
 case ex: ArithmeticException=>{
 // 发生算术异常
 println("发生算术异常")
 }
 case ex: Exception=>{
 // 对异常处理
 println("发生了异常 1")
 println("发生了异常 2")
 }
 }finally {
 println("finally")
 }
}

总结：

我们将可疑代码封装在 try 块中。在 try 块之后使用了一个 catch 处理程序来捕获异常。如果发生任何异常，catch 处理程序将处理它，程序将不会异常终止。

Scala 的异常的工作机制和 Java 一样，但是 Scala 没有“checked（编译期）”异常， 即 Scala 没有编译异常这个概念，异常都是在运行的时候捕获处理。

异常捕捉的机制与其他语言中一样，如果有异常发生，catch 子句是按次序捕捉的。因此，在 catch 子句中，越具体的异常越要靠前，越普遍的异常越靠后，如果把越普遍的异常写在前，把具体的异常写在后，在 Scala 中也不会报错，但这样是非常不好的编程风格。

finally 子句用于执行不管是正常处理还是有异常发生时都需要执行的步骤，一般用于对象的清理工作，这点和 Java 一样。

用 throw 关键字，抛出一个异常对象。所有异常都是 Throwable 的子类型。throw 表达式是有类型的，就是 Nothing，因为 Nothing 是所有类型的子类型，所以 throw 表达式可以用在需要类型的地方

Scala
def test():Nothing = {
 throw new Exception("不对")
}

java 提供了 throws 关键字来声明异常。可以使用方法定义声明异常。它向调用者函数提供了此方法可能引发此异常的信息。它有助于调用函数处理并将该代码包含在 try-catch块中，以避免程序异常终止。在 Scala 中，可以使用 throws 注解来声明异常

Scala
def main(args: Array[String]): Unit = {
 f11()
}
@throws(classOf[NumberFormatException])
def f11()={
 "abc".toInt
}

第 10 章 IO

10.1输入

Scala
Source.fromFile()

10.1.1输入行

Scala
/**
  * 2019/11/18
  * @author Hangge.z  WX:17710299606
  */
object LineIO {
  def main(args: Array[String]): Unit = {
   // 读取文件
    val bs: BufferedSource = Source.fromFile("d://data.txt")
    // 获取所有的行
    val lines: Iterator[String] = bs.getLines()
    // 遍历所有的行
    for (line <- lines) {
      println(line)
    }
    // 行列表
    val list: List[String] = lines.toList
    //行数组
    val array: Array[String] = lines.toArray
    // 整个字符串
    val content: String = lines.mkString
    // 释放资源
    bs.close()
  }
}

10.1.2输入字节

Scala
/**
  * 2019/11/18
  * @author Hangge.z  WX:17710299606
  *
  */
object ByteIo {
  def main(args: Array[String]): Unit = {
    val bs: BufferedSource = Source.fromFile("d://data.txt")
    // 获取输入流对象
    val reader: InputStreamReader = bs.reader()
    //跳过指定长度  到指定位置
    reader.skip(1)
    // 读取一个字节
    val byte: Int = reader.read()
    println(byte) // 99
    reader.close()
    bs.close()
  }
}
def main(args:Array[String]):Unit={
  val file = new File("F:\\info.bin")
  val in = new FileInputStream(file)
  val bytes = new Array[Byte](file.length.toInt)
  in.read(bytes)
  in.close

10.1.3读取其他数据源

Scala
//从URL读取
val source= Source.fromURL("http://www.baidu.com","UTF-8")
val lineIterator =source.getLines
for(l<-lineIterator){
  println(l.toString())
}
//从给定的字符串读取--调试有用
val source2= Source.fromString("Hello DOIT")
println(source2.mkString)//Hello DOIT
//从标准输入读取
val in: BufferedReader = Console.in
println(in.readLine())

10.2输出

Scala
def main(args: Array[String]): Unit = {
  val out = new PrintWriter("F:\\aa.txt")
  for(i<-1 to 100)
    out.println(i)
p.write("")
p.write(Array[Char]('a'))
p.append("")
  out.close
}

第 11 章 综合练习

需求一：wordCount

Scala
package com.doit.day03

import scala.io.{BufferedSource, Source}

object WordCountDemo {
  def main(args: Array[String]): Unit = {
    //读取文件，获取到一个Source对象
    val source: BufferedSource = Source.fromFile("D:\\develop\\ideaWorkSpace\\myself\\study\\scalaDemo\\data\\word.txt")
    //调用getLines方法，获取到每一行数据，每一行数据都放在迭代器中
    val lines: Iterator[String] = source.getLines()
    //如果我现在直接这么返回，他的返回值是什么？？   Iterator[String]  ==》 同样的返回一个迭代器，迭代器里面放得是Array[String] 数组里面每一个元素放得都是一个个的单词
    val arrWord: Iterator[Array[String]] = lines.map(line => {
      //1.需要将每一行数据拿出来进行切割，变成一个个的单词
      //hello   hadoop  hive
      val wordsArr: Array[String] = line.split("\\s+")
      wordsArr
    })
    //将迭代器转换成了集合
    val list: List[Array[String]] = arrWord.toList
    //将list中的array压平，这样list装的就是每一个单词了
    val word: List[String] = list.flatten
    //对每一个单词进行分组，相同的单词分在一组，key就是单词，value是一个list，所有相同的单词都放在这个list中
    val wordAndList: Map[String, List[String]] = word.groupBy(word => word)
    //转换，将list转换成长度，长度就是单词的个数
    val wordCount: Map[String, Int] = wordAndList.map(tup => (tup._1, tup._2.size))
    //查看结果
    println(wordCount)
  }
}

需求二：平均温度案例

Scala
package com.doit.day03

/**
 * 需求：求最近几天每个城市的平均温度
 */
object AvgTem {
  def main(args: Array[String]): Unit = {
    val d1 = Array(("beijing", 28.1), ("shanghai", 28.7), ("guangzhou", 32.0), ("shenzhen", 31.0))
    val d2 = Array(("beijing", 27.3), ("shanghai", 30.1), ("guangzhou", 33.3))
    val d3 = Array(("beijing", 28.2), ("shanghai", 29.1), ("guangzhou", 32.0), ("shenzhen", 32.0))

    //1.将所有的数据都放在一个数组或者集合中
    val allData: Array[(String, Double)] = d1 ++ d2 ++ d3
    //Array(("beijing", 28.1), ("shanghai", 28.7), ("guangzhou", 32.0), ("shenzhen", 33.1),("beijing", 27.3), ("shanghai", 30.1), ("guangzhou", 33.3)，("beijing", 28.2), ("shanghai", 29.1), ("guangzhou", 32.0), ("shenzhen", 32.1))

    //按照城市分组
    val grouped: Map[String, Array[(String, Double)]] = allData.groupBy(tp => tp._1)

    //方式一，获取到所有的温度，sum求和后求平均
    val res: Map[String, Double] = grouped.map(tp => {
      //数组中每一个元素的key都是一样的，只是温度不一样，现在需要将整个数组转换成城市，平均温度
      val value: Array[(String, Double)] = tp._2
      val avg: Double = value.map(_._2).sum / value.length
      (tp._1, avg)
    })
    println(res)


    //方式二，只对value进行处理
    val res1: Map[String, (String, Double)] = grouped.mapValues(tp => {
      val avg: Double = tp.reduce(_._2 + _._2) / tp.length
      (tp(0)._1, avg)
    })

  }
}

需求三：共同好友案例

Scala
package com.doit.day03

import scala.io.{BufferedSource, Source}

/**
 * 数据如下  :每个字母代表一个人 ,  统计任意一个人和其他人的共同好友
 * A:B,C,D,F,E,O
 * B:A,C,E,K
 * C:F,A,D,I
 * D:A,E,F,L
 * E:B,C,D,M,L
 * F:A,B,C,D,E,O,M
 * G:A,C,D,E,F
 * H:A,C,D,E,O
 * I:A,O
 * J:B,O
 * K:A,C,D
 * L:D,E,F
 * M:E,F,G
 * O:A,H,I,J
 */
object SameFriends {
  def main(args: Array[String]): Unit = {
     val lines: Iterator[String] = Source.fromFile("D:\\develop\\ideaWorkSpace\\myself\\study\\scalaDemo\\data\\friends").getLines()
     val myAndFriends: List[(String, Array[String])] = lines.toList.map(line => {
        //        A:B,C,D,F,E,O   :前面的是我自己，：后面的是我的朋友们
        val arr: Array[String] = line.split(":")
        //获取到我自己
        val user: String = arr(0)
        //获取到我的朋友们，朋友们都放在数组里面，里面的元素就是一个个的朋友对象
        val friends: Array[String] = arr(1).split(",")
        (user, friends)
     })

     //获取共同好友。。。
     for(i <- 0 until myAndFriends.length){
        for(j <- i+1 until myAndFriends.length){
           //从第一个元素开始取
           val tuple: (String, Array[String]) = myAndFriends(i)
           val tuple1: (String, Array[String]) = myAndFriends(j)
           //看是不是有共同好友，是不是取交集
           val sameFriends: Array[String] = tuple._2.intersect(tuple1._2)
           println("用户："+tuple._1+"用户："+tuple1._1+"的共同好友是："+sameFriends.mkString(","))
        }
     }
  }
}

需求四：SQL join语法案例

Data

Plain Text
order.txt

order011,u001,300
order012,u002,200
order023,u006,100
order056,u007,300
order066,u003,500
order055,u004,300
order021,u005,300
order014,u001,100
order025,u005,300
order046,u007,30
order067,u003,340
order098,u008,310

user.txt

u001,hls,22,fengjie
u002,wangwu,31,lisi
u003,zhangyanru,22,tananpengyou
u004,laocao,26,fengyi
u005,mengqi,12,nvmengqi
u006,haolei,38,sb
u007,wanghongjing,24,wife
u009,wanghongjing,24,wife



返回一个结果：order011  u001   300  hls  22   fengjie

代码示例：

Scala
package com.doit.day03

import scala.io.{BufferedSource, Source}

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

    //u001,hls,22,fengjie
    val bs1= Source.fromFile("D:\\develop\\ideaWorkSpace\\myself\\study\\scalaDemo\\data\\user.txt")/*.getLines().toList*/

    //order011,u001,300
    val bs2 = Source.fromFile("D:\\develop\\ideaWorkSpace\\myself\\study\\scalaDemo\\data\\order.txt")/*.getLines().toList*/

    //实现left join
/*
    //将用户数据转换成map集合
    val users: Iterator[String] = bs1.getLines()
    val iters: Iterator[(String, (String, String, String, String))] = users.map(_.split(",", -1)).map(x => (x(0), (x(0), x(1), x(2), x(3))))
    val map: Map[String, (String, String, String, String)] = iters.toMap
    // 将订单数据转换成list集合
    val orders: Iterator[String] = bs2.getLines()
    val iters2: Iterator[(String, (String, String))] = orders.map(_.split(",", -1)).map(x => (x(1), (x(0), x(1))))
    val list2: List[(String, (String, String))] = iters2.toList

    //遍历每个订单  拼接用户信息
    var r = list2.map(x => {
      val user = map.getOrElse(x._1, ("null", "null", "null", "null"))
      (user._1, user._2, user._3, user._4, x._2._1)
    })
    // 打印结果
    r.sortBy(_._1).foreach(println)

    */

    //实现join
    /*
    val userTuple: List[(String, String, String, String)] = users.map(line => {
      val arr: Array[String] = line.split(",")
      //user_id，user_name，age,name
      (arr(0), arr(1), arr(2), arr(3))
    })

    val orderTuple: List[(String, String, String)] = orders.map(line => {
      val arr: Array[String] = line.split(",")
      //order_id  user_id   amount
      (arr(0), arr(1), arr(2))
    })

    //join关联条件是user_id = user_id

    for (user <- userTuple) {
      for (order <- orderTuple) {
        if(user._1 == order._2){
          println(user._1,user._2,user._3,user._4,order._1,order._3)
        }
      }
    }
*/
  }
}

需求五：pv，uv案例

数据：

Plain Text
site1,user1,2018-03-01 02:12:22
site1,user2,2018-03-05 04:12:22
site1,user2,2018-03-05 04:13:22
site1,user2,2018-03-05 04:14:22
site1,user2,2018-03-05 04:15:22
site4,user7,
site1,user2,2018-03-05 05:15:22
site1,user2,2018-03-05 08:15:22
site1,user3,2018-03-05 04:15:22
site1,user4,2018-03-05 05:15:22
site1,user3,2018-03-07 11:12:22
site1,user3,2018-03-08 11:12:22
site2,user4,2018-03-07 15:12:22
site3,user5,2018-03-07 08:12:22
site3,user6,2018-03-05 08:12:22
site1,user1,2018-03-08 11:12:22
site1,,2018-03-08 11:12:22
site2,user2,2018-03-07 15:12:22
site3,user5,2018-03-07 08:12:22
site3,user5,2018-03-07 18:12:22
site3,user6,2018-03-05 08:12:22
site4,user7,2018-03-03 10:12:22
site2,,2018-03-08 11:12:22
site3,user5,2018-03-07 08:12:22
site3,user6,2018-03-05 08:12:22
site4,user5,2018-03-03 10:12:22
site4,user7,2018-02-20 11:12:22

代码：

Scala
package com.doit.day03
import scala.io.{BufferedSource, Source}
/**
 * 需求：计算每天的pv和uv
 * pv：浏览次数
 * uv：访客数
 */
object PVUVDemo {
  def main(args: Array[String]): Unit = {

    val source: BufferedSource = Source.fromFile("D:\\develop\\ideaWorkSpace\\myself\\study\\scalaDemo\\data\\pvuv.txt")

    val list: List[String] = source.getLines().toList

    //过滤一些脏数据
    val filtered: List[String] = list.filter(line => {
      val arr: Array[String] = line.split(",",-1)
      arr.length >= 0 && !arr.exists(_.isEmpty)
    })

    val events: List[(String, String, String)] = filtered.map(line => {
      val arr: Array[String] = line.split(",")
      val date: String = arr(2).substring(0, 10)
      //site1,user1,2018-03-01 02:12:22
      (arr(0), arr(1),date)
    })

    //pv：该页面被浏览了多少次
    val tuples: List[((String, String), String)] = events.map(tp => {
      ((tp._3, tp._1), tp._2)
    })

    val pv: Map[(String, String), Int] = tuples.groupBy(_._1).map(tp => (tp._1, tp._2.size))
    val uv: Map[(String, String), Int] = tuples.groupBy(_._1).map(tp => (tp._1, tp._2.distinct.size))
    println("============pv================")
    pv.foreach(println)
    println("============uv================")
    uv.foreach(println)
  }
}

需求五：线段重叠案例

data：

Plain Text
1,4
2,5
4,6
2,4
3,6
4,6
1,5

代码：

Scala
package com.doit.day03

import scala.io.Source

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

    val list: List[String] = Source.fromFile("D:\\develop\\ideaWorkSpace\\myself\\study\\scalaDemo\\data\\line.txt").getLines().toList

    //生成一个个的点
    val points: List[Range.Inclusive] = list.map(line => {
      val arr: Array[String] = line.split(",")
      val start: String = arr(0)
      val end: String = arr(1)
      //按照起始得位置确定这一行中一共有哪些点，后面才能判断哪些点是重合的
      //根据开始和结束得点
      val range: Range.Inclusive = start.toInt to end.toInt
      range
    })

    //将点压平
    val flattened: List[Int] = points.flatten
    //对点分组
    val intToInts: Map[Int, List[Int]] = flattened.groupBy(point => point)
    //获取到最后的个数
    val res: Map[Int, Int] = intToInts.map(tp => (tp._1, tp._2.size))

    res.foreach(println)
  }
}

需求六：综合电影案例

SQL
需求：
1.求每部电影的平均分，按照降序输出

2.求每个用户评过电影的总数，按照降序排列

3.每个用户评价的前三部电影(用户，电影信息，评分值)

4.哪些年份的电影评分(平均分)最高，取最高的前五个年份

5.每个电影类型的平均分按照降序排列取前3

6.最受欢迎(被评分次数最多的)的前三个电影类型

7.每个职业最喜欢的前三个电影类型(按照观看次数排)  -->多了一步   获取到用户id，然后再去关联职业

8.补全信息(返回电影的名称，类型，被评的所有分集合，所有评分的人集合) -->关联条件  一对一还是一对多


http://www.ppmy.cn/news/436426.html

相关文章

vivo手机打印不了日志_vivo手机里的log是什么意思？

vivo手机打印不了日志_vivo手机里的log是什么意思？

01 日志 vivo手机log是记录了系统和软件运行情况的日志文件&#xff0c;可用来分析使用手机过程中遇到的一些问题。 log意即日志&#xff0c;通常是系统或者某些软件对已完成的某种处理的记录&#xff0c;以便将来作为参考&#xff0c;它并没有固定的格式&#xff0c;通常是文本…
阅读更多...
vivo手机html卸载不了,vivo手机怎么彻底卸载删除软件残留的垃圾文件呢

vivo手机html卸载不了,vivo手机怎么彻底卸载删除软件残留的垃圾文件呢

一般手机在用了一段时间后&#xff0c;多多少少都会变得越来越卡了。这时我们会选择把使用频率不高的APP卸载掉。我们的操作基本上都是直接在桌面上长按APP图标然后选择左上角的“x”号&#xff0c;直接把APP卸载。可是这样做把APP卸载干净了吗&#xff1f;事实是不能完全卸载干…
阅读更多...
vivo手机要用计算机隐藏游戏图标,vivo手机怎么隐藏桌面应用图标

vivo手机要用计算机隐藏游戏图标,vivo手机怎么隐藏桌面应用图标

在生活中经常用到电脑的用户肯定都有听说或者使用过电脑上的桌面图标隐藏工具吧&#xff0c;这个工具能够帮助我们隐藏桌面的一些重要图标&#xff0c;那么在我们的智能手机中同样也是有这样一个功能的&#xff0c;可以让用户自行选择要隐藏的桌面图标&#xff0c;并且在不同的…
阅读更多...
vivo手机怎么弄html,vivo手机怎么更改默认应用设置

vivo手机怎么弄html,vivo手机怎么更改默认应用设置

手机是我们生活中不和或缺的电子移动设备&#xff0c;不管是在那个品牌的智能手机中都是有一些默认的应用程序的&#xff0c;就比如手机中的输入法、音乐、邮件等应用程序&#xff0c;在我们没有进行更改之前都是默认使用系统自带的&#xff0c;如果我们想要自己下载这些应用来…
阅读更多...
iphone 数据导android,一招解决iPhone数据导入vivo手机，网友直说，太方便

iphone 数据导android,一招解决iPhone数据导入vivo手机，网友直说，太方便

前一段时间&#xff0c;几个同事都换了新手机。从IOS阵营转到了安卓阵营&#xff0c;从苹果转到了vivo。问他们为什么会从平台上切换呢&#xff1f;一个同事说他刚开始也没考虑换平台&#xff0c;但是上手vivo NEX双屏版之后就改观了&#xff0c;像屏幕方面还是全面屏在使用的时…
阅读更多...
vivo换手机云服务器,换机数据转移不用愁，vivo云服务竞是这么用的！

vivo换手机云服务器,换机数据转移不用愁，vivo云服务竞是这么用的！

原标题&#xff1a;换机数据转移不用愁&#xff0c;vivo云服务竞是这么用的&#xff01; 在去年2018年里&#xff0c;vivo给大家展示了自身雄厚的科技实力&#xff0c;特别是临近年末的一款vivo NEX双屏版&#xff0c;更是给了人们十足的惊喜。相信不少小伙伴们都因此而选择了它…
阅读更多...
vivo手机计算机记录怎么找回,如何从Vivo手机恢复已删除的照片，您将在阅读后知道...

vivo手机计算机记录怎么找回,如何从Vivo手机恢复已删除的照片，您将在阅读后知道...

vivo手机是我们最喜欢的手机之一. 我喜欢用vivo手机拍照. 排除效果特别好. 有时我不小心删除了我拍摄的令人满意的照片&#xff0c;这使我很烦. 不久前vivo手机的挂件删除后怎么恢复&#xff0c;我发现了一种可以还原vivo手机已删除照片的方法. 我告诉你&#xff01; 工具/材料…
阅读更多...
vivo手机可以升级鸿蒙系统,什么手机可以刷鸿蒙系统？vivo、OPPO、三星手机刷鸿蒙系统教程...

vivo手机可以升级鸿蒙系统,什么手机可以刷鸿蒙系统？vivo、OPPO、三星手机刷鸿蒙系统教程...

华为全新鸿蒙系统发布之后&#xff0c;除了不少的华为手机可以升级尝鲜之外&#xff0c;很多小伙伴还是很羡慕的&#xff0c;比如&#xff0c;小米&#xff0c;红米&#xff0c;vivo、OPPO、三星&#xff0c;魅族等手机用户都想升级刷鸿蒙系统&#xff0c;那么这个该怎么操作呢…
阅读更多...
最新文章

Copyright @ 2022~2023