1. 程式人生 > >Scala學習(三)——集合

Scala學習(三)——集合

創建 trait while unit some otto 快捷 對象 theme

基本數據結構

Scala提供了一些不錯的集合。

數組 Array

數組是有序的,可以包含重復項,並且可變。

val numbers = Array(1, 2, 3, 4, 5, 1, 2, 3, 4, 5) 
numbers(3) = 10 
numbers // Array(1, 2, 3, 10, 5, 1, 2, 3, 4, 5) 

列表 List

列表是有序的,可以包含重復項,不可變。

val numbers = List(1, 2, 3, 4, 5, 1, 2, 3, 4, 5) 
numbers(3) = 10 // error: value update is not a member of List[Int]  

集合 Set

集合無序且不可包含重復項。

val numbers = Set(1, 2, 3, 4, 5, 1, 2, 3, 4, 5) 

元組 Tuple

元組在不使用類的情況下,將元素組合起來形成簡單的邏輯集合。

val hostPort = ("localhost", 80) 

與樣本類不同,元組不能通過名稱獲取字段,而是使用位置下標來讀取對象;而且這個下標基於1,而不是基於0。

hostPort._1 // String = localhost  
hostPort._2 // Int = 80 

元組可以很好得與模式匹配相結合。

hostPort match {   
  case ("localhost", port) => ...   
  case (host, port) => ... 
} 

在創建兩個元素的元組時,可以使用特殊語法:->

1 -> 2 // (Int, Int) = (1,2) 

映射 Map

它可以持有基本數據類型。

Map(1 -> 2) 
Map("foo" -> "bar") 

這看起來像是特殊的語法,不過不要忘了上文討論的->可以用來創建二元組。

Map()方法也使用了從第一節課學到的變參列表:Map(1 -> "one", 2 -> "two")將變為 Map((1, "one"), (2, "two")),其中第一個元素是映射的鍵,第二個元素是映射的值。

映射的值可以是映射甚至是函數。

Map(1 -> Map("foo" -> "bar")) 
Map("timesTwo" -> { timesTwo(_) }) 

選項 Option

Option 是一個表示有可能包含值的容器。

Option基本的接口是這樣的:

trait Option[T] {   
  def isDefined: Boolean   
  def get: T   
  def getOrElse(t: T): T 
} 

Option本身是泛型的,並且有兩個子類: Some[T] 或 None

我們看一個使用Option的例子:

Map.get 使用 Option 作為其返回值,表示這個方法也許不會返回你請求的值。

val numbers = Map("one" -> 1, "two" -> 2) 
numbers.get("two") // Option[Int] = Some(2)  
numbers.get("three") // Option[Int] = None 

現在我們的數據似乎陷在Option中了,我們怎樣獲取這個數據呢?

直覺上想到的可能是基於isDefined方法進行條件判斷。

// We want to multiply the number by two, otherwise return 0. 
val result = if (res1.isDefined) {   
  res1.get * 2 
} else {   0 } 

我們建議使用getOrElse或模式匹配處理這個結果。

getOrElse 讓你輕松地定義一個默認值。

val result = res1.getOrElse(0) * 2 

模式匹配能自然地配合Option使用。

val result = res1 match {   
  case Some(n) => n * 2   
  case None => 0 
} 

函數組合子(Functional Combinators)

List(1, 2, 3) map squared對列表中的每一個元素都應用了squared平方函數,並返回一個新的列表List(1, 4, 9)。我們把類似於map的操作稱作組合子。 他們常被用在標準的數據結構上。

map

map對列表中的每個元素應用一個函數,返回應用後的元素所組成的列表。

val numbers = List(1, 2, 3, 4) 
numbers.map((i: Int) => i * 2) // List[Int] = List(2, 4, 6, 8)

或傳入一個函數 (Scala編譯器自動把我們的方法轉換為函數)

def timesTwo(i: Int): Int = i * 2 
numbers.map(timesTwo) // List[Int] = List(2, 4, 6, 8) 

foreach

foreach很像map,但沒有返回值。foreach僅用於有副作用[side-effects]的函數。

numbers.foreach((i: Int) => i * 2)

什麽也沒有返回。

你可以嘗試存儲返回值,但它會是Unit類型(即void)

val doubled = numbers.foreach((i: Int) => i * 2) // Unit = ()

filter

filter移除任何對傳入函數計算結果為false的元素。返回一個布爾值的函數通常被稱為謂詞函數[或判定函數]。

numbers.filter((i: Int) => i % 2 == 0) // List[Int] = List(2, 4) 
def isEven(i: Int): Boolean = i % 2 == 0 
numbers.filter(isEven) // List[Int] = List(2, 4)

zip

zip將兩個列表的內容聚合到一個對偶列表中。

List(1, 2, 3).zip(List("a", "b", "c")) // List[(Int, String)] = List((1,a), (2,b), (3,c)) 

partition

partition將使用給定的謂詞函數分割列表。

val numbers = List(1, 2, 3, 4, 5, 6, 7, 8, 9, 10) 
numbers.partition(_ % 2 == 0) // (List[Int], List[Int]) = (List(2, 4, 6, 8, 10),List(1, 3, 5, 7, 9)) 

find

find返回集合中第一個匹配謂詞函數的元素。

numbers.find((i: Int) => i > 5) // Option[Int] = Some(6) 

drop & dropWhile

drop 將刪除前i個元素

numbers.drop(5) // List[Int] = List(6, 7, 8, 9, 10) 

dropWhile 將刪除匹配謂詞函數的第一個元素。例如,如果我們在numbers列表上使用dropWhile函數來去除奇數, 1將被丟棄(但3不會被丟棄,因為他被2“保護”了)。

numbers.dropWhile(_ % 2 != 0) // List[Int] = List(2, 3, 4, 5, 6, 7, 8, 9, 10) 

foldLeft

numbers.foldLeft(0)((m: Int, n: Int) => m + n) // Int = 55 

0為初始值(記住numbers是List[Int]類型),m作為一個累加器。

可視化觀察運行過程:

numbers.foldLeft(0) { (m: Int, n: Int) => println("m: " + m + " n: " + n); m + n } 
//m: 0 n: 1 m: 1 n: 2 m: 3 n: 3 m: 6 n: 4 m: 10 n: 5 m: 15 n: 6 m: 21 n: 7 m: 28 n: 8 m: 36 n: 9 m: 45 n: 10 
//res0: Int = 55 

foldRight

和foldLeft一樣,只是運行過程相反。

numbers.foldRight(0) { (m: Int, n: Int) => println("m: " + m + " n: " + n); m + n } 
//m: 10 n: 0 m: 9 n: 10 m: 8 n: 19 m: 7 n: 27 m: 6 n: 34 m: 5 n: 40 m: 4 n: 45 m: 3 n: 49 m: 2 n: 52 m: 1 n: 54 
//res0: Int = 55

flatten

flatten將嵌套結構扁平化一個層級。

List(List(1, 2), List(3, 4)).flatten // List[Int] = List(1, 2, 3, 4) 

flatMap

flatMap是一種常用的組合子,結合映射[mapping]和扁平化[flattening]。 flatMap需要一個處理嵌套列表的函數,然後將結果串連起來。

val nestedNumbers = List(List(1, 2), List(3, 4)) 
nestedNumbers.flatMap(x => x.map(_ * 2)) // List[Int] = List(2, 4, 6, 8) 

可以把它看做是“先映射後扁平化”的快捷操作:

nestedNumbers.map((x: List[Int]) => x.map(_ * 2)).flatten // List[Int] = List(2, 4, 6, 8)

這個例子先調用map,然後調用flatten,這就是“組合子”的特征,也是這些函數的本質。

擴展函數組合子

現在我們已經學過集合上的一些函數。

我們將嘗試寫自己的函數組合子。

有趣的是,上面所展示的每一個函數組合子都可以用fold方法實現。讓我們看一些例子。

def ourMap(numbers: List[Int], fn: Int => Int): List[Int] = {   
  numbers.foldRight(List[Int]()) { 
    (x: Int, xs: List[Int]) => fn(x) :: xs   
  } 
}  
ourMap(numbers, timesTwo(_)) // List[Int] = List(2, 4, 6, 8, 10, 12, 14, 16, 18, 20)

為什麽是List[Int]()?Scala沒有聰明到理解你的目的是將結果積聚在一個空的Int類型的列表中。

Map?

所有展示的函數組合子都可以在Map上使用。Map可以被看作是一個二元組的列表,所以你寫的函數要處理一個鍵和值的二元組。

val extensions = Map("steve" -> 100, "bob" -> 101, "joe" -> 201) 

現在篩選出電話分機號碼低於200的條目。

extensions.filter((namePhone: (String, Int)) => namePhone._2 < 200) // Map((steve,100), (bob,101)) 

因為參數是元組,所以你必須使用位置獲取器來讀取它們的鍵和值。呃!

幸運的是,我們其實可以使用模式匹配更優雅地提取鍵和值。

extensions.filter({case (name, extension) => extension < 200}) // Map((steve,100), (bob,101)) 

Scala學習(三)——集合