scala集合

優先使用不可變集合。不可變集合適用於大多數狀況，讓程序易於理解和推斷，由於它們是引用透明的( referentially transparent )所以缺省也是線程安全的。

使用可變集合時，明確地引用可變集合的命名空間。不要用使用import scala.collection.mutable._ 而後引用 Set ，應該用下面的方式替代：

 import scala.collections.mutable
 val set = mutable.Set()

這樣就很明確在使用一個可變集合。

使用集合類型缺省的構造函數。每當你須要一個有序的序列(不須要鏈表語義)，用 Seq() 等諸如此類的方法構造：

 val seq = Seq(1, 2, 3)
 val set = Set(1, 2, 3)
 val map = Map(1 -> "one", 2 -> "two", 3 -> "three")

這種風格從語意上分離了集合與它的實現，讓集合庫使用更適當的類型：你須要Map，而不是必須一個紅黑樹(Red-Black Tree，注：紅黑樹TreeMap是Map的實現者)

此外，默認的構造函數一般使用專有的表達式，例如：Map() 將使用有3個成員的對象(專用的Map3類)來映射3個keys。

上面的推論是：在你本身的方法和構造函數裏，適當地接受最寬泛的集合類型。一般能夠歸結爲Iterable, Seq, Set, 或 Map中的一個。若是你的方法須要一個 sequence，使用 Seq[T]，而不是List[T]

 

scala中集合有不少種:

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

參考 Effective Scala 對怎樣使用 集合的觀點。

列表 List

scala> val numbers = List(1, 2, 3, 4)
numbers: List[Int] = List(1, 2, 3, 4)

 

集 Set

集沒有重複

scala> Set(1, 1, 2)
res0: scala.collection.immutable.Set[Int] = Set(1, 2)

 

元組 Tuple

元組是在不使用類的前提下，將元素組合起來造成簡單的邏輯集合。

scala> val hostPort = ("localhost", 80)
hostPort: (String, Int) = (localhost, 80)

 

與樣本類不一樣，元組不能經過名稱獲取字段，而是使用位置下標來讀取對象；並且這個下標基於1，而不是基於0。

scala> hostPort._1
res0: String = localhost

scala> hostPort._2
res1: Int = 80

 

元組能夠很好得與模式匹配相結合。

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

 

在建立兩個元素的元組時，可使用特殊語法：->

scala> 1 -> 2
res0: (Int, Int) = (1,2)

 

參考 Effective Scala 對 解構綁定 （「拆解」一個元組）的觀點。

映射 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 做爲其返回值，表示這個方法也許不會返回你請求的值。

scala> val numbers = Map("one" -> 1, "two" -> 2)
numbers: scala.collection.immutable.Map[java.lang.String,Int] = Map(one -> 1, two -> 2)

scala> numbers.get("two")
res0: Option[Int] = Some(2)

scala> numbers.get("three")
res1: 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
}

 

參考 Effective Scala 對使用Options的意見。

函數組合子（Functional Combinators）

List(1, 2, 3) map squared對列表中的每個元素都應用了squared平方函數，並返回一個新的列表List(1, 4, 9)。咱們稱這個操做map 組合子。 （若是想要更好的定義，你可能會喜歡Stackoverflow上對組合子的說明。）他們常被用在標準的數據結構上。

map

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

scala> numbers.map((i: Int) => i * 2)
res0: List[Int] = List(2, 4, 6, 8)

 

或傳入一個部分應用函數

scala> def timesTwo(i: Int): Int = i * 2
timesTwo: (i: Int)Int

scala> numbers.map(timesTwo _)
res0: List[Int] = List(2, 4, 6, 8)

 

foreach

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

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

 

什麼也沒有返回。

你能夠嘗試存儲返回值，但它會是Unit類型（即void）

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

 

filter

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

scala> numbers.filter((i: Int) => i % 2 == 0)
res0: List[Int] = List(2, 4)

scala> def isEven(i: Int): Boolean = i % 2 == 0
isEven: (i: Int)Boolean

scala> numbers.filter(isEven _)
res2: List[Int] = List(2, 4)

zip

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

scala> List(1, 2, 3).zip(List("a", "b", "c"))
res0: List[(Int, String)] = List((1,a), (2,b), (3,c))

 

partition

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

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

 

find

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

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

 

drop & dropWhile

drop 將刪除前i個元素

scala> numbers.drop(5)
res0: List[Int] = List(6, 7, 8, 9, 10)

 

dropWhile 將刪除元素直到找到第一個匹配謂詞函數的元素。例如，若是咱們在numbers列表上使用dropWhile奇數的函數, 1將被丟棄（但3不會被丟棄，由於他被2「保護」了）。

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

 

foldLeft

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

 

0爲初始值（記住numbers是List[Int]類型），m做爲一個累加器。

直接觀察運行過程：

scala> 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同樣，只是運行過程相反。

scala> 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將嵌套結構扁平化爲一個層次的集合。

scala> List(List(1, 2), List(3, 4)).flatten
res0: List[Int] = List(1, 2, 3, 4)

 

flatMap

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

scala> val nestedNumbers = List(List(1, 2), List(3, 4))
nestedNumbers: List[List[Int]] = List(List(1, 2), List(3, 4))

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

 

能夠把它看作是「先映射後扁平化」的快捷操做：

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

 

這個例子先調用map，而後能夠立刻調用flatten，這就是「組合子」的特徵，也是這些函數的本質。

參考 Effective Scala 對flatMap的意見。

擴展函數組合子

如今咱們已經學過集合上的一些函數。

咱們將嘗試寫本身的函數組合子。

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

def ourMap(numbers: List[Int], fn: Int => Int): List[Int] = {
  numbers.foldRight(List[Int]()) { (x: Int, xs: List[Int]) =>
    fn(x) :: xs
  }
}

scala> ourMap(numbers, timesTwo(_))
res0: List[Int] = List(2, 4, 6, 8, 10, 12, 14, 16, 18, 20)

 

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

Map?

全部展現的函數組合子均可以在Map上使用。Map能夠被看做是一個二元組的列表，因此你寫的函數要處理一個鍵和值的二元組。

scala> val extensions = Map("steve" -> 100, "bob" -> 101, "joe" -> 201)
extensions: scala.collection.immutable.Map[String,Int] = Map((steve,100), (bob,101), (joe,201))

 

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

scala> extensions.filter((namePhone: (String, Int)) => namePhone._2 < 200)
res0: scala.collection.immutable.Map[String,Int] = Map((steve,100), (bob,101))

 

由於參數是元組，因此你必須使用位置獲取器來讀取它們的鍵和值。呃！

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

scala> extensions.filter({case (name, extension) => extension < 200})
res0: scala.collection.immutable.Map[String,Int] = Map((steve,100), (bob,101))