scala集合

數組：

val array = Array(1,2,23,23)
    for(elem<-array){
      print(elem)
    }

列表,元素能夠重複

    val test = List(1,1,2,3)

也能夠用兩個冒號表示連接兩個元素成爲一個集合，能夠經過三個冒號 將兩個集合合併爲要給集合

Set集合 元素不能夠重複

    val set = Set(1,2,1)

元組tuple

 val userInfo =("userName","age")
    print(userInfo._1)
 特殊狀況建立兩個元素的元組
   val a = "user_name"->"age"
    print(a)
    val pir=(100,"dfd","dfd")
    print(pir._1);
    print(pir._3)

元組不能經過屬性名稱獲取，只能經過下標來取，並且這個基數是從1開始的，不是基於0開始的

映射Map,映射能夠是值也能夠是參數

val c = Map("user_name" -> "lanhu", "age" -> "22")
    
    print(c.get("user_name"))
    val args = Map("a"->23,"b"->3)
    for((k,v)<-args){
      println(k+"===="+v)
    }

option選項

option爲咱們提供便捷的接口，查看是否包含某個選項

trait Option[T] { 
 def isDefined: Boolean 
  def get: T 
  def getOrElse(t: T): T
}
  
   val c = Map("user_name" -> "lanhu", "age" -> "22")
    var d =c.isDefinedAt("user_name")
    print(d)

模糊匹配配合着option使用

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

函數組合

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

 val test = List(1,2,3)
    val c = test.map{(n:Int)=>n*2}
    print(c)

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

  val test = List(1,2,3)
    val c = test.filter { (n:Int) => n>=2 }
    print(c)

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

   val test = List(1,2,3)
    val test2=List("a","d","d","df")
    val c = test.filter { (n:Int) => n>=2 }
    print(test.zip(test2))

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

 val test = List(1,2,3)
    val c = test.partition { (n:Int) => n!=2 }
    print(c)

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

val test = List(1,2,3)
    val c = test.find { (n:Int) => n!=2 }
    print(c)

drop&dropWhile

drop 將刪除前 i 個元素

  val test = List(1,2,3)
    print(test.drop(1))

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

foldLeft

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

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

foldRight相反

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，這就是「組合子」的特徵，也是這些函數的本質。