数组Array
（1）定长数组Array：
val a = new Array[Int](10) //初始化后，每个元素初始值为0
val a = Array("hello", "world")
val a1 = Array("leo", 30)
（2）变长数组ArrayBuffer：import scala.collection.mutable.ArrayBuffer
val b = ArrayBuffer[Int]()
b.append(1, 2) b += 2 //你们将+=当成一个方法 b.+=(4)
b.appendAll(a) b ++= Array(10, 20, 30) b.++=(a)
// 使用trimEnd()函数，可以从尾部截断指定个数的元素 b.trimEnd(1)
// 使用trimStart()函数，可以从头部截断指定个数的元素 b.trimStart(2)
// 使用insert()函数可以在指定位置插入元素
// 但是这种操作效率很低，因为需要移动指定位置后的所有元素
b.insert(0,100) b.insert(0,200,300)
// 使用remove()函数可以移除指定位置的元素
// remove如果从中间删掉元素，那么后面的元素也要往前移动
b.remove(1) b.remove(1, 3)
//反转 var b1 = b.reverse
（3）Array与ArrayBuffer互相转换
b.toArray
a.toBuffer
（4）数组的遍历
1.增强for循环 2.好用的until会生成脚标，0 until 10 包含0不包含10
val arr = Array(1,2,3,4,5,6,7,8)
//增强for循环 for(i <- arr) println(i)
//好用的until会生成一个Range for(i <- (0 until arr.length)) println(arr(i))
//reverse是将前面生成的Range反转 for(i <- (0 until arr.length).reverse) println(arr(i))
（5）数组转换
yield关键字将原始的数组进行转换会产生一个新的数组，原始的数组不变
scala> val arr = Array(1, 2, 3, 4, 5, 6, 7, 8, 9)
arr: Array[Int] = Array(1, 2, 3, 4, 5, 6, 7, 8, 9)
scala> val res = for (e <- arr if e % 2 == 0) yield e * 10
res: Array[Int] = Array(20, 40, 60, 80)
scala> val r = arr.filter(_ % 2 == 0).map(_ * 10) //filter是过滤，接收一个返回值为boolean的函数
r: Array[Int] = Array(20, 40, 60, 80) //map相当于将数组中的每一个元素取出来，应用传进去的函数
scala> var f1 = (a: Int) => a + 100
f1: Int => Int = <function1>
scala> val d = arr.map(f1(_))
d: Array[Int] = Array(101, 102, 103, 104, 105, 106, 107, 108, 109)
scala> val d = arr.map(f1)
d: Array[Int] = Array(101, 102, 103, 104, 105, 106, 107, 108, 109)
scala> val d3 = arr.map(x => x + 100)
d3: Array[Int] = Array(101, 102, 103, 104, 105, 106, 107, 108, 109)
scala> val d3 = arr.map(_ + 100)
d3: Array[Int] = Array(101, 102, 103, 104, 105, 106, 107, 108, 109)
（6）数组的常用算法
scala> arr.sum
res0: Int = 45
scala> arr.max
res1: Int = 9
scala> arr.sorted
res2: Array[Int] = Array(1, 2, 3, 4, 5, 6, 7, 8, 9)
scala> arr.reverse
res3: Array[Int] = Array(9, 8, 7, 6, 5, 4, 3, 2, 1)
scala> arr.sortBy(x=>x).reverse
res4: Array[Int] = Array(9, 8, 7, 6, 5, 4, 3, 2, 1)
scala> arr.sortWith((x,y)=>x>y)
res6: Array[Int] = Array(9, 8, 7, 6, 5, 4, 3, 2, 1)
scala> arr.sortWith(_<_)
res7: Array[Int] = Array(1, 2, 3, 4, 5, 6, 7, 8, 9)
映射Map
（1）不可变Map：
scala> val ages = Map("Leo" -> 30, "Jen" -> 25, "Jack" -> 23)
ages: scala.collection.immutable.Map[String,Int] = Map(Leo -> 30, Jen -> 25, Jack -> 23)
scala> val ages = Map(("Leo", 30), ("Jen", 25), ("Jack", 23))
ages: scala.collection.immutable.Map[String,Int] = Map(Leo -> 30, Jen -> 25, Jack -> 23)
（2）可变的Map：
scala> val ages = scala.collection.mutable.Map("Leo" -> 30, "Jen" -> 25, "Jack" -> 23)
ages: scala.collection.mutable.Map[String,Int] = Map(Jen -> 25, Jack -> 23, Leo -> 30)
（3）HashMap：
scala> val ages = new scala.collection.mutable.HashMap[String, Int]
ages: scala.collection.mutable.HashMap[String,Int] = Map()
（4）操作元素
访问 scala> val ages = Map("neo" -> 30, "leno" -> 35, "lili" -> 40)
ages: scala.collection.immutable.Map[String,Int] = Map(neo -> 30, leno -> 35, lili -> 40)
scala> var a = if (ages.contains("neo1")) ages("neo1") else 0
a: Int = 0
scala> a = ages.getOrElse("neo1", 0)
a: Int = 0
删除 可变 //Ages.remove(“neo”) ages -= "neo"
不可变 val ages3 = ages - "Tom"
增加 可变 import scala.collection.mutable.Map ages += ("Mike" -> 35, "Tom" -> 40)
更新 不可变 val ages = ages + ("Mike" -> 36, "Tom" -> 45)
遍历 for (age <- ages) println(age)
for ((key, value) <- ages) println(key + "," + value)
for (v <- ages.values) println(v)
for (key <- ages.keySet) println(key)
（5）SortedMap和LinkedHashMap
//SortedMap可以自动对Map的key的排序
val ages = scala.collection.immutable.SortedMap("leo" -> 30, "alice" -> 15, "jen" -> 25)
//LinkedHashMap可以记住插入的顺序
val ages = new scala.collection.mutable.LinkedHashMap[String, Int]
（6）对偶集合转换成映射
scala> val arr = Array(("tom",88),("jerry",95))
arr: Array[(String, Int)] = Array((tom,88), (jerry,95))
scala> arr.toMap
res9: scala.collection.immutable.Map[String,Int] = Map(tom -> 88, jerry -> 95)
元组Tuple
（1）创建 scala> val t = ("hadoop",3.14,65535)
t: (String, Double, Int) = (hadoop,3.14,65535)
（2）获取值 scala> val a = t._1
a: String = hadoop
scala> val a = t._2
a: Double = 3.14
（3）Zip操作 zip命令可以将多个值绑定在一起
var names = Array("张三", "李四")
var ages = Array(18, 19,20)
val tuples = names.zip(ages)
注意：如果两个数组的元素个数不一致，拉链操作后生成的数组的长度为较小的那个数组的元素个数
序列List
（1）不可变序列 import scala.collection.immutable._
//创建一个不可变的集合 val lst1 = List(1,2,3)
//将0插入到lst1的前面生成一个新的List val lst2 = 0 :: lst1 val lst3 = lst1.::(0) val lst4 = 0 +: lst1
//插入的集合的尾部 val lst5 = lst1.+:(0)
//将一个元素添加到lst1的后面产生一个新的集合 val lst6 = lst1 :+ 3 val lst0 = List(4,5,6)
//将2个list合并成一个新的List val lst7 = lst1 ++ lst0
//将lst1插入到lst0前面生成一个新的集合 val lst8 = lst1 ++: lst0
//将lst0插入到lst1前面生成一个新的集合 val lst9 = lst1.:::(lst0)
（2）可变序列 scala.collection.mutable.ListBuffer
//构建一个可变列表，初始有3个元素1,2,3 val lst0 = ListBuffer[Int](1,2,3)
//创建一个空的可变列表 val lst1 = new ListBuffer[Int]
//向lst1中追加元素，注意：没有生成新的集合 lst1 += 4 lst1.append(5)
//将lst1中的元素追加到lst0中， 注意：没有生成新的集合 lst0 ++= lst1
//将lst0和lst1合并成一个新的ListBuffer 注意：生成了一个集合 val lst2= lst0 ++ lst1
//将元素追加到lst0的后面生成一个新的集合 val lst3 = lst0 :+ 5
集合Set
（1）不可变 import scala.collection.immutable.HashSet
val set1 = new HashSet[Int]()
//将元素和set1合并生成一个新的set，原有set不变
val set2 = set1 + 4
//set中元素不能重复
val set3 = set1 ++ Set(5, 6, 7)
val set0 = Set(1,3,4) ++ set1
（2）可变 import scala.collection.mutable
//创建一个可变的HashSet
val set1 = new mutable.HashSet[Int]()
//向HashSet中添加元素
set1 += 2
//add等价于+=
set1.add(4)
set1 ++= Set(1,3,5)
println(set1)
//删除一个元素
set1 -= 5
set1.remove(2)
println(set1)