1、集合的数据结构：
array、seq 、set 、map（映射）
2、集合分类
集合分为可变集合和不可变集合（除元组外，元组没有可变和不可变）
scala.collection.immutable : 不可变集合的包
scala.collection.mutable : 可变集合的包
3、集合初始化
不可变集合：
val s= Array[Int](10) val s = Array[String]("Hello","World") val s = List[Int](1, 2, 3, 4) val s = Set[Int](1,2,4) val s = Map("Ali" -> 10, "Bob" -> 3, "City" -> 8); val s = Map(("Ali", 10), ("Bob", 3), ("City", 8));
可变集合：
val b = scala.collection.mutable.ArrayBuffer[Int]() val b = scala.collection.mutable.ListBuffer[Int](1, 2, 3, 4) val b = scala.collection.mutable.Set(1,2,3) val b = scala.collection.mutable.Map[String,Int]() val b = scala.collection.mutable.Map("Ali" -> 10, "Bob" -> 3, "City" -> 8)
注：系统默认是不可变集合，如果是可变，必须前面加包名
4、集合的公共操作
4.1、迭代（遍历）
一共三种方法：iterator、for、foreach
val coll= . . . //coll是一个集合、 val iter = coll.iterator while (iter.hasNext) { iter . next （） } for (elem <- coll) { } //如果是map,则应该： for (（k,v） <- coll) { } List(1,2,3).iterator.foreach( println(_) ) //foreach 是Iterator上的方法
4.2、转化
val coll= . . . //集合都是可以互相转化的 coll.toSeq coll.toSet coll.toMap coll.toArray //转化为不可变数组Array coll.toBuffer //转化为可变数组ArrayBuffer
4.3、增删（++，- -）
val list = List(1, 2, 3, 4) //以list举例，其余的都可以 val list2 = list ++ list 注：不可变集合通过将结果赋值给另一个变量实现增，但是不能实现删
val listBuffer = scala.collection.mutable.ListBuffer[Int](1, 2, 3, 4) //以list举例，其余的都可以 listBuffer -= 4 listBuffer += 4 listBuffer ++= listBuffer //等价于listBuffer = listBuffer ++ listBuffer listBuffer --= listBuffer //等价于listBuffer = listBuffer -- listBuffer listBuffer = listBuffer ++ listBuffer 注：++、--是操作的集合，+、-是针对某一元素
5、Iterable 特质的重要方法（所有）
sum | product | max | min //和，乘积，最大值，最小值
head & last & headOption & lastOption //返回第（最后）一个元素，但是如果集合没有元素，head 会抛出异常，但是headOption会返回none eg ： var coll = Map("A"->1, "B"->2, "C"->3) coll.head //(A,1)
tail & init //返回除第（最后）一个的元素集合
take(n) | drop(n) | splitAt() // take(n) | drop(n) <==>takeLeft(n) | dropLeft(n)。返回前n个元素，除前n个的其他元素，两组对偶 eg： var coll = Set(1, 2, 3, 4) coll.take(2) //Set(1, 2) coll.drop(2) //Set(3, 4) coll.splitAt(2) //(Set(1, 2),Set(3, 4)) takeRight(n) | dropRight(n) //返回最后n个元素，除最后n个的其他元素，两组对偶 slice(from, to) //返回位于从from开始到to结束这个区间内的所以元素 eg：var coll = Set(1, 2, 3, 4) coll.slice(0,2) //Set(1, 2) grouped //将集合分为两个
eg：val xs = List(1, 2, 3, 4, 5, 6, 7, 8, 9) xs.grouped(4).foreach(println) //List(1, 2, 3, 4)，List(5, 6, 7, 8)，List(9)
mkString(before,between,after)、addString(sb, before, between, after) //转化为字符串 eg : var coll = List("a", "b", "c") coll.mkString("<","-",">") //<a-b-c> map(f) | foreach(f) | flatMap(f) | collect(pf) //将函数f应用到所有元素 注：flatMap和map的区别： val arr = ["a b","c d"] val arr2 = arr.flatMap (x => x.split(" ") ） //扁平化：["a","b","c","d"] val arr3 = arr.map (x => x.split(" ") ） //[["a","b"],["c","d"]]
count(pred) | forall(pred) | exists(pred) //返回满足时提前表达式的元素计数，所有元素满足时返回true，至少一个元素满足是返回true eg : var coll = Set(1, 2, 3, 4) coll.count(_<3) //2 filter(pred) | filterNot(pred) | partition(pred) //返回所有满足前提表达式的元素，所有不满足的元素,两组元素组成的对偶 takeWhile(pred) | dropWhile(pred) | span(pred) //和上面一样，只不过遇见第一个不满足，就不扫描了 eg : var coll = Set(1, 3, 2) coll.filter(_<3) //Set(1) coll.takeWhile(_<3) //Set(1, 2) coll.partition(_<2) //(Set(1,2),Set(3)) coll.span(_<2) //(Set(1),Set(3, 2)) reduceLeft 、reduceRight //reduceLeft <==> reduce。reduceLeft将结果作为左边参数,还有 (1 to 9) . reduceLeft( _ * _) //1 * 2 * 3 * 4 * 5 * 6 * 7 * 8 * 9 arr.reduceLeft((a,b) => if (a > b) a else b //找出最大值 foldLeft : //foldLeft <== > fold。其实和reduceLeft差不多，只不过增加了初始值 List (1, 7, 2, 9). foldLeft (0) (_ * _) //0*1 * 2 * 3 * 4 * 5 * 6 * 7 * 8 * 9 zip(coll2) | zipAll(coll2,fill,fill2) //返回由本集合元素和另外一个集合的元素组成的对偶，当长度不一致时，进行填充 var coll = List("a", "b") var coll2 = List(1, 2) coll.zip(coll2) //List(("a",1),("b",1)) 注： coll.filter(_<3) 等价于coll.filter(x => x <3) coll.filter(_+_) //_只是匹配参数，第二个_表示第二个参数，但是没有第二个参数，所以这写法是错误的，一般推荐第二种 coll.filter(x => x + x) //把参数变为x,可以无限使用
6、Seq特质的重要方法（list、array）
reverse //倒置序列 contains(elem)、containsSlice(seq)、startsWith(seq)、endsWith(seq) //返回true，如果该序列：包含给定元素、包含给定序列、以给定序列开始、以给定序列结束 padTo(n,fill) //返回当前序列的一个拷贝，将fill的内容向后追加，直到新序列长度达到n eg: val list2 = List(8,9) val list = List(1,3,4,23,4,5) list.padTo(5,list2) //List(1, 3, 4, 23, 4, 5) indexWhere（pred） //满足表达式的第一个元素索引 eg : val list = List(1,3,4,23,4,5,6,7,8,1,23) list.indexWhere(_>20) //3 indexOf(elem)、lastIndexOf(elem)、indexOfSlice(seq)、lastIndexOfSlice(seq) //返回给定元素或序列在当前序列中的首次或末次出现的下标 intersect(seq)、diff(seq) //交集和序列之间的差异。 eg : val list2 = List(8,1,23,9) val list = List(1,3,4,23,4,5) list.intersect(list2) //List(1, 23) list.diff(list2) //List(3, 4, 4, 5) sorted, sortWith(less), sortBy(f) //默认排序，二元函数排序、自定义函数排序 eg: "Mary had a" . split (" ").sortWith(_. length< _.length) //Array ("a ", "had","Mary")
7、线程安全的集合
SynchronizedBuffer
SynchronizedMap
SynchronizedPriorityQueue
SynchronizedQueue
SynchronizedSet
SynchronizedStack
注：方法还是大同小异，只不过是线程安全，但是速度慢，一般都是用线程不安全的集合
8、List、set
val set = Set(1,2,4) val set = scala.collection.mutable.Set(1,2,3） //初始化
val list = List(1, 2, 3, 4) val ListBuffer = scala.collection.mutable.ListBuffer[Int](1, 2, 3, 4) //List 增加了Nil（空表）、:: （等价于+:）、:::（等价于++：）的概念 //::操作单个元素，:::操作集合 val a= 9 : : List(4) //a = List(9,4) val a = 9 : : 4 : : Nil //最右边必须是集合，不能val a= 9 : : 4 : : 2，所以加空表 val b = a ::: a 改写 ：val b = a ++: a //但是不推荐改写 //因为底层是链表，还增加了首尾增加元素，了解 val a= 9 +: List(4, 2) //（9,4,2） var b = List(4, 2) :+ 9 //（4,2,9）
9、数组
①不可变数组：Array ————————————————————————————————————————————————————————— val s= Array[Int](10) val s = Array[String]("Hello","World") s(0) = "GoodBye" //改，推荐使用 ————————————————————————————————————————————————————————— ②可变数组：ArrayBuffer ————————————————————————————————————————————————————————— val b = scala.collection.mutable.ArrayBuffer[Int]() b.insert(1, 6) //在下标为1的地方增加一个元素6 b.remove(2); //移除下标为2的元素 b.remove(2,2); //从下标为2的地方开始，移除两个元素 注：因为数组有顺序，多了指定位置增删，insert，remove ————————————————————————————————————————————————————————— ③常用方法：max、min、mkstring 、reverse ————————————————————————————————————————————————————————— val arr = Array(1,2,3,4,5,6) println(arr.max) println(arr.min) println(arr.mkString) //123456 println(arr.mkString("|")) //1|2|3|4|5|6 println(arr.mkString("[", "|", "]")) //[1|2|3|4|5|6] println(arr.reverse) //Array(1,2,3,4,5,6)-->Array(6,5,4,3,2,1)
10、Map(映射)
①不可变映射： —————————————————————————————————————————————————————————— val s = Map("Ali" -> 10, "Bob" -> 3, "City" -> 8); //初始化 val s = Map(("Ali", 10), ("Bob", 3), ("City", 8)); val aLi = s("Ali") val aLi = s.getOrElse("Ali",0) //如果不存在返回0，推荐使用 for (i <- map.keySet) { //keyset、values方法 println(i); } map.values ————————————————————————————————————————————————————————— ②可变映射 ————————————————————————————————————————————————————————— val s = scala.collection.mutable.Map[String,Int]() //初始化 val s = scala.collection.mutable.Map("Ali" -> 10, "Bob" -> 3, "City" -> 8) s("Ali") = 10 s += ("Dog" -> 12, "Esi" -> 10) //可变集合的增删举例 s - = "Ali" ————————————————————————————————————————————————————————— ③排序映射 ————————————————————————————————————————————————————————— val scores = scala .collection .mutable.SortedMap （”Alce " - > 10, ” Fred" - > 7, ” Bob” - > 3 ， ”Cndy” －＞ 8) //默认会按字典排序，就是说你遍历时候，会按字典排序出来（字典排序：unicode的字符集的前后位置） val months = scala . collection .mutable.LinkedHashMap (” January" > 1, ” February ” -> 2, “. . . ) //默认会按输入值的排序
11、Tuple（元组）
元组虽属于集合，但是以上的规律，增删都不适用。 val t1 = ("小明", "男", 23) println(t1._1 + ":" + t1._2 + "-" + t1._3) val arr1 = Array("a", "b", "c") val arr2 = Array("A", "B", "C") val tuple = arr1 zip arr2 //拉链操作 ((a,A), (b,B), (c,C))