Scala基礎篇

數據類型

下表中列出的數據類型都是對象，可以直接對它們調用方法。

表示Long類型，在數字後面添加L或者l作為後綴；浮點數後面有f或者F後綴時，表示Float類型，否則就是Double

變量

用關鍵詞“var”聲明變量，關鍵詞"val"聲明常量。

var myName : String = "gyt"
val myAge : Int = 21 

scala中不一定要指明數據類型，其數據類型通過變量或常量的初始值推斷出來的，因此，在沒有指明數據類型的情況下，必須要給出初始值。

訪問修飾符

用private關鍵詞修飾，只能被當前類以及當前類的內部類訪問到，外層類訪問不到。

class Outer{
    class Inner{
        private def f(){
            println("f")
        }
        class InnerMost{
            f() // 正確
        }
    }
    (new Inner).f() //錯誤
}

用protected關鍵詞修飾，只能被當前類的子類訪問。

package p {
    class Super {
        protected def f() {println("f")}
    }
    class Sub extends Super {
        f()
    }
    class Other {
        (new Super).f() //錯誤
    }
}

沒有指定任何修飾符，默認為public，在任何地方都可以被訪問。

條件和循環

以下是IF...ELSE語句實例。

object Test {
   def main(args: Array[String]) {
      var x = 30;

      if( x == 10 ){
         println("X 的值為 10");
      }else if( x == 20 ){
         println("X 的值為 20");
      }else if( x == 30 ){
         println("X 的值為 30");
      }else{
         println("無法判斷 X 的值");
      }
   }
}

以下是一個使用了 i to j 語法(包含 j)的實例，箭頭 <- 用於為變量 a 賦值。

object Test {
   def main(args: Array[String]) {
      var a = 0;
      // for 循環
      for( a <- 1 to 10){
         println( "Value of a: " + a );
      }
   }
}

在 for 循環 中你可以使用分號;來設置多個區間，它將迭代給定區間所有的可能值。

object Test {
   def main(args: Array[String]) {
      var a = 0;
      var b = 0;
      // for 循環
      for( a <- 1 to 3; b <- 1 to 3){
         println( "Value of a: " + a );
         println( "Value of b: " + b );
      }
   }
}

for 循環集合的語法如下。

object Test {
   def main(args: Array[String]) {
      var a = 0;
      val numList = List(1,2,3,4,5,6);

      // for 循環
      for( a <- numList ){
         println( "Value of a: " + a );
      }
   }
}

你可以將 for 循環的返回值作為一個變量存儲。

object Test {
   def main(args: Array[String]) {
      var a = 0;
      val numList = List(1,2,3,4,5,6,7,8,9,10);

      // for 循環
      var retVal = for{ a <- numList 
                        if a != 3; if a < 8
                      }yield a

      // 輸出返回值
      for( a <- retVal){
         println( "Value of a: " + a );
      }
   }
}

函數式編程（重點）

函數式編程：對於相同的輸入永遠會得到相同的輸出,而且沒有任何可以觀察的副作用,也不依賴外部的環境狀態。參考什麼是函數式編程？。

Scala中函數是為完成某一功能的程序語句的集合，類中定義的函數稱之為方法。下面是方法的一個實例。

object add{
   def addInt( a:Int, b:Int ) : Int = {
      var sum:Int = 0
      sum = a + b

      return sum
   }
}

可變參數：我們不需要指定函數參數的個數，可以向函數傳入可變長度參數列表。通過在參數的類型之後放一個星號來設置可變參數(可重複的參數)。

object Test {
   def main(args: Array[String]) {
        printStrings("Runoob", "Scala", "Python");
   }
   def printStrings( args:String* ) = {
      var i : Int = 0;
      for( arg <- args ){
         println("Arg value[" + i + "] = " + arg );
         i = i + 1;
      }
   }
}

默認參數： scala可以為函數參數指定默認參數值，使用了默認參數，你在調用函數的過程中可以不需要傳遞參數，這時函數就會調用它的默認參數值，如果傳遞了參數，則傳遞值會取代默認值。

object Test {
   def main(args: Array[String]) {
        println( "返回值 : " + addInt() );
   }
   def addInt( a:Int=5, b:Int=7 ) : Int = {
      var sum:Int = 0
      sum = a + b

      return sum
   }
}

匿名函數：箭頭左邊是參數列表，右邊是函數體。

var inc = (x: Int) => {x+1}
var x = inc(7) - 1

//定義一個函數，以函數作為參數輸入
def f(func: String => Unit): Unit = {
    func("gyt")
}
var fun = (name: String) => {println(name)}
f(fun)

傳名調用：傳遞的不是具體的值，而是代碼塊。和一般的傳值調用相比，每次使用傳名調用時，解釋器都會計算一次表達式的值。

def f1(): Int = {
    println("f1被調用")
    12
}
def f2(a: => Int): Unit = {
    println(a)
    println(a)
}
f2(f1())

至簡原則：

（1）函數中的return可以省略，以最後一行代碼作為代碼塊的返回值。

def f1(name: String): String = {
    name
}

（2）如果函數體只有一行代碼，可以省略花括號。

def f2(name: String): String = name

（3）如果編譯器可以推斷出來返回值，那麼可以省略（：和返回值類型一起省略）。有意思的是，到這一步，scala函數的形式形如數學中的f(x) = y。

def f3(name: String) = name

（4）如果有return，則（3）不適用。

（5）如果返回值是Unit，可以省略等號和返回值，但是此時花括號不能省略。

def f4(name: String) {
    println(name)
}

（6）如果函數沒有參數，那麼調用它的時候可以直接用函數名。不用加“()”。

閉包：如果一個函數，訪問到它的外部（局部）變量的值，那麼這個函數和它所處的環境，稱為閉包。

柯里化：將原來接受兩個參數的函數變成新的接受一個參數的函數的過程。新的函數返回一個以原有第二個參數為參數的函數。

object Test {
   def main(args: Array[String]) {
      val str1:String = "Hello, "
      val str2:String = "Scala!"
      println( "str1 + str2 = " +  strcat(str1)(str2) )
   }

   def strcat(s1: String)(s2: String) = {
      s1 + s2
   }
}

字符串

在 Scala 中，字符串的類型實際上是 Java String，它本身沒有 String 類。

數組

Scala 語言中提供的數組是用來存儲固定大小的同類型元素。下面是聲明數組的三種方式。

var z:Array[String] = new Array[String](3)
var zz = new Array[String](3)
var zzz = Array("Runoob", "Baidu", "Google")

模式匹配

一個模式匹配包含了一系列備選項，每個都開始於關鍵字 case。每個備選項都包含了一個模式及一到多個表達式。箭頭符號 => 隔開了模式和表達式。

object Test {
   def main(args: Array[String]) {
      println(matchTest("two"))
      println(matchTest("test"))
      println(matchTest(1))
      println(matchTest(6))

   }
   def matchTest(x: Any): Any = x match {
      case 1 => "one"
      case "two" => 2
      case y: Int => "scala.Int"
      case _ => "many"
   }
}

實例中第一個 case 對應整型數值 1，第二個 case 對應字符串值 two，第三個 case 對應類型模式，用於判斷傳入的值是否為整型，相比使用isInstanceOf來判斷類型，使用模式匹配更好。第四個 case 表示默認的全匹配備選項，即沒有找到其他匹配時的匹配項，類似 switch 中的 default。

object Test {
   def main(args: Array[String]) {
        val alice = new Person("Alice", 25)
        val bob = new Person("Bob", 32)
        val charlie = new Person("Charlie", 32)
   
    for (person <- List(alice, bob, charlie)) {
        person match {
            case Person("Alice", 25) => println("Hi Alice!")
            case Person("Bob", 32) => println("Hi Bob!")
            case Person(name, age) =>
               println("Age: " + age + " year, name: " + name + "?")
         }
      }
   }
   // 樣例類
   case class Person(name: String, age: Int)
}

使用了case關鍵字的類定義就是樣例類(case classes)，樣例類是種特殊的類，經過優化以用於模式匹配。

迭代器

Scala Iterator（迭代器）不是一個集合，它是一種用於訪問集合的方法。迭代器 it 的兩個基本操作是 next 和 hasNext。調用 it.next() 會返回迭代器的下一個元素，並且更新迭代器的狀態。調用 it.hasNext() 用於檢測集合中是否還有元素。讓迭代器 it 逐個返回所有元素最簡單的方法是使用 while 循環：

object Test {
   def main(args: Array[String]) {
      val it = Iterator("Baidu", "Google", "Runoob", "Taobao")
      
      while (it.hasNext){
         println(it.next())
      }
   }
}

下表列出了Scala Iterator常用的方法：