Scala（一）基础语法、条件控制、函数、数组，Map与Tuple

1. 声明变量

   1. val：类似于Java里的常量，一旦赋值就不能在改变。例如：

      val result = 1
      val person =new Persion()
      //以下两行会报错，因为val类型的变量不允许再次被赋值或者被引用
      val result = 2 
      val person =new PersionSub()

   2. var：类似于Java里的变量，可以随意赋值改变

      var result = 1 
      var person =new Persion()
      //以下不会报错，因为常量可以随意赋值
      var result = 2 
      var person =new PersionSub()

   3. 声明多个变量

      var firtst,last = 0
      var firtst,last = "li"

2. 条件表达式,条件表达式里的最后一行作为返回值，这一点跟Java是有所区别的

   1. if：后边没有跟else，如果if里的判断为false，那么返回值为就会是默认的Unit()，类似于Java里的void或者是null

      print(if(false){}) //控制台输出的结果为()

   2. if( false | true){ } else{ } ：if代码块里与else代码块里的数据类型可以不一致，那么返回值类型为他们的公共父类 Any类型

      val result = if(false|true){ 
                          "a" 
                    } else{
                           1 
                    }
      print(result) //那么返回值类型为Any

   3. if( ){ } else if( ) { } else{ }：符合要求的代码块会以最后一行为返回值

3. 循环语句

   1. while do

      var n =10
      while(n<10){
          println(n)
          n -=1
      }

   2. for循环：scala没有类似于java的for循环只能使用while代替for循环或者使用简易版的for语句

      var n = 10
      for(i <- 1 to n){
          println(i)
      }
      
      for(i  <- "hallo word"){
          print(i)
      }
      
      for(i <- 1 to 10){
          print(i) //不包含10
      }

   3. 双重for循环

      for (i <- 1 to 10;j <- 1 to 10){
          println(i*j)
        }

   4. for循环带有if表达式：

       for (i <- 1 to 10 if  i ==2;j <- 1 to 10 if j==2 ){
          println(i*j)
        }

   5. for推到式：构建一个集合

   val lists  = for (i<-1 to 10) yield i 
     print(lists)

4. 函数

   1. 函数入门

      object Learn2 {
        def main(args: Array[String]): Unit = {
          print(sayHello("liyz", 15))
          print(sum(1))
        }
      
        //返回值类型scala会自动推断出返回值类型
        def sayHello(name: String, age: Int) = {
          if (age > 10) {
            print("未成年人")
            age //返回值
          } else {
            print("成年人")
            age //返回值
          }
        }
      
        def sum(age: Int): Any = {
          var result = 2
          for (i <- 1 to 10) {
            result += i
          }
          result //返回值
        }
      }

   2. 函数之默认参数与带名参数：在sacla中我们调用某些函数时，不希望给出参数的具体值。而是希望使用默认参数值，此时就可以定义函数参数的默认值，如果参数不够会从左向后一次应用参数

      object Learn2 {
        def main(args: Array[String]): Unit = {
            print(sayHello("liyuzhi")) 
        }
        //第一个参数为必须传的参数，后俩个为不是必须传的参数，如果调用该方法传后俩个参数，则默认值被覆盖
        def sayHello(firstName:String,name:String="liyzhi",lastName:String="xiaolizi"): Any ={
          val n = firstName+"-"+name+"-"+lastName
          n
        }
      }

   3. 函数之变长参数：利用*

      1. 单纯的只有一个可变长参数

         object Learn2 {
           def main(args: Array[String]): Unit = {
              print(moreParam(1,2,3,4,5,6,7,8,9,10))
           }
         def moreParam(param:Int*): Any ={
             var num =0
             for (elem <- param) {
               num+=elem
             }
             num+param2
           }
          }

      2. 单个参数与可变长参数混用：可变长参数一定要放在参数列表的最后边

         object Learn2 {
           def main(args: Array[String]): Unit = {
             print(moreParam("a",2,3,4,5,6,7,8,9,10))
           }
           //可变长参数一定要放在最后边，否则语法错误
           def moreParam(param2:String,param:Int*): Any ={
             var num =0
             for (elem <- param) {
               num+=elem
             }
             num+param2
           }
         }
         

      3. 函数之已有序列调用变长参数函数，是不对的，例如val s = sum(1 to(5)) 。此时需要使用Scala特殊的语法（ val s = sum(1 to(5):_*) ）来将参数定义为序列，让Scala解释器识别改序列。

         package com.lyz 
         object Learn3 {
           def main(args: Array[String]): Unit = {
         
             print(sum(1 to 10:_*)) //利用已有的序列调用可变长参数函数，需要加上能够让Scala识别的语法来标记该参数是一个已有序列
         
           }
         
           def sum(age: Int*): Int = {
             var sum = 0
             if (age.isEmpty) {
               print(1)
               0
             } else {
               for (elem <- age) {
                 sum += elem
               }
               sum
             }
         
           }
         }
         

5. Scala惰性赋值：lazy的使用。有时候我们在使用变量的时候希望在用到的时候再去初始化，并且不再被重复计算，那么我们就会用到Lazy这个关键字去修饰声明变量，并且Lazy只能修饰val 所声明的变量。应用场景为文件IO，网络IO，初始化数据库连接等等。

   object Learn3 {
     def main(args: Array[String]): Unit = {
       lazy val result = init() //懒加载，只有调用的时候才会初始化
       println("1") //首先打印的是 1
       println(result) //第二打印的是 "初始化init"，第三打印的是 2
   
   
       //如果去掉lazy那么根据程序执行的顺序他就会先初始化init函数，打印的顺序是，第一打印的是 "初始化init"，第二打印的是 1，第三打印的是 2
     }
     def init(): Int = {
       println("初始化init")
       2
     }
    }

6. Scala异常：根Java的异常语法很相似

   def main(args: Array[String]): Unit = {
       def detailException(): Unit = {
         try {
           val f = new FileReader("")
         } catch {
           case IOException => { //跟java有所区别的地方
             println("this is IOException")
           }
           case IllegalArgumentException => {
             println("IllegalArgumentException")
           }
         } finally { //跟java执行机制一样，都会执行该代码块的代码
           println("contine process")
         }
     }
   

7. 数组：对应Java里的数组

   1. 数组之Array：在Scala中Array代表的含义与Java中的类似，也是长度不可变的数据，此外由于Scala与Java都运行在Java虚拟机上，地方可以互相调用，因此Scala的数据的底层就是Java数据，例如字符串数据就是Java中的String[],整数数据就是Java中的 int[]

      package com.lyz
      
      object Learn4 {
        def main(args: Array[String]): Unit = {
      
          //初始化数组，并指定数组的长度
          val strAarry = new Array[String](10)//声明长度为10的字符串数组，默认值就是数据类型的默认值，每个元素的默认值是0
          val intArray= new Array[Int](10)//声明长度为10的整数数组，每个元素的默认值为 null
      
          //直接使用Array创建数据
          val strAarry1 = Array("aaaa","bbbbbb")
          val intArray2 = Array(1,2,3,4,5)
          val anyArray = Array(2,3,4,"resutl") //Sacla会自动推断数据类型，改数组的数据类型是Any类型  
        }
      }

   2. 数组之ArrayBuffer：跟Java里的ArrayList类似，是一个可变长度的数组

      package com.lyz
      
      import scala.collection.mutable.ArrayBuffer
      
      object Learn4 {
        def main(args: Array[String]): Unit = {
          //直接使用Array创建数据
          val strAarry = Array("aaaa", "bbbbbb")
      
          val arrayBuffer = new ArrayBuffer[String]() //创建一个可变长数组
          arrayBuffer += "b0" //向可变长数组里添加单个元素
          arrayBuffer += ("b1", "b2", "b3") //像可变长数组里添加多个元素
      
          var arrayBuffer1 = new ArrayBuffer[String]() //创建第二个可变长数组
          arrayBuffer += ("a4", "a5", "a6") //向数组里添加多个元素
      
          arrayBuffer ++= arrayBuffer1 //将一个数组的全部元素添加到另一个数组里
      
          arrayBuffer.remove(0) //移除指定位置的元素
          arrayBuffer.insert(0, "a", "a8") //在指定的位置插入元素,将"a"插入到0下标的位置，"a8" 插入下标为1的位置
          arrayBuffer.remove(1)
      
          arrayBuffer.trimEnd(1) //从尾部截断指定个数的元素
          arrayBuffer.trimStart(1) //从开头截断指定个数的元素
      
          arrayBuffer.toArray //将ArrayBuffer转化成Aarry
          arrayBuffer.toBuffer //将Arrary转换成AarryBuffer
      
          //遍历数组里的元素
          for (elem <- arrayBuffer) {
            println(elem)
          }
          for (elem <- arrayBuffer.indices) {
            println(arrayBuffer(elem))
          }
      
          //倒叙遍历
          for (elem <- arrayBuffer.distinct.reverse) {
            println(elem)
          }
      
          //跳跃遍历，步长为2
          for (elem <- 0 until(arrayBuffer.length, 2)) {
            println(arrayBuffer(elem))
          }
      
          println(arrayBuffer.sum) //数组求和，一定是数值类型
          println(arrayBuffer.min)//数组最小值，一定是数值类型
          println(arrayBuffer.max)//数组最大值，一定是数值类型
          println(arrayBuffer.sorted)//数组排序
      
          //指定每个元素下标位置进行排序
          for (elem <- arrayBuffer.sortBy(_.charAt(0))) {
            println(elem)
          }
          println(arrayBuffer.mkString(",")) //将数组里的每个元素利用 "," 拼接起来，返回值为String，控制台打印为：b1,b2,b3,a4,a5
      
          println(arrayBuffer.mkString) //将数组里的元素拼起来  控制台打印为：b1b2b3a4a5
      }
      

      object Learn4 {
        def arrayBufferConversion(arrayBuffer: ArrayBuffer[String]): ArrayBuffer[String] = {
      
          /**
            * 第一种方式是利用yield 语法来转换，利用filter过滤含有"a"字符串的元素
            * 打印结果为：
            * a4：conversion is ok
            * a5：conversion is ok
            * a6：conversion is ok
            */
      
          val change = for (elem <- arrayBuffer.filter(_.contains("a"))) yield elem + "：conversion is ok" //对数组进行转换，而不改变原来的的数组
          for (elem <- change) {
            println(elem)
          }
      
          /**
            * 第二种为利用map函数来转换，过滤条件为元素里包含"a"的元素
            * 打印结果为：
            * a4：conversion is ok map
            * a5：conversion is ok map
            * a6：conversion is ok map
            */
          for (elem <- arrayBuffer.filter(_.contains("a")).map(_ + "：conversion is ok map")) {
            println(elem)
          }
      
          /**
            * 元数据没有被改变
            * 打印结果为：
            * b0
            * b1
            * b2
            * b3
            * a4
            * a5
            * a6
            */
      
          for (elem <- arrayBuffer) {
            println(elem)
          }
          arrayBuffer
        }
      
        def main(args: Array[String]): Unit = {
          val arrayBuffer = new ArrayBuffer[String]() //创建一个可变长数组
          arrayBuffer += "b0" //向可变长数组里添加单个元素
          arrayBuffer += ("b1", "b2", "b3") //像可变长数组里添加多个元素
      
          var arrayBuffer1 = new ArrayBuffer[String]() //创建第二个可变长数组
          arrayBuffer += ("a4", "a5", "a6") //向数组里添加多个元素
          arrayBuffer ++= arrayBuffer1 //将一个数组的全部元素添加到另一个数组里
        }
      
      }

   3. Map：一键值对存在的一种数据结构，创建Map的时候默认长度是不可变的

      package com.lyz
      
      import scala.collection.{SortedMap, mutable}
      import scala.collection.mutable.Map
      
      /**
        * 类的注释
        *
        * @Package com.lyz
        * @ClassName MapAndTuple
        * @Description ${TODO}
        * @Author liyuzhi
        * @Date 2018-06-08 19:08
        */
      
      
      object MapAndTuple {
        def main(args: Array[String]): Unit = {
      
          //immutableMap
      
          //mutableMap
      
          hashMap
      
        }
      
        //可变的Map
        private def hashMap = {
          /**
            * 初始化HashMap
            */
          val hashMap = new mutable.HashMap[String, Int]()
      
          hashMap.put("zhangsan", 21)
          hashMap.put("lisi", 22)
          hashMap.put("wangwu", 23)
          hashMap.put("zhaoliu", 24)
      
          /**
            * 获取Map值
            */
          println(hashMap("zhangsan")) //如果键不存在会什么也不返回直接报错
          println(hashMap.get("aaaa")) //如果键不存在会返回None，打印结果为：None，如果存在那么返回值类型为Option，然后我们需要调用get方法获取值
          println(hashMap.getOrElse("aaaa", 0)) //如果键不存在就返回0,如果存在就会返回键对应的值
      
      
          /**
            * 更新Map元素
            */
          hashMap("zhangsan") = 31
      
          /**
            * 增加Map元素
            */
          hashMap += ("abc" -> 20, "bcd" -> 22)
      
          /**
            * 移除元素
            */
          hashMap -= ("zhangsan", "aaaaa")
          hashMap.remove("zhangsan")
      
          /**
            * 遍历Map
            */
          for (elem <- hashMap) {
            println(elem._1, elem._2)
          }
          //遍历Key
          for (elem <- hashMap.keySet) {
            println(elem)
          }
          //遍历value
          for (elem <- hashMap.values) {
            println(elem)
          }
        }
      
        //可变Map
        private def mutableMap = {
          /**
            * 初始化 scala.collection.mutable.Map
            */
          //scala.collection.mutable.Map[String,Int] Map是可变的数据结构，所以我们再次给已存在的键赋值就不会报错
          val ageMuttableMap = scala.collection.mutable.Map("zhangsan" -> 21, "lisi" -> 22, "wangwu" -> 23, "zhaoliu" -> 24)
          ageMuttableMap("zhangsan") = 31
      
          /**
            * 获取Map值
            */
          println(ageMuttableMap("zhangsan")) //如果键不存在会什么也不返回直接报错
          println(ageMuttableMap.get("zhangsan")) //如果键不存在会返回None，打印结果为：None，如果存在那么返回值类型为Option，然后我们需要调用get方法获取值
          println(ageMuttableMap.getOrElse("aaaaa", 0)) //如果键不存在就返回0,如果存在就会返回键对应的值
      
          /**
            * 更新Map元素
            */
          ageMuttableMap("zhangsan") = 31
      
          /**
            * 增加Map元素
            */
          ageMuttableMap += ("abc" -> 20, "bcd" -> 22)
      
          /**
            * 移除元素
            */
          ageMuttableMap -= ("zhangsan", "aaaaa")
      
          /**
            * 遍历Map
            */
          for (elem <- ageMuttableMap) {
            println(elem._1, elem._2)
          }
          //遍历Key
          for (elem <- ageMuttableMap.keySet) {
            println(elem)
          }
          //遍历value
          for (elem <- ageMuttableMap.values) {
            println(elem)
          }
        }
      
        //不可变Map
        private def immutableMap = {
      
          /**
            * 初始化 scala.collection.immutable.Map[String,Int]
            */
          //scala.collection.immutable.Map[String,Int] Map是不可变的数据结构，所以我们再次给已存在的键赋值就会报错
          val age = scala.collection.immutable.Map("zhangsan" -> 21, "lisi" -> 22, "wangwu" -> 23, "zhaoliu" -> 24)
          //自动对键排序的Map
          val ageSortedMap = scala.collection.immutable.SortedMap("zhangsan" -> 21, "lisi" -> 22, "wangwu" -> 23, "zhaoliu" -> 24)
      
          /**
            * 获取Map值
            */
          println(age("zhangsan")) //如果键不存在会什么也不返回直接报错
          println(age.get("zhangsan")) //如果键不存在会返回None，打印结果为：None，如果存在那么返回值类型为Option，然后我们需要调用get方法获取值
          println(age.getOrElse("aaaaa", 0)) //如果键不存在就返回0,如果存在就会返回键对应的值
      
          /**
            * 更新Map元素
            */
          //age("zhangsan") = 31 //报错
          age + ("abc" -> 20, "bcd" -> 22) //更新不可变Map的Api
      
          /**
            * 不可变Map移除元素
            */
          age - ("abc", "zhangsan")
      
          /**
            * 遍历Map
            */
          for (elem <- age) {
            println(elem._1, elem._2)
          }
          //遍历Key
          for (elem <- age.keySet) {
            println(elem)
          }
          //遍历value
          for (elem <- age.values) {
            println(elem)
          }
      
        }
      }
      

   4. Tuple：元组

      package com.lyz
      
      object TupleLearn {
        def main(args: Array[String]): Unit = {
      
      
          val tuple = ("a1",1) //定义一个元组
          println(tuple._1) //得到元组第一个元素
          println(tuple._2)//得到元组里的第二个元素
      
      
          val names = Array("z3","l4","w5")
          val ages = Array(1,2,3,4,5)
      
          /**
            * 控制台打印的结果为：
            *               z3:1
            *               l4:2
            *               w5:3
            */
          val nameage = names.zip(ages)
          for ((name,age) <- nameage) {
            println(name+":"+age)
          }
        }
      }