Scala 一些基本的语法

Scala的循环：

for (i <- 0 until 1000000) { ... }var i = 0; while (i < 1000000) { ...; i = i+1 }

这两种方式跟C#的循环大致类似

 

Scala 迭代循环:

for(n <- List( 5, 7, 2, 4) if n % 2 == 1) yield n * n

List(5, 7, 2, 4).filter(n => n % 2 == 1).map(n => n * n)

C#3.5目前也支持这种foreach的循环方式。

Scala 异常:

try { ... } catch { case ioe: IOException => ... // more specific cases first ! case e: Exception => ... }

Scala Tuples的用法:

object Test extends Application { def tupleTest = (1, 2, 3) val (a, b ,c) = tupleTest println("a:" + a + ", b:" + b + ", c:" + c) val t = tupleTest println("a:" + t._1 + ", b:" + t._2 + ", c:" + t._3) }

Scala List的用法:

  val t = List( 1, 2, 3, 4, 5)        
  val u = 1 :: 2 :: 3 :: 4 :: 5 :: Nil
  t match {
    case 1::2::rest        => true
    case List(1,2,rest@_*) => true // equivalent
  }

Scala Map(immutable):

val t = List( 1, 2, 3, 4, 5)        
  val u = 1 :: 2 :: 3 :: 4 :: 5 :: Nil
  t match {
    case 1::2::rest        => true
    case List(1,2,rest@_*) => true // equivalent
  }

Scala Map(mutable):

val map = new scala.collection.mutable.HashMap[String, Any]
            
  map("likes") = "cheese"
        
  assume( map("likes") == "cheese")
  assume( map.get("likes") == Some("cheese") )
      
  assume( map.get("fakeKey") == None)
      
  map += "name" -> "Gromit"
  assume( map("name") == "Gromit")
 
  map += "id" -> 1234
  assume( map.get("id") == Some(1234) )
  assume( map("id") == 1234)
 
  map.get("id") match {
    case Some(idval) => assume(1234 == idval)
    case None => fail("no value found")
  }

Scala Map Key:

//custom classes as keys to a map
  case class AnotherCustomKey(someval:int, someString:String) {
    //hashCode and equals are implemented for you
  }
  
  val map = new HashMap[AnotherCustomKey, int]
  map += AnotherCustomKey(1,"333") -> 1   
  assume(map.get(AnotherCustomKey(1, "333")) == Some(1))
  assume(map.get(AnotherCustomKey(2, "222")) == None)
 
  //if a case class can not be used, you must override equals and hashCode
  class CustomKey(val someval:int) {
    override def hashCode: int = someval
    override def equals(any:Any): Boolean = {
      any.isInstanceOf[CustomKey] && any.asInstanceOf[CustomKey].someval == someval
    }
  }
  val map2 = new HashMap[CustomKey, int]
  map2 += new CustomKey(1) -> 1   
  assume(map2.get(new CustomKey(1)) == Some(1))
  assume(map2.get(new CustomKey(2)) == None)


 

Array:

object dictionary {
 val data = Array(null, "A","B","C")
 
 def apply(x:String) = x match {
  case "one" => data(1)
  case "two" => data(2)
  case "three" => data(3)
 }
 
 def update(x:String,y:String) = x match {
  case "one" => data(1) = y // ...this gets turned to data.update(1,y)
  case "two" => data(2) = y
  case "three" => data(3) = y
 }
 
 def main(args:Array[String]) { // ...shorthand for this.apply("one")
   Console.println(this("one")+","+this("two")+","+this("three")) 
   this("one") = "X"   // ...and this becomes this.update("one","X")
   this("two") = "Y"
   this("three") = "Z"
   Console.println(this("one")+","+this("two")+","+this("three"))
 }
}

Scala的lazy argument, a no-arg function argument, and a lazy value?

 

a “normal” (call-by-value) argument:

  def foo(x:Bar) = {
    val a = x
    val b = x
  }


a lazy (call-by-name) argument:

def foo(x: => Bar) = {
    val a = x
    val b = x
  }


no-argument function (a thunk):

def foo(x:() => Bar) = {
     val a = x
     val b = x
     val c = x()
  }


call-by-name lazy arguments:

def foo(x: => Bar) = {
     lazy val y = x
     //...
   }


use matching with regular expressions:

val RE = "(\\d+)([a-z]+)".r
// or, if you don't like escaping things
val RE_Also = """(\d+)([a-z]+)""".r
 
def m(someString: String) = someString match {
  case RE(theNUmbers,theLetters) => println(theNumbers + ": " + theLetters)
  case _ => println("no match")
}