Scala编程基础7：模式匹配、隐式转换详解

一、模式匹配

概念：类似于java中的switch，scala中的模式匹配，可以匹配基本数据类型，字符串，对象，元组，数组等

1、匹配基本数据类型

    val a: Int = 100
    a match {
      case 10 => println("i的值为10")
      case 100 => println("i的值为100")
      case _ => println("未知")
    }

2、模式匹配：case语句中添加if条件判断（守卫）

 print("请输入一个数字:")
    val i: Int = StdIn.readInt()
    i match {
      case res1 if i < 0 => println("该数为负数")
      case res2 if i > 0 => println("该数为正数")
      case _ => println("该数为0")
    }

3、匹配字符串数据类型

 val c: String = "星期一"
    val res1: String = c match {
      case "星期二" => "去春游"
      case "星期一" => "去学习"
      case _ => "睡大觉"
    }
    println(res1)
  }

4、匹配元组

  val tuple3: (String, String, Int) = Tuple3("张三", "安徽", 18)
  tuple3 match {
    case ("李四", "安徽", 18) => println("该元组信息属于李四")
    case ("张三", "安徽", 18) => println("该元组信息属于张三")
    case _ => println("未知")
  }

5、匹配数组

  val array: Array[String] = Array[String]("1001", "张三")
  array match {
    case Array(id: String, name: String) => println(s"学号：${id},姓名：${name}")
    case Array(id: String, name: String, address: String) => println(s"学号：${id},姓名：${name},地址：${address}")
  }

6、匹配值的类型

val obj: Any = true
  obj match {
    case a: Int => println("Int类型")
    case b: String => println("String类型")
    case c: Any => println("其他类型")
  }

7、模式匹配避免报错

/**
   * Option类型，可以用来有效避免空引用(null)异常。也就是说，将来我们返回某些数据时，可以返回一个Option类型来替代。
   * scala中，Option类型来表示可选值。这种类型的数据有两种形式：
   * Some(x)：表示实际的值
   * None：表示没有值
   */
  //引入：
  val map1: Map[String, String] = Map("1001" -> "张三", "1002" -> "李四")
  println(map1.get("1001")) //Some(张三)
  println(map1.get("1003")) //None
 
  //由引入可知，当map中的键不存在，调用get方法会返回None值,现在我们需要给不存在的键一个默认值
  //方式1：getOrElse
  println(map1.getOrElse("1003", "默认id:1000")) //默认id:1000
  //方式2：模式匹配
  val result: String = map1.get("1003") match {
    case Some(v) => v
    case None => "默认id:1000"
  }
  println(result) //默认id:1000

8、模式匹配结合函数使用

//需求：取出文件中每个学生的姓名和地址
  val arrList: List[Array[String]] = Source.fromFile("scala/data/student")
    .getLines()
    .toList
    .map((line: String) => line.split(","))
 
  //模式匹配使用map函数，需要将（）换成{}
  private val tuples: List[(String, String)] = arrList.map {
    case Array(id: String, name: String, age: String, address: String) => (name, address)
  }
  tuples.foreach(print) //(张三,安徽合肥)(李四,安徽芜湖)(王五,江苏南京)

二、隐式转换

概念：隐式转换：动态的让对象增加方法，包括隐式转换函数、隐式转换类、隐式转换变量

1、隐式转换函数

object ImplicitDemo12 {
  def main(args: Array[String]): Unit = {
    //显式类型转换1
    val a: String = "1001"
    val b: Int = a.toInt
    println(b)
 
    //显式类型转换2
    def fun1(s: String): Unit = {
      println(s.toInt)
    }
    fun1(1001.toString)
 
    /**
     * 定义一个隐式转换函数：可以将参数类型转换成返回值类型
     *
     * 注：
     * 1、scala编译器，在编译代码的时候，会识别到需要将A类型转B类型，然后就去找参数是A类型，返回值是B类型的隐式转换函数，自动调用，否则找不到报错
     * 2、只针对参数类型和返回值类型，和隐式函数叫什么无关
     * 3、同一种参数和返回值类型组合的隐式转换函数，同一作用域下只能出现一种
     */
 
    implicit def intToString(s: Int): String = {
      s.toString
    }
 
    fun1(100)  //等价于 fun1(intToString(100))
 
 
  }
}

2、隐式转换类

object ImplicDemo13 {
  def main(args: Array[String]): Unit = {
   //定义隐式转换类的时候，定义在object中
    implicit class Read(path:String){
     def read(): List[String] = {
       Source.fromFile(path).getLines().toList
     }
   }
 
    /**
     * 隐式转换类的调用：
     * 隐式转换类可以隐式的将类的构造函数参数类型转换成当前类的类型，自动调用构造方法创建对象
     */
 
    val list: List[String] = "scala/data/she_hui_zhu_yi".read()
    println(list)  //List(富强、民主、文明、和谐，, 自由、平等、公正、法治，, 爱国、敬业、诚信、友善)
 
 
  }
}

3、隐式转换变量

object ImplicDemo14 {
  def main(args: Array[String]): Unit = {
    //是返回值是函数的简写，其实就是函数柯里化
    def add(x: Int)(implicit y: Int): Int = {
      x + y
    }
 
    //定义一个隐式转换变量
    implicit val a:Int = 1000
    val res: Int = add(200)
    println(res)
 
    //隐式转换变量的应用：
    //观察fromFile源码可知，该方法也可以传隐式转换变量,加入参数可以指定编码读取文件
    Source.fromFile("scala/data/she_hui_zhu_yi")(Codec("utf-8"))
  }
}