Scala编程：Scala初探

小灰灰 2022-03-27 07:26 194阅读 0赞

### Scala的名称来自于“可伸展的语言” ###

### Java关键字 ###

>   
> Java一共有50个关键字（keywords），其中有2个是保留字，目前还不曾用到：goto和const。true、false和null看起来很像关键字，但实际上只是字面量而已。本文粗略的把true、false和null也看做Java关键字，认为Java一共有53个关键字。下面是大致归类的Java关键字列表：

> assert  
> boolean, byte, short, char, int, long, float, double, void  
> package, import, class, interface, enum, implements, extends  
> public, protected, private, abstract, static, final, volatile, transient, synchronized, strictfp, native  
> try, catch, finally, throw, throws  
> if, else, do, while, for, switch, case, default, break, continue, return  
> super, this  
> new, instanceof  
> const, goto  
> true, false, null

###    Scala关键字   Scala只有39个关键字： ###

> package, import, class, object, trait, extends, with, type, forSome  
> private, protected, abstract, sealed, final, implicit, lazy, override  
> try, catch, finally, throw  
> if, else, match, case, do, while, for, return, yield  
> def, val, var  
> this, super  
> new  
> true, false, null  
> 对比Java和Scala关键字

![1415092014_2876.png][]  
  
[参考：------][------]

《Scala编程》的前3 章，一些Scala基本使用方法；Scala倒是和Python比较相似

打印出“hello world”

object mytest {
      
      def main(args: Array[String]): Unit = {
        println("hello this world")    //常例， 打印出一个 Hello World
          
      }
    }

函数使用方法：与python，java主要区别有：

1.变量名写在数据类型的前面

2.返回类型写在最后，无返回值则为 Unit（）

3.需要增加一个等号（最大不同）

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNTg3NTc1_size_16_color_FFFFFF_t_70][]

object mytest {
      //定义函数
      def max(x:Int, y:Int): Int = {
        if (x > y) 
          return x  // Scala中可写、可不写  return，Scala中称为结果类型
        else 
          return y
      }
      def max2(x: Int, y: Int): Int = if (x > y) x else y  // 同样是求最大值的函数
      def myPrint() = println("haha THIS IS Scala") // 不带参数的函数 Unit， 相当于java 中的void
      
      def myPrint2() = {
        var i = 0
        var myArgs = List("this", "is", "Scala")
        while(i < myArgs.length){
          if (i != 0){
            print(" ")        
          }
          print(myArgs(i))
          i += 1
        }
          println()    
      }
      
      def main(args: Array[String]): Unit = {
        println("hello this world")    //常例， 打印出一个 Hello World
        println("this is just for you ")
        var name = "zhangsan"
        var age = 13
        var shenggao = 13.22f
        println(name)
        println(age)
        println(shenggao)
        var capital = Map("hua"-> "meiguo  ", "France"-> "bali")  //字典类型, 映射关系
        println(capital("hua"))
        //变量定义
        val age1 = 12  //val 表示常量， 类似于java 中的final 变量
        var age2 = 13  // 可变的变量
        println(age1, age2)
        val msg : String = "this is string"
        println(msg)
        
        //定义函数
        println(max(2, 4))
        println(max2(2, 4))
        myPrint()
        myPrint2()  // this is Scala
        var myArgs = List("this", "is", "Scala")
        myArgs.foreach((arg: String) ⇒println(arg))  //or myArgs.foreach(arg⇒println(arg))
        for(arg ← myArgs)
          println(arg)   //  与上式foreach 打印出来的是一样
          
        // 使用类型化参数数组(Array) 可变
          val greetings = new Array[String](3) // 方括号内表示类型； 圆括号表示索引值，这不同于java和python
          greetings(0) = "Hello"
          greetings(1) = ", "
          greetings(2) = "World \n"
          for (i ← 0 to 2)    // 0 to 2 代表两边都是闭区间， range(0, 9)则与python相同，左闭右开
            println(greetings(i))
            
          //简洁的方法
          val greetings2 = Array("one", "two", "three") //实际是： val greetings2 = Array.apply("one", "two", "three")
          for (j ← 0 to 2)
            println(greetings2(j))
            
          // 使用列表List，不可变； python中是可变的
          val oneTwo = List(1, 2)
          val threeFour = List(3, 4)
          println(oneTwo ::: threeFour)  // List(1, 2, 3, 4) 叠加称为新列表
          println(1:: threeFour)  // List(1, 3, 4)
         
          //使用元组 Tuple，元组可以包含不同的类型的元素，  与列表一样， 元组也是不可变的
          val pair = (99, "Tuple")
          println(pair._1)  // ._1 称为字段；列表List 的apply方法始终返回相同的数据类型，由于Tuple可以包含多个数据类型，所以使用字段
          println(pair._2)  // Tuple
         
          //使用集（set）和 映射（map）
          // 不可变集 Set; 可变集将元素加入了自身，而不变集创建并返回包含了添加元素的新集
          var jetSet = Set("Boeing", "Airbus")
          jetSet += "Lear"
          println(jetSet) // Set(Boeing, Airbus, Lear)
          println(jetSet.contains("Lear"))//True
          // 可变集Set
          import scala.collection.mutable.Set
          var movieSet = Set("Hitch", "Poltegeist")
          movieSet += "Shrek"
          println(movieSet) // Set(Shrek, Poltegeist, Hitch)
          // 可变Map, 映射
          import scala.collection.mutable.Map
          var treatureMap = Map[Int, String]()
          treatureMap += (1 → "Go to island")
          treatureMap += (2 → "Find Something")
          treatureMap += (3 → "Done")
          println(treatureMap(2)) // Find Something
          
      }
    }

[1415092014_2876.png]: https://img-my.csdn.net/uploads/201411/04/1415092014_2876.png
[------]: https://blog.csdn.net/zxhoo/article/details/40787297%C2%A0
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNTg3NTc1_size_16_color_FFFFFF_t_70]: /images/20220327/586a98e3428d4432ae172d5f2ddd4d35.png