2.1

集合
分类：

可变集合 线程不安全

集合本身可以动态变化，且可变集合提供了改变集合内元素而都方法。

scala.collection.mutable //需要手动导包

不可变集合 线程安全

默认类库，集合内的元素一旦初始化完成就不可再进行更改，任何对集合的改变都将生成一个新的集合。

scala.collection.immutable //不需要手动导包

Set 无序、唯一
HashSet
SortedSet
TreeSet
BitSet
ListSet
Seq 序列、有序、可重复、元素有索引
IndexedSeq 索引序列，随机访问效率高
NumericRange Range的加强
Range 有序整数序列，类似等差数列
Vector 通用不可变的数据结构，获取元素时间长，随机更新快于数组或列表
String 字符串
LinearSeq 线性序列，主要操作首尾元素
List 列表
Queue 队列
Stack 栈 不可变栈已经弃用
Stream 流
Map
HashMap
SortedMap
TreeMap
ListMap
可变集合比不可变集合更丰富，例如在 Seq 中，增加了 Buffer 集合，例如 ArrayBuffer 和 ListBuffer。

Traverable
Traverable 是一个特质，它的子特质 immutable.Traverable 和 mutable.Traverable 分别是不可变集合和可变集合的父特质。

格式：

创建空的Traverable 对象。

val t = Traverable.empty[Int]
val t = Traverable[Int]()
val t = Nil

创建带参数的Traverable 对象。

val t = List(1, 2, 3).toTraverable
val t = Traverable(1, 2, 3)//默认生成List

转置：

使用 transpose 方法。

转置操作时，需要每个集合的元素个数相同。

def main(args: Array[String]): Unit = {
val t1 = Traversable(Traversable(1, 4, 7), Traversable(2, 5, 8), Traversable(3, 6, 9))
println(t1)//List(List(1, 4, 7), List(2, 5, 8), List(3, 6, 9))
val transpose = t1.transpose
println(transpose)//List(List(1, 2, 3), List(4, 5, 6), List(7, 8, 9))
}

拼接：

++ 可以拼接数据，但是会创建大量临时集合，可以通过 concat 方法实现。

def main(args: Array[String]): Unit = {
val t1 = Traversable(1, 2, 3)
val t2 = Traversable(4, 5, 6)
val traversable = Traversable.concat(t1, t2)
println(traversable)//List(1, 2, 3, 4, 5, 6)
}

筛选：

利用 collect 方法实现偏函数结合集合使用，从集合中筛选指定数据。

def main(args: Array[String]): Unit = {
val t1 = (1 to 10).toList
def filter:PartialFunction[Int, Int] = {
case x if x % 2 == 0 => x
}
//val t2 = t1.collect(filter)
val t2 = t1.collect({
case x if x % 2 == 0 => x
})
println(t2)//List(2, 4, 6, 8, 10)
}

scan 方法

def scan[B](z:B)(op: (B, B) => B)
1
[B] 表示返回值的数据类型，(z:B)表示初始化值，(op: (B, B) => B)表示具体的函数运算。

示例：定义 traversable 集合，存储1-5，假设初始值为1，分别获取每个元素的阶乘值。

def main(args: Array[String]): Unit = {
val t1 = 1 to 5
//val seq = t1.scan(1)((a, b) => a * b)
val seq = t1.scan(1)(_ * _)
println(seq)//Vector(1, 1, 2, 6, 24, 120)
}

获取集合指定元素

head/last ： 获取第一个/最后一个元素，不存在抛出异常

headOption/lastOption ： 获取获取第一个/最后一个元素，返回值是 Option

find： 查找符号条件的第一个元素

slice ：截取集合中的一部分元素，左闭右开

def main(args: Array[String]): Unit = {
val t1 = 1 to 5
println(t1.head)//1
println(t1.last)//5
println(t1.headOption)//Some(1)
println(t1.lastOption)//Some(5)
println(t1.find(_ % 2 == 0))//Some(2)
println(t1.slice(0, 2))//Vector(1, 2)
}

判断元素是否合法

forall 如果集合中所有元素都满足条件返回 true

exist 如果集合中有一个元素满足条件返回 true

def main(args: Array[String]): Unit = {
val t1 = 1 to 5
println(t1.forall(_ % 2 == 0))//false
println(t1.exists(_ % 2 == 0))//true
}

聚合函数

count 统计集合中满足条件的元素个数

sum 获取集合元素和

product 获取集合中所有元素成绩

max 获取集合中所有元素最大值

min 获取集合中所有元素最小值

集合类型转换

toList
toSet
toArray
toSeq
填充元素

fill 快速生成指定数量的元素

iterator 根据指定条件，生成指定个数的元素

range 生成某个区间内的指定间隔的所有数据，不传间隔参数默认 1

def main(args: Array[String]): Unit = {
val t1 = Traversable.fill(5)("a")
println(t1)//List(a, a, a, a, a)
val t2 = Traversable.fill(2, 2, 2)("a")
println(t2)//List(List(List(a, a), List(a, a)), List(List(a, a), List(a, a)))
val t3 = Traversable.iterate(1, 5)(_ * 10)
println(t3)//List(1, 10, 100, 1000, 10000)
val t4 = Traversable.range(1, 100, 7)
println(t4)//List(1, 8, 15, 22, 29, 36, 43, 50, 57, 64, 71, 78, 85, 92, 99)
}

案例：随机学生序列
定义一个 Traversable 集合，包含 5 个学生信息，学生姓名年龄随机生成。

按照学生年龄降序排列并打印。

object ClassDemo {

case class Student(name:String, age:Int)

def main(args: Array[String]): Unit = {
val names: List[String] = List("aa" ,"bb", "cc", "dd", "ee")
val r:Random = new Random()
val students = Traversable.fill(5)(Student(names(r.nextInt(names.size)), r.nextInt(10) + 20))
val list = students.toList
val list1 = list.sortWith(_.age < _.age)
println(list1)//List(Student(ee,22), Student(bb,23), Student(ee,23), Student(ee,24), Student(aa,26))
}

}