1、概述
scala中集合大致分为四类：list（列表，这里归属于seq下），tuple（元组），map，set，所有的集合都扩展自 Iterable特质
对于几乎所有的集合类，Scala 都同时提供了可变和不可变的版本，分别位于以下两个包
不可变集合：scala.collection.immutable
可变集合： scala.collection.mutable
2、List
（1）list（不可变的list）
—元素有序，可重复,不可变的
/**
* List：元素有序，可重复,不可变的
*/
val list: List[Int] = List(1, 2, 3, 4, 5, 6, 7, 1, 9)
println(list(0))
println(list(7))
//常见的方法
println(list.max) //最大值
println(list.min) //最小值
println(list.sum) //和
println(list.sum / list.size.toFloat) //平均值
println(list.head) //第一个元素
println(list.take(10))) //取前10个
println(list.tail) //除第一个之外的所偶遇元素构成的新的集合
println(list.reverse) //反转
println(list.mkString(" ")) //指定分隔符遍历
println(list.sorted) //排序
println(list.isEmpty) //是否空
map方法：将集合元素一个个展开进行各种操作，将每一个元素都平方（一进一出）
val listmap: List[Int] = list.map((i:Int)=>{i*i})
println(listmap.mkString(" "))
flatMap方法：将元素展开，集合出去（一进多出）
//将元素展开
/**
*** flatMap函数：**
- 接收一个函数f：函数的参数类型为List中元素的自身决定，但是必须是集合类 *
也会将List中的元素一次传递给函数f，并且会对函数f返回的结果进行扁平化处理
*/
val list1: List[String] = List("hadoop,java,redis","hadoop,python,scala","hive,mysql,spark")
val listFlat: List[String] = list1.flatMap((str:String)=>{
str.split(",")})
for (elem <- listFlat) {
println(elem)
}
foreach方法：打印
//scala中打印方法
/**
* foreach:接收一个函数，函数的参数类型为list中元素的类型
* 函数的返回值类型为Unit
* 与map函数区别在于没有返回值，而map有返回值
*/
list1.foreach(println)
filter：过滤
//filter过滤
//将list中的奇数过滤出来
/**
* 接收一个函数
* 参数类型为list中元素类型，返回值类型为boolean
* //为true的留下，为false的过滤
*/
val listFilter: List[Int] = list.filter((i: Int) => {
var flag = false
if (i % 2 == 1) {
flag = true
}
flag
})
println(listFilter.mkString(" "))
sortby：指定排序的列,根据元组的某一列进行排序
val list2: List[(Int, Int)] = List((1,5),(2,7),(4,6),(3,2))
val listsort1: List[(Int, Int)] = list2.sortBy((tuple2: (Int,Int))=>tuple2._1) //第一列
val listsort2: List[(Int, Int)] = list2.sortBy((tuple2: (Int,Int))=>tuple2._2) //第二列
println(listsort1.mkString(" "))
println(listsort2.mkString(" "))
sortwith：指定排序规则,依次传入两个数
val listwith: List[Int] = list.sortWith((i1, i2) => {
1 / i1.toFloat > 1 / i2.toFloat（倒数，从小到大）
})
listwith
println(listwith.mkString(" "))
（2）ListBuffer（可变的list）
val listbuffer: ListBuffer[Int] = ListBuffer(1,2,3,4,5,6,7)
//增
println(listbuffer.mkString(" "))
listbuffer.insert(0,11) //在索引位置添加
listbuffer.append(1,1,1,1) //在后面追加
listbuffer.+=(2) //在后面追加
println(listbuffer)
//删
listbuffer.remove(0) //删除第一个
listbuffer.-=(1) //删除指定的值，默认删除一次
println(listbuffer)
//改
listbuffer(0) = 11 //将第一个元素改成0
listbuffer.update(0,15)
println(listbuffer)
3、集合set
（1）set（不可变的）
—不可变的，元素无序，不可重复
val set1: Set[Int] = Set(1,2,3,1,4,5,6,1,2,4,7,8,9,1,2,5)
println(set1.max)
println(set1)
//...方法都有
val set2: Set[Int] = Set(1,2,3,10,11)
println(set1 & set2) //交集
println(set1 | set2) //并集
println(set1.diff(set2)) //差集
（2）hashset（可变的）
//可变的set
val hashset: mutable.HashSet[Int] = mutable.HashSet(1,2,4,5,6,3,1,2,4,7,8,9,5,4)
4、元组（不可变）
元组:就是不可变，元素有序，虽然不能通过index取元素，可以通过_1..取元素
元组的最大的长度为22
val tuple: (Int, Int) = Tuple2(1,2) //二元组
val t1: (Int, Int, Int) = Tuple3(1,2,3)
//先写()填数据自动生成
val t2: (Int, Int, Int, Int, Int, Int, Int) = (1,2,3,4,5,6,7)
println(t2._1)
5、map
（1）map（不可变）
----元素是key-value格式的，无序的，key是不能重复的
//通过元组进行创建
val map1: Map[String, String] = Map(("k1","v1"),("k2","v2"),"k3"->"v3")
println(map1)
//判断某个key是否存在
println(map1.contains("k1"))
println(map1.contains("k4"))
//根据key获取value
println(map1.get("k1").get) //返回some，还需要get获取值
println(map1.getOrElse("k4","不存在"))
//过滤k4
val map2filter = map1.filter((tuple2) => {
val key: String = tuple2._1
val value: String = tuple2._2
var flag = false
if (key == "k2") {
flag = true
}
flag
})
map2filter
println(map2filter)
//简写
println(map1.filter(_._1=="k1"))
（2）hashmap（可变的）
val hashmap = mutable.HashMap("k1"->"v1","k2"->"v2","k3"->"v3")
println(hashmap)
hashmap.+=("k4"->"v4")
println(hashmap)
6、数组
Array不可变的，Arraybuffer可变的