Scala基础知识

一.写scala可运行文件的注意事项

**
 *  写scala可运行文件的注意事项
 *  1、如果一个scala文件要运行，class要改成object
 *  2、如果是class，就仅单纯代表一个类，如果是object代表的是单例对象
 *  3、scala语法中，一句话结束不需要加分号
 *  4、scala文件中，可以无缝使用java中的类和方法
 */

object HelloWorld {
  def main(args: Array[String]): Unit = {
    println("hello world")

    System.out.println("hello world")
  }
}

二.scala基础

2.1、scala变量与语句

/**
 * 变量：在程序的运行过程中，其值可以发生改变的量
 * 在scala中定义一个变量，需要使用一个关键词：var
 * 注意：
 * 1、变量一旦定义，它的类型就确定，可以不用手动指定类型，根据赋的值自动推断出类型
 * 2、也可以手动的指定变量的数据类型，完整的写法：var 变量名:数据类型 =
 * scala中的数据类型和java的数据类型对应关系：
 * java:              scala:
 * byte                Byte
 * short               Short
 * int                 Int
 * long                Long
 * float               Float
 * double              Double
 * boolean             Boolean
 * char                Char
 */

    val zs: String = "张三说法"
    //    println(zs)


    var b1: String = "hello"
    var b2: String = "scala"
    var b3: String = "niu"
    var str1: String = b1 + "|" + b2 + "|" + b3
    println(str1)

//运算符
var x: Int = 3
var y: Int = 4
println(x + y)
println(x - y)

/**
 * 条件语句
 * 选择语句：if
 * 循环语句：
 */

        val sc: Scanner = new Scanner(System.in)
        print("请输入年龄:")
        val age:Int = sc.nextInt()
        if (age>18){
          println("成年了")
        }else{
          println("未成年")
        }

/**
 * for循环
 * while循环
 */

    //创建一个数组，for循环遍历数组
    val arr2: Array[Int] = Array(11, 22, 33, 44, 55)
        println(arr2(0))
        println(arr2(1))
        println(arr2(2))
        println(arr2(3))
        println(arr2(4))  
 
        for (e<-arr2){
          println(e)
        }
 

   //while循环打印10遍hello kitty 
    var h: Int = 1
    while (h < 10) {
      println("hello kitty")
      h += 1
    }

/**
 * 控制流程语句
 * 在scala中没有break或者continue关键字
 */

    for (e<-1 to 10){
      if (e==5){
        continue //错误报红，scala中没有continue关键字
      }
      println(e)    
-------------------------------------
      breakable{
      for (e <- 1 to 10) {
        if (e == 5) {
          break // 底层实现是一个函数，抛出一个异常，终止程序运行
        }
        println(e)
      }
    }
    
  

2.2、scala读写文件

    //scala中的读取文件的方式
    //Source.fromFil 底层是使用了字节输入流读取数据FileInputStream

    val source: BufferedSource = Source.fromFile("scala/data/word.txt")
    val lineIterator: Iterator[String] = source.getLines()
    while (lineIterator.hasNext){
      val str: String = lineIterator.next()
      println(str)
    }

    // java写文件
    val bw: BufferedWriter = new BufferedWriter(new FileWriter("scala/data/word.txt"))
    bw.write("张三不懂法")
    bw.newLine()
    bw.write("你信吗")
    bw.flush()

//    纯scala中没有写文件的方式！！

2.3、Scala抛出异常

  def main(args: Array[String]): Unit = {
   
      try {
        println(10 / 0)
        val arr1: Array[Int] = Array(1, 2, 3, 4)
        println(arr1(4))
        val sc: Scanner = new Scanner(System.in)
        print("输入除数:")
        val chus: Int = sc.nextInt()
        if (chus != 0) {
          println(chus)
        } else {
          throw new ArithmeticException("你输入的除数为0")
        }
      }catch {
        //类似于sql语句中case when
        case e:ArithmeticException=>
          println("除0异常")
          e.printStackTrace()
        case e:ArrayIndexOutOfBoundsException=>
          println("数组越界异常")
          e.printStackTrace()
        case _=>
          println("出现异常")
      }finally {
        //今后finally中的处理大部分情况下都与释放资源有关
        println("这是finally代码块")
      }

    println("hello scala")

2.4、scala函数

/**
 * def 定义函数或者方法的关键字
 * main 函数或者方法的名字
 * args: 函数形参的名字
 * Array[string]: 参数的数据类型为元素为字符串的数组
 * Unit: 等同于Java中的void 表示无返回值的
 * = : 后面接着函数的方法体
 *
 * 在object中定义 称作函数
 * 在class中定义，称作方法
 */

object Demo5Function {
  def main(args: Array[String]): Unit = {
    //调用函数
        val res1: Int = add1(3, 4)
        println(res1)


    // scala中的函数可以嵌套定义，函数中可以再定义函数
    def plus(x: Int, y: Int): Int = {
      return x + y
    }

    //调用必须在定义之后
    val res2: Int = plus(10, 40)
    println(res2)

    val d1: Demo1 = new Demo1()
    val res3: Int = d1.add2(30, 25)
    println(res3)

    //object中的函数可以使用类名调用,类似于静态一样
    val res4: Int = Demo5Function.add3(100, 200)
    println(res4)

    //调用形式2：object中的函数调用时，可以省略类名
    val res5: Int = add4(100, 150)
    println(res5)

    //如果定义的时候，没有小括号，调用的时候，就不需要加小括号
    add5

    val res6: Int = fun1("20240705")
    println(res6)

    //如果方法调用的函数只有一个参数的时候，可以将.和小括号用空格代替调用
    val res7: Int = Demo5Function.fun1("20240705")
    val res8: Int = Demo5Function fun1 "20240705"
    println(res8)

  }
  //=============================================

  //需求1：定义一个求两个数之和的函数，返回结果
  def add1(a1: Int, b1: Int): Int = {
    a1 + b1
  }

  class Demo1 {
    //这里叫方法，将来调用时需要创建该类的对象才可以调用
    //函数或者方法必须定义在class或者object中
    def add2(a1: Int, b1: Int): Int = {
      a1 + b1
    }
  }

  //定义格式1：如果函数有返回值，且最后一句话作为返回值的话，return关键字可以不写
  def add3(a1: Int, b1: Int): Int = {
    a1 + b1}

  //定义格式2：如果函数体中只有一句实现，那么大括号也可以不写
  def add4(a1: Int, b1: Int): Int = a1 + b1
  //定义格式3：如果函数没有参数的时候,小括号省略不写

  def fun1(s:String):Int={
    return s.toInt
  }
}

/**
 * scala函数递归
 * 方法调用时，调用自身现象
 * 条件：要有出口
 */

object DemoDiGui {
  def main(args: Array[String]): Unit = {
    //求阶乘 5!
    val res: Int = jieCheng(x=5)
    println("5的阶乘是"+res)
    println(s"5的阶乘是$res")
    println(s"5的阶乘是${DemoDiGui.jieCheng(5)}")

  }

  def jieCheng(x: Int): Int = {
    if (x == 1) {
      1
    } else {
      x * jieCheng(x - 1)
    }
  }
}

2.5、scala定义类及样例类

/**
 * 可以在scala程序定义类
 * 类：构造方法 成员方法 成员变量
 *
 * 构造方法：
 * 1、类所拥有的大括号中都是构造代码块的内容
 * 2、默认情况下，每一个类都应该提供一个无参的构造方法
 * 3、构造方法可以有许多
 */

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

  def main(args: Array[String]): Unit = {
    val stu1: Student = new Student("李亮", 18)
    println(stu1)

  /**
   * 定义成员变量
   */
  val _name: String = name
  val _age: Int = age
  var _gender: String = _ // 这个下划线，就表示将来会赋予默认值


  /**
   * 构造方法也可以写多个
   */
  def this(name: String, age: Int, gender: String) {
    this(name: String, age: Int)
    _gender = gender
  }
  println("李亮最爱打王者,还有植物大战僵尸杂交版2.2")

  /**
   * 也可以重写方法
   */
  override def toString:String={
    "姓名:" + _name + ", 年龄:" + _age + ", 性别:" + _gender
  }
}

class Student2{
  def fun1(): Unit = {
    println("hello scala")
  }
}

/**
 * 样例类中的成员变量，编译后默认是被jvm添加了final关键字，用户是改变不了的
 * 对于scala来说，默认是被val修饰的
 * 如果将来想要被改变，定义的时候需要使用var进行修饰
 */

 def main(args: Array[String]): Unit = {
    val p1 = new Person("叶凡", age = 9, "姬紫月")
    println(p1.name)
    println(p1.age)
    println(p1.like)
    println(p1)
}
case class Person(name:String,age:Int, var like:String)

2.6、scala面向对象式编程和函数式编程

/**
 * 面向对象编程：将对象当做参数一样传来传去
 * 1、对象可以当作方法参数传递
 * 2、对象也可以当作返回值返回
 * 当看到类，抽象类，接口的时候，无论是参数类型
 * 还是返回值类型，都需要提供相对应的实现类对象
 *
 * 面向函数式编程：将函数当作参数一样传来传去
 * 1、函数a可以当作函数b的参数进行传递
 * 2、函数a可以当作函数b的返回值类型
 * 在Scala中，将函数看作一个对象，对象就有类型
 */

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

    //是一个参数为字符串类型，返回值是整数类型的函数
        def fun1(s: String): Int = {
          s.toInt + 1000
        }

        val res1: Int = fun1("1000")
        println(res1)

    //定义变量的方式，定义一个函数
    //将函数当作对象，赋值给类型是函数类型的变量，将来可以直接通过变量调用函数
        val fun2: String => Int = fun1
        val res2: Int = fun2("2000")
        println(res2)

/**
 * 函数当作参数传递的应用
 */
object Demo11Fun {
  def main(args: Array[String]): Unit = {
    val arr1: Array[Int] = Array(11, 22, 33, 44, 55, 66)
   
    def fun1(i:Int)={
      println(i*2)
    }
    arr1.foreach(fun1)
    
    //foreach函数需要一个参数和数组元素一样类型的类型，返回值是Unit的函数
    //foreach函数的主要作用是将调用该方法的序列中的元素，依次取出传递给后面的函数进行处理

    // scala自带的一个函数
    // def println(x: Any) = Console.println(x)
    // Any可以接收任意的数据类型元素
    arr1.foreach(println)
  }

2.7、函数柯里化

/**
* 函数柯里化
* 1、本意是原来一次传递多个参数，现在被改成了分开传递的形式，叫做柯里化
* 2、在scala中体现柯里化，是指函数的返回值也是一个函数，将来调用时参数可以分开传递。
* 3、提高了程序的灵活性和代码复用性
* 4、在scala中也可以通过偏函数实现参数分开传递的功能
*/

    //调用函数的返回值是函数的方式1：
    val resFun1: String => Int = fun1("1")
    val r1: Int = resFun1("0")
    val r2: Int = resFun1("1")
    val r3: Int = resFun1("2")
    println(r1)
    println(r2)
    println(r3)

    //方式2
    def function1(s1: String, s2: String): Int = {
      s1.toInt + s2.toInt
    }
      val res: Int = function1("1", "1000")
      println(res)

    /**
     * 偏函数
     */
    val f1:String=>Int=function1("1",_)
    val res1: Int = f1("006")
    val res2: Int = f1("100")
    val res3: Int = f1("210")
    println(s"rea1:$res1,res2:$res2,res3:$res3")
  }

2.8、scala集合

/**
* scala中的集合：
* List: 元素有序，且可以发生重复，长度固定
* Set:  元素无序，且唯一，长度固定
* Map:  元素是键值对的形式，键是唯一的
* Tuple: 元组，长度是固定的，每个元素的数据类型可以不一样
*/

2.8.1 ArrayList

  def main(args: Array[String]): Unit = {
    val list1: util.ArrayList[Int] = new util.ArrayList[Int]()
    list1.add(11)
    list1.add(22)
    list1.add(33)
    list1.add(123)
    list1.add(321)
    print(list1)
    println("=" * 50)

    //scala中的for循环，只能遍历scala中的序列，无法遍历java的序列
    //    for (e <- list1) {
    //    }//报错

    var i = 0
    while (i < list1.size()) {
      println(list1.get(i))
      i += 1
    }

2.8.2 基本函数

  def main(args: Array[String]): Unit = {
    //创建一个scala中的List集合
    val list2: List[Int] = List(34, 11, 22, 11, 33, 44, 55, 22, 75, 987, 1, 12, 34, 66, 77)

    //获取List集合的长度
    println(list2.size)
    println(list2.length)
    
    //可以直接通过索引下标获取元素
    println(list2(0))
    println(list2(1))
    
    println(list2.head)//scala获取第一个元素的方式是调用head函数
    println(list2.last)

    //根据指定的分隔符拼接元素
    println(list2.mkString("|"))
    
    val resList1: List[Int] = list2.reverse //返回一个新的集合
    println(s"list2:$list2")//原来的集合
    println(s"resList1:$resList1")//新的集合
   
    val resList2: List[Int] = list2.distinct //返回一个新的集合
    println(s"list2:$list2")
    println(s"resList2:$resList2")
   
    val resList3: List[Int] = list2.tail // 除去第一个，其余的元素返回一个新的集合
    println(s"list2:$list2")
    println(s"resList3:$resList3")
   
    val resList4: List[Int] = list2.take(5) // 从左向右取元素，取若干个
    println(s"list2:$list2")
    println(s"resList4:$resList4")
    println("=" * 50)

    val resList5: List[Int] = list2.takeRight(5) //取右边的几个，组成新的集合
    println(s"list2:$list2")
    println(s"resList5:$resList5")
    println("=" * 50)

    //从第一个判断取数据，直到不符合条件停止
    val resList10: List[Int] = list2.takeWhile((e: Int) => e % 2 == 0)
    println(s"list2:$list2")
    println(s"resList10:$resList10")
    println("*" * 50)
    val res1: Int = list2.sum // 元素必须是数值
    println(s"集合中的元素和为：$res1")
    
    val res2: Int = list2.max
    println(s"集合中的元素最大值为：$res2")
    
    //集合的遍历
    for (e <- list2) {
      println(e)
    }
   

2.8.3 高阶函数

    /**
     * 高阶函数:
     * foreach: 将集合中的元素依次取出传入到后面的函数中
     * 注意：没有返回值的，要么就输出，要么就其他方式处理掉了
     */
    //def foreach[U](f: A => U)
    //    list2.foreach((e: Int) => println(e))
    //    list2.foreach(println)
    //需求1：使用foreach求出集合中偶数的和
    var ouSum = 0
    var jiSum = 0
    list2.foreach((e: Int) => {
      if (e % 2 == 0) {
        ouSum += e
      } else {
        jiSum += e
      }
    })
    println(s"集合中偶数之和为：$ouSum")
    println(s"集合中奇数之和为：$jiSum")
    println("=" * 50)
    /**
     * 高阶函数:
     * map: 依次处理每一个元素，得到一个新的结果，返回到一个新的集合中
     */
    val list3: List[Int] = List(1, 2, 3, 4, 5, 6, 7, 8, 9)
    //需求2：将集合中的每一个元素*2
    val resList6: List[Int] = list3.map((e: Int) => e * 2)
    println(s"list3:$list3")
    println(s"resList6:$resList6")
    println("*" * 50)

    /**
     * 高阶函数:
     * filter: 保留符合条件的元素
     */
    val list4: List[Int] = List(4, 7, 9, 10, 12, 11, 14, 9, 7)
    val resList7: List[Int] = list4.filter((e: Int) => e % 2 == 0)
    println(s"list4:$list4")
    println(s"resList7:$resList7")

    /**
     * 高阶函数:
     * sortBy: 排序
     * sortWith: 两个数之间的关系排序
     */
    println("=" * 50)
    val resList8: List[Int] = list4.sortBy((e: Int) => -e)
    println(s"list4:$list4")
    println(s"resList8:$resList8")
    val resList9: List[Int] = list4.sortWith((x: Int, y: Int) => x > y)
    println(s"list4:$list4")
    println(s"resList9:$resList9")

    /**
     * 高阶函数:
     * flatMap: 扁平化
     */
    println("=" * 50)
    val list5: List[String] = List("hbase|scala|java", "hello|dataX|aliyun", "python|spark|hadoop")
    val fMp: List[String] = list5.flatMap((e: String) => e.split("\\|"))
    fMp.foreach(println)

    /**
     * 高阶函数:
     * groupBy: 分组
     */
    val list6: List[String] = List("aliyun", "spark", "java", "hadoop", "flink", "java", "hadoop", "flink", "flink", "java", "hadoop", "flink", "java", "hadoop", "aliyun", "world", "java", "hadoop", "aliyun", "spark", "java", "hadoop")
    val map: Map[String, List[String]] = list6.groupBy((e: String) => e)
    for (e <- map) {
      println(e)
    }

2.8.4 set集合

    /**
     * set集合：scala中Set集合不可变，除了排序相关的函数以外，List集合有的高阶函数，Set集合也有
     */
    val set1: Set[Int] = Set(1, 4, 3, 6, 5)
    val set2: Set[Int] = Set(3, 6, 5, 7, 8)
    println(s"set1: ${set1}")
    println(s"set2: ${set2}")


    /**
     * Set集合和List集合可以互相转换
     */
    val list1: List[Int] = List(11, 22, 33, 44, 55, 11, 22, 44, 88, 33, 44, 99, 11, 22, 55)
    //List->Set
    val resSet4: Set[Int] = list1.toSet
    println(s"list1:${list1}")
    println(s"resSet4:${resSet4}")
    
    //Set->List
    val list2: List[Int] = resSet4.toList.sortBy((e:Int)=>e)
    println(s"list1:${list1}")
    println(s"resSet4:${resSet4}")
    println(s"list2:${list2}")

2.8.5 可变,不可变集合

  def main(args: Array[String]): Unit = {
    /**
     * 不可变的集合是属于scala.collection.immutable包下的
     * 可变的集合，scala.collection.mutable包下寻找
     */
    //创建一个可变的List集合
    val listBuffer1: ListBuffer[Int] = new ListBuffer[Int]
    println(listBuffer1)
    listBuffer1.+=(11)
    listBuffer1.+=(22)
    listBuffer1.+=(33)
    listBuffer1.+=(11)
    listBuffer1.+=(55)
    listBuffer1.+=(22)
    listBuffer1.+=(33)
    listBuffer1.+=(66)
    listBuffer1.+=(33)
    println(listBuffer1)
    
    //获取元素
    println(listBuffer1(2))
    println(listBuffer1.head)
    println(listBuffer1.last)
    /**
     *  可变List集合,list功能函数可以调用
     */
    println("=" * 50)
    //删除元素
    //ListBuffer(11, 22, 33, 11, 55, 22, 33, 66, 33)
    listBuffer1.-=(33) //从左向右找元素，只会删除第一次找到的
    println(listBuffer1)
    println("=" * 50)
    //批量添加元素
    listBuffer1.+=(100,220,300,400)
    println(listBuffer1)

    /**
     * 可变的Set集合
     */
    val hashSet1: mutable.HashSet[Int] = new mutable.HashSet[Int]()
    val set1: hashSet1.type = hashSet1.+=(1, 2, 3, 4, 5, 7, 1, 2, 3, 1, 6, 5)
    println(set1)
  }

2.8.6 元组

/**
 * 大小,值是固定的，根据创建的类来定，每个元素的数据类型可以是不一样，最高可以创建存储22个元素的元组
 */
object Demo17Tuple {
    def main(args: Array[String]): Unit = {
    val tuple1: (Int, String, String, Int, String) = Tuple5(1001, "张三", "男", 18, "说法")
    println(tuple1)
    println("="*50)

    val s2 = new Student1(1002, "李四", 18, "看剧")
    val t2: (Int, Student1) = Tuple2(1002, s2)
    println(t2)
    println(t2._1)
    println(t2._2.name)
  }
}

case class Student1(id: Int, name: String, age: Int, like: String)

2.8.7 map集合

object Demo19Map {
  def main(args: Array[String]): Unit = {
    //创建Map集合
    //键是唯一的，键一样的时候，值会被覆盖
    val map1: Map[Int, String] = Map((1001, "张三"), (1002, "李四"), (1003, "王五"), (1004, "赵六"))
    println(map1)
    println("=" * 50)

    //可以根据键获取值
    //    println(map1(1006))// 小括号获取值，键不存在报错
    //    println(map1.get(1007))// get函数获取，键不存在，返回None

    println(map1.getOrElse(1003, 0)) //根据键获取值，若键不存在，返回提供的默认值，默认值的类型可以是任意数据类型

    val keys: Iterable[Int] = map1.keys //获取所有的建
    for (e <- keys) {
      println(e)
    }
    println("=" * 50)

    //遍历Map集合第一种方式，先获取所有的键，根据键获取每个值
    val keys1: Iterable[Int] = map1.keys
    for (e <- keys1) {
      val v: Any = map1.getOrElse(e, 0)
      println(s"键:${e},值:${v}")
    }

    //遍历Map集合第二种方式，先获取所有的键，根据键获取每个值
    for (kv <- map1) { // 直接遍历map集合，得到每一个键值对组成的元组
      println(s"键:${kv._1},值:${kv._2}")
    }

    //遍历Map集合第三种方式，先获取所有的键，根据键获取每个值
    map1.foreach((kv: (Int, String)) => println(s"键:${kv._1},值:${kv._2}"))
    }
}

2.9 统计单词个数

  def main(args: Array[String]): Unit = {
    val lineList: List[String] = Source.fromFile("scala/data/word.txt").getLines().toList
    println(lineList)
    //2、将每一行数据按照|切分，并且进行扁平化
    val wordsList: List[String] = lineList.flatMap((line: String) => line.split("\\|"))
    println(wordsList)
    //3、根据元素进行分组
    val wordKV: Map[String, List[String]] = wordsList.groupBy((e: String) => e)
    println(wordKV)

    val wordCount: Map[String, Int] = wordKV.map((kv: (String, List[String])) => {
      val word: String = kv._1
      val count: Int = kv._2.size
      (word, count)
    })

    val resultList: List[(String, Int)] = wordCount.toList
    resultList.foreach(println)
    println("=" * 50)

    /**
     * 使用链式调用的方式简写
     */
    Source.fromFile("scala/data/word.txt").getLines()
      .toList
      .flatMap((line:String)=>line.split("\\,"))
      .groupBy((e:String)=>e)
      .map((kv:(String,List[String]))=>{
        val word: String = kv._1
        val count: Int = kv._2.size
        (word,count)
      })
      .toList
      .foreach(println)

三. scala基础

3.1、DemoJDBC

/**
 *  jdbc的链接步骤
 *    1、注册驱动
 *    2、创建数据库链接对象
 *    3、创建数据操作对象
 *    4、执行sql语句
 *    5.分析查询结果
 *    6、释放资源
 */

  def main(args: Array[String]): Unit = {
    //1.注册驱动
    Class.forName("com.mysql.jdbc.Driver")

    //2.创建数据库连接对象
    //jdbc:数据库名//host:port/数据库?xxx=xxx&xxx=xxx
    val conn: Connection = DriverManager.getConnection("jdbc:mysql://192.xxx.xxx.xxx:3306/studentdb?useUnicode=true&characterEncoding=UTF-8&useSSL=false", "root", "12345678")

    //3.创建数据库操作对象
    val preparedStatement: PreparedStatement = conn.prepareStatement("select id,name,age,gender,clazz from students where clazz=?")

    //4、执行sql语句
    preparedStatement.setString(1,"理科二班")
    val resultSet: ResultSet = preparedStatement.executeQuery()

    //5、如果第4步是查询的话，分析查询结果
    while (resultSet.next()){
      val id: Int = resultSet.getInt("id")
      val name: String = resultSet.getString("name")
      val age: Int = resultSet.getInt("age")
      val gender: String = resultSet.getString("gender")
      val clazz: String = resultSet.getString("clazz")
      println(s"学号:$id,姓名:$name,年龄：$age, 性别：$gender, 班级：$clazz")

    //6.释放资源
    conn.close()

    }

  }

3.2、 scala集合与java集合转换

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

    //创建一个java中的集合
    val array1: util.ArrayList[Int] = new util.ArrayList[Int]()
    array1.add(11)
    array1.add(22)
    array1.add(33)
    array1.add(55)
    array1.add(66)
    array1.add(44)
    println(array1)

    /**
     * 将java中的集合转成scala中的集合
     * java中的集合本来是没有转换scala的功能，需要导入隐式转换
     * scala中的导包，可以在任意地方
     */

    import scala.collection.JavaConverters._
    val scala1: List[Int] = array1.asScala.toList
    println(scala1)

    /**
     * scala中的集合转java的集合
     */
    val java1: util.List[Int] = scala1.asJava
    println(java1）

  }
}

3.3、模式匹配

/**
 * 模式匹配,可以帮助我们开发的时候，减少代码量，
 * 让逻辑看起来更清晰，避免一些异常
 *
 * 语法:
 * 表达式 match{
 * case 值|[变量名:类型]|数组|对象|元组=>
 * 匹配成功执行的语句
 * case xxx=>
 * xxx
 * _ xxx=>
 * xxx
 * }
 * 模式匹配中，如果没有对应匹配，那么就报错！！！
 */

    /**
     * 匹配变量值
     */
    var i: Int = 100
    i match {
      case 10=>println("该值是10")
      case 50=>println("该值是50")
      case 100=>println("该值是100")
      case _=>("该值是其他值")
    }

    /**
     * 匹配数据类型
     */
    var flag1:Any="true"
    flag1 match {
      case _:Int=>println("是Int类型")
      case _:String=>println("是String类型")
      case _:Boolean=>println("是Boolean类型")
    }

    /**
     * 匹配元组
     */
    val tuple1: (Int, String, Int, String) = Tuple4(1001, "汤姆", 20, "抓老鼠")
    tuple1 match {
      case (a1:Int,a2:String,a3:Int,a4:String)=>
        println(s"学号:$a1,姓名:${a2},年龄:${a3},爱好:${a4}")
    }

    /**
     * 匹配数组
     */
    val array: Array[Any] = Array(1002, "小李", "男", 18, "小李飞刀")
    array match {
      case Array(id:Int,name:String,gender:String,age:Int,skill:String)=>
        println(s"证件:$id, 姓名:$name, 性别:$gender,年龄:$age,技能:$skill")
    }


    /**
     * 模式匹配的应用1:避免异常
     */
    val map: Map[Int, String] = Map((1001, "黑小虎"), (1002, "双面龟"), (1003, "沸羊羊"))
    val res1: Option[String] = map.get(1001)
    val res2: Option[String] = map.get(1002)

    val sc = new Scanner(System.in)
    println("请输入您要查询的键:")
    val key: Int = sc.nextInt()
    map.get(key) match {
      case Some(a:Any)=>println(s"${key}键对应值为$a")
      case None=>println(s"${key}键不存在！")
    }

    /**
     * 模式匹配的应用2：简化代码
     */
    val stuList: List[String] = Source.fromFile("scala/data/students.txt").getLines().toList
    val stuArrayList: List[Array[String]] = stuList.map((line: String) => line.split(","))

    stuArrayList.map {
    case Array(id:String,name:String,age:String,gender:String,clazz:String)=>
        (id,name,age,gender,clazz)
    }.foreach(println)

3.4、隐式转换

/**
 * 隐式转换
 * 1.隐式转换函数
 * 2.隐式转换类
 * 3.隐式转换变量
 * 将一个a类型将来会自动的转换成b类型，类型可以是1.基本数据类型2.引用数据类型
 */

3.4.1、隐式转换函数

    //需求：调用fun1函数，只传字符串，不会报错
    //定义隐式转换函数
    //在需要返回值类型的时候，自动的根据已有隐式转换函数将参数类型转换成返回值类型
    //implicitFun1:名字随便起，无所谓
    implicit def implicitFun1(s: String): Int = {
      return Integer.parseInt(s)
    }

      /**
       * 隐式转换类型区分重复：看implicitFun1和implicitFun2参数类型和返回值类型是否一致
       * @param s
       * @return
       */
//    implicit def implicitFun2(s: String): Int = {
//      return Integer.parseInt(s) + 2000
//    }
//
//
//    def fun1(s: Int): Int = {
//          return s + 1000
//        }
//    //调用函数
//        println(fun1(100))
//        println(fun1(200))
//        println(fun1("300"))
    /*===========================================================================*/


    import com.shujia.jichu.Demo99._ //第二种方法，导用包下的方法进行隐式转换
   
    //implicit def implicitFun3(s: String): BufferedSource = 
    Source.fromFile(s)//第一种方法
    //"scala/data/score.txt".getLines().toList.foreach(println)

    val scoList: List[String] = "scala/data/score.txt".getLines().toList
    val stuList: List[String] = "scala/data/students.txt".getLines().toList

    println("1000" + 500) // 1000500 // 使用字符串自身的+拼接功能，做字符串拼接
    println("1000" - 500) // 500   // 字符串中没有-减法功能，自动使用隐式转换中的函数，将字符串转成数字做减法
    println("2000" - 500) // 1500   // 字符串中没有-减法功能，自动使用隐式转换中的函数，将字符串转成数字做减法

  }
}
object Demo99 {
  implicit def implicitFun3(s: String): BufferedSource = Source.fromFile(s)

  implicit def implicitFun1(s: String): Int = Integer.parseInt(s)
}

3.4.2、隐式转换类

package com.shujia.jichu
import scala.io.Source

object Demoimplicit {
  /**
   * 隐式转换类
   */
  def main(args: Array[String]): Unit = {
    val demo1 = new Demo66("scala/data/students.txt")
    demo1.show().foreach(println)//第一种方法
    val stuList1: List[String] = demo1.show()


    val stuList: List[String] = "scala/data/students.txt".show()//第二种：直接通过路径调用show方法得到集合
//    val scoList: List[String] = "scala/data/score.txt".show()  //scala/data/score.txt会自动把String类型转成Demo66对象，对象再调用show方法

    "张三".f()
  }

  implicit class Demo66(path:String){//类的构造方法的类型转换成对象的类型
    def show():List[String]={
      Source.fromFile(path).getLines().toList
    }

    def f()={
      println(s"${path}:好好学习，一天一忘！")
    }

  }
}

3.4.3、 隐式转换变量

object Demoimplicit {
  def main(args: Array[String]): Unit = {
    /**
     * 隐式转换变量
     */

    //定义一个隐式转换参数
    def hanShu(a1: Int)(implicit b1: Int): Int = a1 + b1

    //定义一个隐式转换变量
    implicit var i:Int=1000

    val res1: Int = hanShu(a1=10)
    println(res1)

  }
}