Scala(最终9/10/11章)

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