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

Posted --->别先生<---

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了Scala学习笔记一之基础语法,条件控制,循环控制,函数,数组,集合相关的知识,希望对你有一定的参考价值。

前言:Scala的安装教程:http://www.cnblogs.com/biehongli/p/8065679.html

1: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);

2:Scala之条件控制学习笔记:

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()是输入小数类型的。

3:Scala之循环控制学习笔记:

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)

4:Scala之函数学习笔记,面向对象和面向函数编程:

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;    
7Scala的异常:在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")

5:Scala之数组学习笔记

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 + " ")
        

6:Scala之集合中的Map,以及tuple的学习笔记:

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)
        }
    

待续......

以上是关于Scala学习笔记一之基础语法,条件控制,循环控制,函数,数组,集合的主要内容,如果未能解决你的问题,请参考以下文章

大数据处理学习笔记1.5 掌握Scala内建控制结构

go语言学习笔记 — 基础 — 控制流:goto跳转语句

scala控制结构:条件表达式与循环

scala学习笔记3:基本控制结构基础

Python学习笔记-流程控制(while循环)

Scala基础语法学习