Scala 使用详解

    //1. 定义变量
    //没有指定msg的类型,那么Scala会自动根据 "Hello,World!"的类型来推断 msg的类型
    val msg="Hello,World!"
    println(msg);
    
    //指定类型
    val msg2:String="Hello,World!"
    val msg3:java.lang.String="Hello,World!"
    println(msg3);
    
    //val类型不能重新赋值
    //scala> msg2 = "Goodbye cruel world!"
    //<console>:5: error: reassignment to val
    //             msg2 = "Goodbye cruel world!"
    
    
    var greeting="Hello,World!"
    greeting="Leave me alone,world!"
    println(greeting);
    

  //2. 定义函数
  def max(x:Int,y:Int):Int={
    if(x>y){
      x
    }else{
      y
    }
  }
  
  def max2(x:Int,y:Int)=if(x>y)x else y
  
  def greet()="h"  // println(greet) 输出结果为 h
  def greet2()=println("h") // println(greet2) 输出结果为 h () 是因为该方法是没有返回值的

    //3. 循环
    // while循环,if判断
    var i=0
    while(i<10){
      println(i)
      i+=1
    }
    
    // foreach,for
    var str:Array[String]=new Array[String](10);
    //------foreach方法给() 或者{} 都可以
    Array[String]("concise","is","nice").foreach(arg=>println(arg))
    //------arg如果要指定类型的话，要加上小括号()
    Array[String]("concise","is","nice").foreach((arg:String)=>println(arg))
    Array[String]("concise","is","ncie").foreach(println);
    
    //------arg是val类型，而不是var类型，arg不能再for表达式的函数体中重新赋值
    for(arg<-Array[String]("concise","is","ncie"))
      println(arg)
    

    //4. 带类型的参数化数组
    val greetStrings=new Array[String](3)
    //-----当你在一个或多个值或变量外使用括号时,Scala会把它转换成对名为apply的方法调用.于是greetStrings(i)转换成
    //-----greetStrings.apply(i)。所以Scala里访问数据的元素也不过只是跟其它的一样的方法调用
    //这个原则不仅仅局限于数组：任何对某些在括号中的参数的对象的应用将都被转换为对apply方法的调用.当前前提是这个类型实际定义过
    //apply方法。所以这不是一个特例，而是一个通则
    greetStrings(0)="Hello" //java是[0]
    greetStrings(1)=","
    greetStrings(2)="world"
    //-----0 to 2 实际上调用的是(0).to(2)
    for(i<-0 to 2) //0 1 2
      print(greetStrings(i))

    //5. 使用List   
    val oneTwoThree=List(1,2,3)
    //---scala中List是不可变的，表现上有些像Java的String:当你在一个List上调用方法时,似乎这个名字指代的List看上去被改变了,而实际上
    //---它只是用新的值创建了一个List并返回。
    val oneTwo=List(1,2)
    val threeFour=List(3,4)
    val oneTwoThreeFour=oneTwo ::: threeFour
    println(oneTwo+" and "+ threeFour+"were not mutated.")
    println("Thus, "+oneTwoThreeFour+" is a new List.")
    
    //-- :: 把一个新元素组合到已有List的最前端,然后返回结果List
    val twoThree=List(2,3)
    //执行过程为 twoThree.::(1)
    val tmp=1 :: twoThree
    println(tmp)
    
    val tmp2=1::2::3::4::Nil
    //Nil要最后才能使用 ::被定义在List类上的方法,如果使用1::2::3 由于3是Int类型的,没有::方法,因此会导致异常
    println(tmp2)
    
    //为什么List不支持append ?
    //类List没有提供append操作,因为随着列表边长append的耗时将呈线性增长,而使用::做前缀则仅花费常量时间.如果你想通过添加元素来构造列表
    //你的选择时把它们前缀进去,当前完成之后再调用reverse;或使用ListBuffer,一种提供append操作的可变列表,当你完成之后再调用toList
    
    

    //6. 使用Tuple
    //与List一样,元组也是不可变的
    val pair=(99,"Luftballons");
    println(pair._1)
    println(pair._2)

    //7. 使用Set和Map
    var jetSet=Set("Boeing","Airbus")
    jetSet+="Lear" //对不可变集 使用+=需要重新赋值，所以是var的
    println(jetSet.contains("Lear"))
    
    import scala.collection.mutable.Set  //引用了可变 Set
    val movieSet=Set("Hitch","Poltergeist")
    movieSet+="Shrek" //是可变的不需要对 movieSet重新赋值,所以他是val的
    println(movieSet);
    
    import scala.collection.immutable.HashSet
    val hashSet=HashSet("Tomatoes","Chilies")
    println(hashSet+"Coriander")

    //Map是Scala里另一种有用的集合类,和Set一样,Scala采用了类继承机制提供了可变的和不可变的两种版本的Map
    //scala.collection包里面有一个基础的Map特质和两个子特质Map
    //可变的Map在scala.collection.mutable里,不可变的在scala.collection.immutable里
    
    import scala.collection.mutable.Map
    val treasureMap=Map[Int,String]()
    // -> 可以调用Scala程序里的任何对象，并返回一个包含键和值的二元组
    treasureMap+=(1->"Go to island.")
    treasureMap+=(2->"Find big X on ground.")
    treasureMap+=(3->"Dig.")
    println(treasureMap(2))