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，这就是“组合子”的特征，也是这些函数的本质。