scala学习笔记一之基础语法，条件控制，循环控制，函数，数组，集合

1:声明val变量:可以使用val来声明变量，用来存放表达式的计算结果，但是常量声明后是无法改变它的值的，建议使用val来声明常量；
  声明var变量:如果要声明可以改变的引用，可以使用var变量，声明的常量的值可以改变。
3:指定类型:无论声明val变量还是声明var变量。都可以手动指定其类型，如果不指定，scala会自动根据值，进行类型的推断；
4:声明多个变量:可以将多个变量放到一起进行声明,如val id,age :Int = 0;val num1,num2=100;
5:基础数据类型:Byte,Char,Short,Int,Long,Float,Double,Boolean;记住，Scala没有包装数据类型；
6:基本操作符:scala的算术操作符和Java的算术操作符没有什么区别，比如+ - * / %等等，以及其他操作符，& | >> << 等等，但是在scala中，这些操作符其实是数据类型的函数，比如1+1,可以写作1.+(1),1 to 10可以写作1.to(10)等等。
　　  注意，在scala中没有提供++,--操作，我们只可以使用+=和-=操作符；
7:apply函数:在scala中apply函数是非常特殊的一种函数，在Scala的object中，可以声明apply函数。而使用"类名()"的形式，其实就是"类名.apply()"的一种缩写。通常使用这种方式来构造类的对象，而不是使用"new 类名()"的方式。
　　 比如"hello world"(6)可以写成"hello world".apply(6)；

1:if表达式的定义:在scala中，if表达式是有值的，就是if或者else中最后一行就是返回的值。
    比如var age = 18; if(age >18) 1 else 0;
    可以将if表达式赋予一个变量，比如var result = if(age >18) 1 else 0;
2:if表达式的类型推断，由于if表达式是有值的，而if和else子句的值类型可能是不同的。此时if表达式的值是什么类型的呢，scala可以自动进行推断，取两个类型的公共父类型。
    比如：var age =18;if(age > 18) "成年人" else 0;此时if和else的值分别是String和Int,则表达式的值就是Any,因为Any是String和Int的公共父类型。
3:如果if后面没有跟else，则默认else的值是Unit，也可以用()表示，类似于Java中的void或者null。
4:语句终结符:默认情况下，scala不需要语句终结符即;这个分号,默认每一行作为一个语句。
    但是如果一行放多条语句，则必须使用语句终结符。
5:块表达式。指的就是{}中的值，其中可以包含多条语句，最后一个语句的值就是块表达式的返回值。
6:输出:print()和println(),其中print()打印的时候不会加换行，但是println()打印的时候会加一个换行符。
7:输入:readLine：允许我们从控制台读取用户输入的数据，类似于Java中的System.in和Scanner的作用。
    注意:readInt()输入是数值类型的。readDouble()是输入小数类型的。

1:while do循环，scala中的while do循环，基本和Java相同。
2:for循环，比如:for(i <- 1 to 10) println(i);注意for循环的使用，多加揣摩和练习。
3:跳出循环语句:scala中没有提供如Java中的跳出循环语句。但是可以使用boolean类型变量，return或者使用Breaks的break函数来替换使用。
    比如：var flag : Boolean = false;for(i <- 1.to(10)) if(i%2==0){ flag = true; return flag;}
4:scala的九九乘法表:
    for(i <- 1.to(9); j <- 1.to(9)){
      if(j == 9){
        println(i + "*" + j + " = " + i*j);
      }else{
        print(i + "*" + j + " = " + i*j + " ");
      }

    }
5:scala的取偶数
    for(i <- 1 to 100 if i % 2 ==0) println(i)
6:for推导式，构造集合:
    var a = for(i <- 1 to 10) yield i;
    println(a)

1:函数的定义:需要定义函数的函数名，参数，函数体；Scala要求必须给出所有参数的类型，但是不一定给出函数返回值的类型，只要右侧的函数体中不包含递归的语句，Scala就可以根据自己右侧的表达式推断出返回类型。
    比如：
    def helloScala(name : String,age : Int): Unit ={
      if(age > 18){
         println("恭喜您:" + name + "您已经:" + age+"岁了，您已经成年了");
      }else{
        println("恭喜您:" + name + "您已经:" + age+"岁了，您还是未成年哦");
      }
    }
    helloScala("张三",20);
2:如果在函数体递归调用函数自身，则必须手动给出函数的返回值类型。
3:默认参数，在Scala中，有时候在调用某些函数的时候，不希望给出参数的具体指，而希望使用参数自身默认的值，此时就在定义函数时使用默认参数。如果给出的参数不够，则会从左往右依次应用参数。
    比如:
    def hello(name :String="张三",age : Int=20): Unit ={
      println(name+ " "  + age)
    }
    hello()
4:带名参数:在调用函数的时候，也可以不按照函数定义的参数顺序来传递参数，而是使用带名参数的方式来传递；
    还可以混合使用未命名参数和带名参数，但是未命名参数必须在带名参数前面。
    比如：
    def hello(name :String="张三",age : Int=20): Unit ={
      println(name+ " "  + age)
    }
    hello(age=24,name="李四")
    hello("王五",age=26)
5:函数之变长参数:在Scala中，有时候我们需要将函数定义为参数个数可变的形式，则此时可以使用变长参数定义函数:
    比如:
    def add(nums : Int*): Int ={
      var sum : Int= 0;
      for(num <- nums){
        sum += num;
      }
      return sum;
    }
    var result = add(1,2,3,4);
    println(result)
注意:如果想要将一个已有的序列直接调用变长参数，是不可以的。此时需要使用Scala特殊的语法将参数定义为序列，让Scala解释器能够识别:比如:var s = sum(1 to 5:_*)
    比如:
    def add(nums : Int*): Int ={
      var sum : Int= 0;
      for(num <- nums){
        sum += num;
      }
      return sum;
    }
    println(add(1 to 4:_*))
6：函数之过程，定义函数的时候，如果函数体直接包裹在了花括号里面，而没有使用=连接，则函数的返回值就是Unit。这样的函数就被称之为过程。过程通常用于不需要返回值的函数。
注意:过程还有一种写法，就是将函数的返回值类型定义为Unit;
    比如：
        def hello(name : String) = "hello:" +name;
        def hello(name : String) {println("hello:"+name);"hello:"+ name}
        def hello(name : String) : Unit= "hello:" +name;    
7：Scala的异常:在scala中，异常处理和捕获机制与Java类似。
    比如：
    try{
      throw new IllegalArgumentException("算数异常");
    }catch{
      case _:IllegalArgumentException => println("算术异常");
    }finally {
      println("最后一定执行这句话。")
    }
8:高阶函数：
　　可以将函数A作为参数传递给函数B，此时这个函数B叫做高阶函数。此时函数A称为匿名函数，注意匿名函数的参数和类型。
　　textFile.filter((line : String) => line.contains("Spark")) #Scala可以自动推断类型，可以省略类型
　　textFile.filter((line) => line.contains("Spark")) #Scala参数只有一个，可以省略括号
　　textFile.filter(line => line.contains("Spark")) #_可以代表任意字符
　　textFile.filter(_.contains("Spark")

1:Array,在Scala中，Array也是长度可变的数组，此外，由于Scala与Java都是运行在Jvm中，双方可以互相调用，因此，Scala数组的底层实际上就是Java数组。
    比如:数组初始化以后，长度就固定下来了，而且元素全部根据其类型初始化:
        var arr = new Array[Int](10)
        var arr2 = new Array[String](10)
    可以直接使用Array()创建数组，元素类型自动推断:
        var arr = Array("张三","李四");
        println(arr(0))
2:ArrayBuffer,在Scala中，如果需要类似于Java中ArrayList这种长度可变的集合类，则可以使用ArrayBuffer;
    如果不想每次都使用全限定名，则可以预先导入ArrayBuffer类:
        import scala.collection.mutable.ArrayBuffer
    使用ArrayBuffer()方式可以创建一个空的ArrayBuffer:
        var arr = ArrayBuffer[Int]();
        println(arr.toBuffer)        
    使用+=操作符，可以添加一个元素或者多个元素:
        arr += 1;
        println(arr.toBuffer)
        arr += (2,3,4,5,6);
        println(arr.toBuffer)    
    使用++=操作符，可以添加其他集合中的所有元素:
        arr ++= Array(8,9,5,6,3,66);
        println(arr.toBuffer)
    使用trimEnd()函数，可以从尾部截断指定个数的元素:
        arr.trimEnd(5)
        println(arr.toBuffer)
    使用insert()函数可以在指定位置插入元素。但是这种操作效率很低，因为需要移动指定位置后的所有元素。
    使用remove()函数可以移除指定位置的元素。    
    Array和ArrayBuffer可以互相进行转换:arr.toArray;arr.toBuffer    
3:遍历Array和ArrayBuffer
    使用for循环和until遍历Array和ArrayBuffer：
    使用until是RichInt提供的函数:
        var arr = Array(11,22,33,44,55,66,77,88);
        for(i <- 0.until(arr.length)){
          print(arr(i) + " ")
        }
    跳跃遍历Array/ArrayBuffer
        var arr = Array(11,22,33,44,55,66,77,88);
        for(i <- 0.until(arr.length,3)){
          print(arr(i) + " ")
        }
    从尾部遍历Array/ArrayBuffer
        var arr = Array(11,22,33,44,55,66,77,88);
        for(i <- 0.until(arr.length).reverse){
          print(arr(i) + " ")
        }
    使用增强for循环遍历Array/ArrayBuffer
        var arr = Array(11,22,33,44,55,66,77,88);
        for(i <- arr){
          print(i + " ")
        }    
4：数组的常用函数：
    数组元素求和:
        var arr = Array(55,11,22,33,44,55,66,77,88);
        println("求和：" + arr.sum)        
    获取数组的最大值和最小值:
        println("最大值:"+ arr.max + " ,最小值:" + arr.min)            
    对数组进行排序:
        quickSort(arr)
        println("排序:"+ arr.toBuffer)        
    获取数组中所有的元素内容:
        println("获取值："+ arr.mkString(","))
    toString函数
        println(arr.toString)
5:使用yield和函数式编程转换数组:
    对数组Array进行转换，获取的还是Array：
        var arr = Array(11,12,13,14,15,16,17,18,19);
        var result = for(i <- arr) yield i * i;
        for(i <- result){
          print(i + " ")
        }        
    对数组ArrayBuffer进行转换，获取的还是ArrayBuffer：    
        var arr = ArrayBuffer[Int]();
        arr += (11,12,13,14,15,16,17,18,19);
        var result = for(i <- arr) yield i * i;
        for(i <- result){
          print(i + " ")
        }
    结合if守卫，仅仅转换需要的元素:
        var arr = ArrayBuffer[Int]();
        arr += (11,12,13,14,15,16,17,18,19);
        var result = for(i <- arr if i %2 == 0) yield i * i;
        for(i <- result){
          print(i + " ")
        }    
    使用函数式编程转换数组,通常使用第一种方式:    
        var arr = ArrayBuffer[Int]();
        arr += (11,12,13,14,15,16,17,18,19);
        var result = arr.filter(_ % 2 == 0).map(2 * _)
        print(result.toBuffer + " ")
        var result2 = arr.filter(_ % 2 == 0) map{2 * _}
        print(result2.toBuffer + " ")
        

1:创建Map:
    创建一个不可变的Map:
        import scala.collection.immutable.Map
        var map = Map("张三" ->26,"李思思" -> 23);
        println(map("张三"))
    创建一个可变的Map:
        import scala.collection.mutable.Map
        var map = Map("张三" -> 23,"李思思" -> 24);
        println(map("张三"))
        map("王五") = 25;
        println(map("王五"))    
    使用另外一种方式定义Map元素:
        var map = Map(("张三",22),("李四",23),("王五",24),("赵六",26));
        println(map.toBuffer)
    创建一个空的HashMap:
        var map = new mutable.HashMap[String,Int]()
    获取指定key对应的value，如果key不存在，会报错的:    
        println(map("张三"))
    使用contains函数检查key是否存在:
        var map = Map(("张三",22),("李四",23),("王五",24),("赵六",26));
        if(map.contains("张三")){
          println("张三存在");
        }else{
          println("张三不存在");
        }        
    使用getOrElse函数用来判断是否存在，不存在返回一个默认值:
        var map = Map(("张三",22),("李四",23),("王五",24),("赵六",26));
        var result = map.getOrElse("张三三",20)
        println(result)
    更新Map的元素:
        var map = Map(("张三",22),("李四",23),("王五",24),("赵六",26));
        map("张三") = 26;
        println(map("张三"))
    增加多个元素：
        var map = Map(("张三",22),("李四",23),("王五",24),("赵六",26));
        map += ("小明" -> 22,"小红" -> 26);
        println(map.toBuffer)
    移除元素:
        var map = Map(("张三",22),("李四",23),("王五",24),("赵六",26));
        map -= "张三";
        println(map.toBuffer);
    更新不可变的map：
        var map = Map(("张三",22),("李四",23),("王五",24),("赵六",26));
        map -= "张三";//而不是map不可以添加和减少对应的key-value
        //map("李四") = 20;//注意不可更改是key对应的value不可以改变。
        println(map.toBuffer);
        map += ("张三" -> 26);
        println(map.toBuffer)
    移除不可变的map的元素:
        var map = Map(("张三",22),("李四",23),("王五",24),("赵六",26));
        var map2 = map + ("小红" -> 20,"小明" -> 21);
        println(map2.toBuffer)
        var map3 = map2 - ("小红","小明");
        println(map3.toBuffer)
2:Scala遍历Map的操作：    
    scala遍历map的entrySet：
        var map = Map(("张三",22),("李四",23),("王五",24),("赵六",26));
        for((key,value) <- map){
        println(key + " " + value)
        }
    scala遍历map的key：
        var map = Map(("张三",22),("李四",23),("王五",24),("赵六",26));
        for(key <- map.keySet){
        println(key + " " + map(key))
        }
    scala遍历map的value：
        var map = Map(("张三",22),("李四",23),("王五",24),("赵六",26));
        for(value <- map.values){
          println(value)
        }
    scala生成新的map，反转key和value：
        var map = Map(("张三",22),("李四",23),("王五",24),("赵六",26));
        var result = for((key,value) <- map) yield (value,key)
        for((key,value) <- result){
          println(key + " " + value)
        }
    SortedMap可以自动对Map的key进行排序:
        var map = SortedMap("张三" -> 26, "别先生" -> 24 ,"小明" ->20);
        println(map.toBuffer)
    LinkedHashMap可以记住插入的entry的顺序:
        var map = new mutable.LinkedHashMap[String ,Int]();
        map("张三") = 20;
        map("别先生") = 24;
        map("小明") = 22;
        println(map.toBuffer)
        for((key,value) <- map){
          println(key + " " + value)
        }
3:Scala的tuple：    
    简单Tuple和访问Tuple：
        var tuple = ("张三",26,20,true,"李四");
        println(tuple._1)
        println(tuple._2)
        println(tuple._3)
        println(tuple._4)
        println(tuple._5)
    zip操作:
        var names = Array("张三","李四","王五");
        var ages = Array(24,25,26);
        var result = names.zip(ages);
        println(result.toBuffer)
        for((name,age) <- result){
          println(name+ "  " + age)
        }