scala-經常使用函數介紹

歡迎你們關注： scala工具庫 ,裏面包含各類庫的測試用例和使用說明文檔

##模式匹配 使用用模式匹配實現斐波那契

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)

##廣告 點擊Spark加入羣Spark，分享更多Spark相關信息