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)

  }
}