模式匹配
使用用模式匹配實現斐波那契
def fibonacci(in: Any): Int = in match {
case 0 => 0
case 1 => 1
case n: Int if(n > 1)=> fibonacci(n - 1) + fibonacci(n - 2)
case _ => 0
}
println(fibonacci(3))
元組tuple
元組可以保存不同類型的值，不能通過名稱獲取字段，而是使用位置下標來讀取對象；而且這個下標基於1，而不是基於0。
val hostPort = ("localhost", 80)
println("host:%s,port:%s".format(hostPort._1,hostPort._2))
執行結果：
host:localhost,port:80
選項 Option
Option 是一個表示有可能包含值的容器。
Option基本的接口是這樣的：
trait Option[T] {
def isDefined: Boolean
def get: T
def getOrElse(t: T): T
}
映射 Map
Option本身是泛型的，並且有兩個子類： Some[T] 或 None
Map.get 使用 Option 作為其返回值，表示這個方法也許不會返回你請求的值。
val map = Map(1 -> "one", 2 -> "two")
println(map.get(2))
println(map.get(3))
執行結果：
Some(two)
None
函數組合子（Functional Combinators）
map
map對列表中的每個元素應用一個函數，返回應用后的元素所組成的列表。
val numbers = List(1, 2, 3)
val double = numbers.map((i: Int) => i * 2)
val squared = numbers.map((i: Int) => BigInt(i).pow(3))
println("%s".format(numbers))
println(double)
println(squared)
//傳入一個部分應用函數
def timesTwo(i: Int): Int = i * 2
val doubleFunction = numbers.map(timesTwo _)
println(doubleFunction)
執行結果：
List(1, 2, 3)
List(2, 4, 6)
List(1, 8, 27)
List(2, 4, 6)
foreach
foreach很像map，但沒有返回值。foreach僅用於有副作用[side-effects]的函數
//foreach返回值為Unit即void
val foreachResult = numbers.foreach { (i: Int) => i * 2 }
println(foreachResult)
執行結果：
()
filter
filter移除任何對傳入函數計算結果為false的元素
val filterResult = numbers.filter { (i: Int) => i % 2 == 0 }
println(filterResult)
執行結果：
List(2)
zip
zip將兩個列表的內容聚合到一個對偶列表中，多余的元素刪除
val zipResult = numbers.zip(List('a', 'b', 'c', 'd'))
println(zipResult)
執行結果：
List((1,a), (2,b), (3,c))
partition
partition將使用給定的謂詞函數分割列表。
val partitionResult = numbers.partition { _ % 2 == 0 }
println("partition result:%s".format(partitionResult))
執行結果：
partition result:(List(2),List(1, 3))
find
find返回集合中第一個匹配謂詞函數的元素
var findResult = numbers.find(_ == 1)
println("find result:%s".format(findResult))
findResult = numbers.find(_ > 3)
println("find result:%s".format(findResult))
執行結果：
find result:Some(1)
find result:None
drop&dropWhile
drop刪除前i個元素,dropWhile刪除直到不滿足謂詞函數的元素
var dropResult = numbers.drop(2)
println("drop result:%s".format(dropResult))
dropResult = numbers.dropWhile(_ % 2 != 0)
println("dropWhile result:%s".format(dropResult))
執行結果：
drop result:List(3)
dropWhile result:List(2, 3)
foldLeft&foldRight
0為初始值（記住numbers是List[Int]類型），m作為一個累加器,foldRight與foldLeft運行過程相反
var foldLeftResult = numbers.foldLeft(0) {
(m: Int, n: Int) => println("m:" + m + " n:" + n); m + n
}
println("foldLeft result:%s".format(foldLeftResult))
var foldRightResult = numbers.foldRight(0) {
(m: Int, n: Int) => println("m:" + m + " n:" + n); m + n
}
println("foldRight result:%s".format(foldRightResult))
執行結果：
m:0 n:1
m:1 n:2
m:3 n:3
foldLeft result:6
m:3 n:0
m:2 n:3
m:1 n:5
foldRight result:6
flatten
flatten將嵌套結構扁平化為一個層次的集合
var flattenResult = List(List(1, 2, 3), List(4, 5, 6)).flatten
println("flatten result:%s".format(flattenResult))
執行結果：
flatten result:List(1, 2, 3, 4, 5, 6)
flatMap
flatMap是一種常用的組合子，結合映射[mapping]和扁平化[flattening]。 flatMap需要一個處理嵌套列表的函數，然后將結果串連起來。flatMap是map和flatten的組合。
val nestedNumbers = List(List(1, 2), List(3, 4))
var flatMapResult = nestedNumbers.flatMap(x => x.map(_ * 2))
println("flatMap result:%s".format(flatMapResult))
flatMapResult = nestedNumbers.map(x => x.map(_ * 2)).flatten
println("flatMap result:%s".format(flatMapResult))
執行結果：
flatMap result:List(2, 4, 6, 8)
flatMap result:List(2, 4, 6, 8)