Scala_4

最新推荐文章于 2022-02-07 10:44:04 发布

美美的大猪蹄子

最新推荐文章于 2022-02-07 10:44:04 发布

阅读量235

点赞数

分类专栏： Scala 文章标签： Scala_4

本文链接：https://blog.csdn.net/qq_27501147/article/details/102624012

版权

Scala 专栏收录该内容

5 篇文章 1 订阅

订阅专栏

scala-day04

13.正则表达式

定义一个正则表达式，来匹配邮箱是否合法

参考代码

scala> var str = "119829381@163.com"
str: String = 119829381@163.com

scala> str.matches("^([0-9]*|[a-z]*)@([a-z]*|[0-9]*)\\..*$")
res3: Boolean = true

scala> "13845642324".matches("^(13[0-9]|14[5|7]|15[0|1|2|3|5|6|7|8|9]|18[0|1|2|3|5|6|7|8|9])\\d{8}$")
res7: Boolean = true

val r = """.+@.+\..+""".r

val eml1 = "qq12344@163.com"
val eml2 = "qq12344@.com"

if(r.findAllMatchIn(eml1).size > 0) {
    println(eml1 + "邮箱合法")
}
else {
    println(eml1 + "邮箱不合法")
}

if(r.findAllMatchIn(eml2).size > 0) {
    println(eml2 + "邮箱合法")
}
else {
    println(eml2 + "邮箱不合法")
}

14.异常处理-捕获异常

语法格式

try {
    // 代码
}
catch {
    case ex:异常类型1 => // 代码
    case ex:异常类型2 => // 代码
}
finally {
    // 代码
}

15.异常处理-抛出异常

参考代码

  def main(args: Array[String]): Unit = {
    throw new Exception("这是一个异常")
  }

Exception in thread "main" java.lang.Exception: 这是一个异常
	at ForDemo$.main(ForDemo.scala:3)
	at ForDemo.main(ForDemo.scala)

16.提取器(解构器)

样例类自动实现了apply、unapply方法
apply方法，可以用类名来快速构建一个对象。伴生对象中，还有一个unapply方法。与apply相反，unapply是将该类的对象，拆解为一个个的元素。

参考代码

class Student(var name:String, var age:Int)

object Student {
    def apply(name:String, age:Int) = {
        new Student(name, age)
    }

    def unapply(student:Student) = {
        val tuple = (student.name, student.age)

        Some(tuple)
    }
}

def main(args: Array[String]): Unit = {
    val zhangsan = Student("张三", 20)

    zhangsan match {
        case Student(name, age) => println(s"${name} => ${age}")
    }
}

17.泛型-定义泛型方法

泛型：增加方法的通用性
定义泛型方法

object Myo {

def pdT: Unit ={

val b: Boolean = t.isInstanceOf[Map[String,String]]

if(b){

  println("这是一个map集合")
  //强转成map类型
  val map: Map[String, String] = t.asInstanceOf[Map[String,String]]

  //循环打印
  for ((x,y) <- map) println(x+"-->"+y)

}else if(t.isInstanceOf[List[Int]]){
  println("这是一个list集合")
  //强转成list类型
  val list: List[Int] = t.asInstanceOf[List[Int]]
  //循环打印
  list.foreach(println)
}

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

val map: Map[String, String] = Map("name"->"dbf4","sex"->"nan")
val list: List[Int] = List(1,2,3,4)

Myo.pd(list)

}

def getMiddleElement[T](array:Array[T]) =
array(array.length / 2)

def main(args: Array[String]): Unit = {
    println(getMiddleElement(Array(1, 2, 3, 4, 5)))
    println(getMiddleElement(Array("a", "b", "c", "d", "e")))
}

18.泛型-定义泛型类

~~~java
public class Result {

private String message;
private Integer code;
private T data;



//返回成功信息
public static <T> Result success(T t){
    Result<String> stringResult = new Result<>();
    stringResult.setMessage("处理成功");
    stringResult.setCode(200);
    stringResult.setAbcd(t.toString());
    return stringResult;
}

//返回失败的信息
public static <T> Result fail(){
    Result<String> stringResult = new Result<>();
    stringResult.setMessage("处理失败");
    stringResult.setCode(400);
    return stringResult;
}


@Override
public String toString() {
    return "Result{" +
            "message='" + message + '\'' +
            ", code=" + code +
            ", data=" + data +
            '}';
}



public static void main(String[] args) {
    Result success = Result.success("我是处理结果，一个很大的对象");
    System.out.println(success.toString());
    Result fail = Result.fail();
    System.out.println(fail.toString());

}


public String getMessage() {
    return message;
}

public void setMessage(String message) {
    this.message = message;
}

public Integer getCode() {
    return code;
}

public void setCode(Integer code) {
    this.code = code;
}

public T getAbcd() {
    return data;
}

public void setAbcd(T data) {
    this.data = data;
}

public static <T> void m1(T t){
    System.out.println("这是一个泛型方法"+t.toString());

}

public static void m2(Object o){
    System.out.println("这是一个泛型方法"+o.toString());
}

}




**语法格式**

```scala
class 类[T](val 变量名: T)
```

**参考代码**

```scala
case class Pair[T](var a:T, var b:T)

def main(args: Array[String]): Unit = {
  val pairList = List(
      Pair("Hadoop", "Storm"),
      Pair("Hadoop", 2008),
      Pair(1.0, 2.0),
      Pair("Hadoop", Some(1.9))
  )

  println(pairList)
}
```



### 19.泛型-上下界

* 想让泛型，不那么自由，加上约束。输入的参数只能是一定范围内的类型。
* 举例：高铁的 商务座，一等座， 二等座


* 我们在定义方法/类的泛型时，限定必须从哪个类继承、或者必须是哪个类的父类。此时，就需要使用到上下界。
* 定义上界
* 使用`<: 类型名`表示给类型添加一个**上界**，表示泛型参数必须要从该类（或本身）继承
* 使用`>: 类型名`表示给类型添加一个**下界**
* 守住一个底线，如果这个泛型多了（>1），控制不住了。

**参考代码**

```scala
class Person
class Student extends Person

def demo[T <: Person](a:Array[T]) = println(a)

def main(args: Array[String]): Unit = {
  demo(Array(new Person))
  demo(Array(new Student))
  // 编译出错，必须是Person的子类
  // demo(Array("hadoop"))
}
```

* 定义下界
* 下界必须是**某个类的父类**（或本身）

**参考代码**

```scala
class Person
class Policeman extends Person
class Superman extends Policeman

def demo[T >: Policeman](array:Array[T]) = println(array)

def main(args: Array[String]): Unit = {
  demo(Array(new Person))
  demo(Array(new Policeman))
  // 编译出错：Superman是Policeman的子类
  // demo(Array(new Superman))
}
```



### 20.泛型-协变、逆变、非变

* spark的源代码中大量使用到了协变、逆变、非变，学习该知识点对我们将来阅读spark源代码很有帮助。
* **非变**

**语法格式**

```scala
class Pair[T]{}
```

- 默认泛型类是非变的
- 类型B是A的子类型，Pair[A]和Pair[B]没有任何从属关系
- **协变**

**语法格式**

```scala
class Pair[+T]
```

- 类型B是A的子类型，Pair[B]可以认为是Pair[A]的子类型
- **逆变**

```scala
class Pair[-T]
```

- 类型B是A的子类型，Pair[A]反过来可以认为是Pair[B]的子类型

**参考代码**

```scala
class Super
class Sub extends Super

class Temp1[T]
class Temp2[+T]
class Temp3[-T]

def main(args: Array[String]): Unit = {
  val a:Temp1[Sub] = new Temp1[Sub]
  // 编译报错
  // 非变
  //val b:Temp1[Super] = a

  // 协变
  val c: Temp2[Sub] = new Temp2[Sub]
  val d: Temp2[Super] = c

  // 逆变
  val e: Temp3[Super] = new Temp3[Super]
  val f: Temp3[Sub] = e
}
```







### 21.Actor并发编程-Actor介绍

* scala的Actor并发编程模型可以用来开发比Java线程效率更高的并发程序。我们学习scala Actor的目的主要是为后续学习Akka做准备。
* scala在2.11.x版本中加入了Akka并发编程框架，老版本已经废弃。Actor的编程模型和Akka很像，我们这里学习Actor的目的是为学习Akka做准备。

### 22.Actor并发编程-创建Actor

使用class继承Actor创建

```scala
object _05ActorDemo {
class Actor1 extends Actor {
  override def act(): Unit = (1 to 10).foreach(println(_))
}

class Actor2 extends Actor {
  override def act(): Unit = (11 to 20).foreach(println(_))
}

def main(args: Array[String]): Unit = {
  new Actor1().start()
  new Actor2().start()
}
}
```

使用object继承Actor创建

```scala
object Actor1 extends Actor {
 
  
  override def act(): Unit =
    for(i <- 1 to 10) {
      println(i)
    }
}

object Actor2 extends Actor {
  override def act(): Unit =
    for(i <- 11 to 20) {
      println(i)
    }
}

def main(args: Array[String]): Unit = {
  Actor1.start()
  Actor2.start()
}
```



### 23.Actor并发编程-发送接收消息

**发送消息**

我们可以使用三种方式来发送消息：

* 同步：会阻塞当前线程，一直等待当前任务完成，完成之后，才继续运行下面的代码。效率低。
* 异步：不会阻塞当前线程，继续运行下面的代码。效率高。

| **！**  | **发送异步消息，没有返回值**           |
| ------ | -------------------------- |
| **!?** | **发送同步消息，等待返回值**           |
| **!!** | **发送异步消息，返回值是Future[Any]** |

**参考代码**

```scala
object ActorSender extends Actor {
  override def act(): Unit = {
    // 发送消息
    while(true) {
      ActorReceiver ! "hello!"
      TimeUnit.SECONDS.sleep(3)
    }
  }
}

object ActorReceiver extends Actor {
  override def act(): Unit = {
    // 持续接收消息
    while(true) {
      receive {
        case msg:String => println("接收到消息：" + msg)
      }
    }
  }
}

def main(args: Array[String]): Unit = {
  ActorReceiver.start()
  ActorSender.start()
}

会重复创建线程，造成资源浪费
```



### 24.Actor并发编程-持续接收消息

使用loop + react重写上述案例，复用线程。

**参考代码**

```scala
// 持续接收消息
loop {
  react {
      case msg:String => println("接收到消息：" + msg)
  }
}
```



### 25.Actor并发编程-发送接收自定义消息（同步方式）

**参考代码**

```scala
case class Message(id:Int, msg:String)
case class ReplyMessage(msg:String, name:String)

object MsgActor extends Actor {
  override def act(): Unit = {
    loop {
      react {
        case Message(id, msg) => {
          println(s"接收到消息:${id}/${msg}")
          sender ! ReplyMessage("不太好", "Tom")
        }
      }
    }
  }
}

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

  val replyMessage: Any = MsgActor !? Message(1, "你好")
  println("回复消息:" + replyMessage.asInstanceOf[ReplyMessage])
}
```



### 26.Actor并发编程-发送接收自定义消息（异步无返回方式）

**参考代码**

```scala
case class Mesasge(message:String, company:String)

object MsgActor extends Actor {
  override def act(): Unit = {
      loop {
          react {
              case Mesasge(message, company) =>
              println(s"MsgActor接收到消息:${message}/${company}")
          }
      }
  }
}

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

  MsgActor ! Mesasge("中国联通", "大爷，快交话费！")
}
```



### 27.Actor并发编程-发送接收自定消息（异步有返回消息）

**参考代码**

```scala
case class Message(id:Int, message:String)
case class ReplyMessage(message:String, name:String)

object MsgActor extends Actor {
  override def act(): Unit = {
      loop {
          react {
              case Message(id, message) =>
              println(s"MsgActor接收到消息：${id}/${message}")
              sender ! ReplyMessage("收到消息！", "JIm")
          }
      }
  }
}

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

//Future[Any]不一定立马有返回值
  val future: Future[Any] = MsgActor !! Message(1, "你好！")

  while(!future.isSet) {}
//apply:取出封装在Future[Any]里面的Any类型的值
  val replyMessage = future.apply().asInstanceOf[ReplyMessage]
  println(replyMessage)
}
```



### 28.WordCount案例 - 思路分析

* 接下来，我们要使用Actor并发编程模型实现多文件的单词统计。
* 给定几个文本文件（文本文件都是以空格分隔的），使用Actor并发编程来统计单词的数量

### 29.WordCount案例 - 获取文件列表

* **参考代码**

```scala
// 1. MainActor获取要进行单词统计的文件
val DIR_PATH = "./data/"
val dataDir = new File(DIR_PATH)

// 读取所有data目录下的所有文件
println("对以下文件进行单词统计:")
// 构建文件列表
val fileList = dataDir.list().toList.map(DIR_PATH + _)
println(fileList)
```



### 30.WordCount案例 - 创建WordCountActor

* 根据文件数量创建WordCountActor，为了方便后续发送消息给Actor，将每个Actor与文件名关联在一起

**参考代码**

MainActor.scala

```scala
// 2. 根据文件数量创建对应的WordCountActor
val actorList = fileList.map {
  x => new WordCountActor
}

// 将Actor和文件名列表建立为元组
val actorWithFileList: List[(WordCountActor, String)] = actorList.zip(fileList)
```

WordCountActor.scala

```scala
class WordCountActor extends Actor{
override def act(): Unit = {
}
}
```



### 31.WordCount案例 - 启动Actor、发送接收消息

* 启动所有WordCountActor，并发送单词统计任务消息给每个WordCountActor

**参考代码**

MainActor.scala

```scala
// 3. 将文件名封装为消息发送给WordCountActor，并获取到异步返回结果
val futureList = actorWithFileList.map {
  // tuple为Actor和文件名
  tuple =>
  // 启动actor
  tuple._1.start()
  // 发送任务消息
  tuple._1 !! WordCountTask(tuple._2)
}
```

MessagePackage.scala

```scala
/**
* 单词统计任务消息
* @param fileName 文件名
*/
case class WordCountTask(fileName:String)
```

WordCountActor.scala

```scala
loop {
  receive {
      // 接收单词统计任务消息
      case WordCountTask(fileName) => {
          println("接收到消息:" + fileName)
      }
  }
}
```



### 32.WordCount案例 - 消息统计文件单词计数

**实现思路**

读取文件文本，并统计出来单词的数量。例如：

```html
(hadoop, 3), (spark, 1)...
```

**参考代码**

WordCountActor.scala

```scala
// 4. 统计单个文件的单词计数
val iter: Iterator[String] = Source.fromFile(fileName).getLines()
// [第一行] hadoop hadoop
// [第二行] hadoop spark
val lineList = iter.toList
// [单词列表] hadoop, hadoop, hadoop, spark
val wordList: List[String] = lineList.flatMap(_.split(" "))
// 将单词转换为元组
// [元组列表] (hadoop, 1), (hadoop, 1), (hadoop, 1), (spark, 1)
val tupleList = wordList.map(_ -> 1)
// 按照单词进行分组
// [单词分组] = {hadoop->List(hadoop->1, hadoop->1, hadoop->1), spark->List(spark ->1)}
val grouped: Map[String, List[(String, Int)]] = tupleList.groupBy(_._1)
// 将分组内的数据进行聚合
// [单词计数] = (hadoop, 3), (spark, 1)
val wordCount: Map[String, Int] = grouped.map {
  tuple =>
  // 单词
  val word = tuple._1
  // 进行计数
  // 获取到所有的单词数量，然后进行累加
  val total = tuple._2.map(_._2).sum
  word -> total
}
println(wordCount)
```



### 33.WordCount案例 - 封装单词计数结果返回给mainactor

**实现思路**

- 将单词计数的结果封装为一个样例类消息，并发送给MainActor
- MainActor等待所有WordCount均已返回后获取到每个WordCountActor单词计算后的结果

**参考代码**

MessagePackage.scala

```scala
/**
* 单词统计结果
* @param wordCount 单词计数
*/
case class WordCountResult(wordCount: Map[String, Int])
```

WordCountActor.scala

```scala
// 5. 将单词计数结果回复给MainActor
sender ! WordCountResult(wordCount)
```

MainActor.scala

```scala
// 等待所有Actor都已经返回
while(futureList.filter(_.isSet).size != fileList.size){}
// MainActor等待所有的WordCountActor都已经成功返回消息，然后进行结果合并
val resultList: List[Map[String, Int]] = futureList.map(_.apply.asInstanceOf[WordCountResult].wordCount)
println("接收到所有统计结果：" + resultList)
```



### 34.WordCount案例 - 合并结果

**实现思路**

对接收到的所有单词计数进行合并。因为该部分已经在WordCountActor已经编写过，所以抽取这部分一样的代码到一个工具类中，再调用合并得到最终结果

**参考代码**

WordCountUtil.scala

```scala
/**
  * 单词分组统计
  * @param wordCountList 单词计数列表
  * @return 分组聚合结果
  */
def reduce(wordCountList:List[(String, Int)]) = {
  // 按照单词进行分组
  // [单词分组] = {hadoop->List(hadoop->1, hadoop->1, hadoop->1), spark->List(spark ->1)}
  val grouped: Map[String, List[(String, Int)]] = wordCountList.groupBy(_._1)
  // 将分组内的数据进行聚合
  // [单词计数] = (hadoop, 3), (spark, 1)
  val wordCount: Map[String, Int] = grouped.map {
    tuple =>
      // 单词
      val word = tuple._1
      // 进行计数
      // 获取到所有的单词数量，然后进行累加
      val total = tuple._2.map(_._2).sum
      word -> total
  }
  wordCount
}
```

MainActor.scala

```scala
// 扁平化后再聚合计算
val result: Map[String, Int] = WordCountUtil.reduce(resultList.flatten)

println("最终结果:" + result)
```