Scala集合介绍
集合简介
1）Scala 的集合有三大类：序列 Seq、集 Set、映射 Map，所有的集合都扩展自 Iterable
特质。
2）对于几乎所有的集合类，Scala 都同时提供了可变和不可变的版本，分别位于以下两
个包
- 不可变集合：scala.collection.immutable
- 可变集合： scala.collection.mutable
3）Scala 不可变集合，就是指该集合对象不可修改，每次修改就会返回一个新对象，而
不会对原对象进行修改。类似于 java 中的 String 对象。
4）可变集合，就是这个集合可以直接对原对象进行修改，而不会返回新的对象。类似
于 java 中 StringBuilder 对象。
建议：在操作集合的时候，不可变用符号，可变用方法
不可变集合继承图
1）Set、Map 是 Java 中也有的集合
2）Seq 是 Java 没有的，我们发现 List 归属到 Seq 了，因此这里的 List 就和 Java 不是同一个概念。
3）我们前面的 for 循环有一个 1 to 3，就是 IndexedSeq 下的 Range
4）String 也是属于 IndexedSeq
5）我们发现经典的数据结构比如 Queue 和 Stack 被归属到 LinearSeq(线性序列)
6）大家注意 Scala 中的 Map 体系有一个 SortedMap，说明 Scala 的 Map 可以支持排序
7）IndexedSeq 和 LinearSeq 的区别：
- IndexedSeq 是通过索引来查找和定位，因此速度快，比如 String 就是一个索引集合，通过索引即可定位
- LinearSeq 是线型的，即有头尾的概念，这种数据结构一般是通过遍历来查找
可变集合继承图
数组
不可变数组
基本介绍
1）第一种方式定义数组
val arr1 = new Array[Int](10)
其中：
（1）new 是关键字
（2）[Int]是指定可以存放的数据类型，如果希望存放任意数据类型，则指定 Any
（3）(10)，表示数组的大小，确定后就不可以变化
2）第二种方式定义数组
val arr1 = Array(1, 2)
其中
（1）在定义数组时，直接赋初始值
（2）使用 apply 方法创建数组对象
案例实操
（1）创建数组
（2）访问数组
（3）赋值
（4）数组遍历
（5）添加数组元素
package chapter07
object Test01_ImmutableArray {
def main(args: Array[String]): Unit = {
//创建数组
val arr = new Array[Int](5)
//另一种创建的方式
val arr2 = Array(12,24,25) //apply方法省略
//访问数组的方法
println(arr(0))
println(arr(1))
println(arr(2))
println(arr(3)) // 等于arr.apply(3)
//赋值
arr(0) = 1 //等于arr.update(0) = 1
arr(1) = 3
println(arr(0))
//数组遍历
//for循环
for (i <- 0 until( arr.length)){
println(arr(i))
}
for (i <- arr.indices)
println(arr(i))
println("============")
//直接遍历所有元素，增强for循环
for (elem <- arr2)
println(elem)
//迭代器使用
val iter = arr2.iterator
while (iter.hasNext){
//元素是否有下一个
println(iter.next())
}
//调用foreach方法
arr2.foreach((elem: Int) => println(elem))
//上面的至简原则
arr2.foreach(println)
//底层实现的连接遍历
println(arr2.mkString("-"))
//添加数组元素（在最后面）
arr2.:+(73)
println(arr2.mkString("-"))
val arr3 = arr2.:+ (73) // 相当于创建一个新的数组
//简化
val arr5 = arr2 :+ 73
println(arr3.mkString("-"))
println(arr5.mkString("-"))
//添加数组元素（在最前面）
val arr4 = arr2.+:(73)
//简化
val arr6 = 73 +: arr2
println(arr6.mkString("-"))
//结合上面的两种方法
val arr7 = 72 +: 73 +: arr2 :+ 74 :+ 75
println(arr7.mkString("-"))
}
}
可变数组
基本介绍
1）定义变长数组
val arr01 = ArrayBuffer[Any](3, 2, 5)
其中
（1）[Any]存放任意数据类型
（2）(3, 2, 5)初始化好的三个元素
（3）ArrayBuffer 需要引入 scala.collection.mutable.ArrayBuffer
案例实操
（1）创建数组
（2）ArrayBuffer 是有序的集合
（3）访问以元素
（4）增加元素使用的是 append 方法()，支持可变参数
（5）删除元素
package chapter07
import scala.collection.mutable.ArrayBuffer
object Test02_ArrayBuffer {
def main(args: Array[String]): Unit = {
//创建一个可变数组
val arr1: ArrayBuffer[Int] = new ArrayBuffer[Int]()
val arr2 = ArrayBuffer(23,24,25)
println(arr1.mkString("-"))
println(arr2.mkString("-"))
println(arr2)
//访问元素
// println(arr1(0)) //java.lang.IndexOutOfBoundsException: 0 数组越界
println(arr2(0))
arr2(0) = 2121
println(arr2(0))
//添加元素
arr1 :+ 15
val newarr1 = arr1 :+ 15
println(arr1 == newarr1)
println(newarr1.mkString("-"))
val newarr2 = arr1 += 19
arr1 += 19 //可变数组采用这种方式在后面添加元素
println(arr1)
println(arr1 == newarr2)
20 +=: arr1 //可变数组采用这种方式在前面添加元素
println(arr1)
//可变数组推荐下面的方法
arr1.append(12,13) //在后面添加
println(arr1)
arr1.prepend(11,12) //在前面添加
println(arr1)
arr1.insert(1,121,211) //任意位置添加
println(arr1)
arr1.appendAll(newarr1) //在后面添加一个数组
println(arr1)
arr1.prependAll(newarr1) //在前面面添加一个数组
println(arr1)
arr1.insertAll(1, newarr1) //任意位置添加一个数组
println(arr1)
//删除元素
arr1.remove(4)
println(arr1)
arr1.remove(2,3) //第二个开始，删除3个
println(arr1)
arr1 -= 19 //删除19，多个的话，就删除一个
println(arr1)
}
}
不可变数组与可变数组的转换
基本介绍
arr1.toBuffer //不可变数组转可变数组
arr2.toArray //可变数组转不可变数组
其中
（1）arr2.toArray 返回结果才是一个不可变数组，arr2 本身没有变化
（2）arr1.toBuffer 返回结果才是一个可变数组，arr1 本身没有变化
案例实操
package chapter07
import scala.collection.mutable.ArrayBuffer
object Test02_ArrayBuffer {
def main(args: Array[String]): Unit = {
//创建一个可变数组
val arr1: ArrayBuffer[Int] = new ArrayBuffer[Int]()
val arr2 = ArrayBuffer(23,24,25)
//可变数组在转换为不可变数组
val arr = ArrayBuffer(1,2,3)
val newarr = arr.toArray
println(newarr.mkString("-"))
println(arr)
//不可变数组转换为不可变数组
val buffer = newarr.toBuffer
println(buffer)
}
}
多维数组
多维数组定义
val arr = Array.ofDim[Double](3,4)
说明：二维数组中有三个一维数组，每个一维数组中有四个元素
案例实操
package chapter07
object Test03_MulArray {
def main(args: Array[String]): Unit = {
//创建多维数组
val array = Array.ofDim[Int](2, 3) //2行3列
//访问元素
array(0)(2) = 12 //赋值
array(1)(0) = 13
//输出
println(array.mkString(","))
for (i <- 0 until array.length; j <- 0 until array(i).length)
println(array(i)(j))
//换行输出
for (i <- array.indices; j <- array(i).indices) {
print(array(i)(j) + "\t")
if (j == (array(i).length - 1))
println()
}
array.foreach(line => line.foreach(println))
//简写
array.foreach(_.foreach(println))
}
}
列表 List
不可变 List
基本介绍
1）说明
（1）List 默认为不可变集合
（2）创建一个 List（数据有顺序，可重复）
（3）遍历 List
（4）List 增加数据
（5）集合间合并：将一个整体拆成一个一个的个体，称为扁平化
（6）取指定数据
（7）空集合 Nil
案例实操
package chapter07
object Test04_List {
def main(args: Array[String]): Unit = {
//创建一个list
val list1 = List(1,2,3,4)
// println(list1.indices)
println(list1.mkString("-"))
//访问list元素
println(list1(1))
// list1(1) = 12 //error不能赋值
list1.foreach(println)
//添加元素
val list2 = list1 :+ 10
val list3 = 10 +: list1
println(list1)
println(list2)
println(list3)
// ::方法, 常用来创建一个新的list
val list4 = list1.::(521)
println(list4)
val list5 = Nil.::(12)
println(list5)
val list6 = 32 :: Nil
println(list6)
val list7 = 12 :: 13 :: 14 :: Nil
println(list7)
//合并list
val list8 = list7 :: list6 //不可以
println(list8)
val list9 = list7 ::: list6
println(list9)
val list10 = list7 ++ list6
println(list10)
}
}
可变 ListBuffer
基本介绍
1）说明
（1）创建一个可变集合 ListBuffer
（2）向集合中添加数据
（3）删除元素
（4）合并元素
（5）修改元素
（6）打印集合数据
案例实操
package chapter07
import scala.collection.mutable.ListBuffer
object Test05_ListBuffer {
def main(args: Array[String]): Unit = {
//创建可变列表
val list1 = new ListBuffer[Int]()
val list2 = ListBuffer(1,2,3) //伴生对象创建
println(list1)
println(list2)
//添加元素
list1.append(1,2)
println(list1)
list2.prepend(0)
println(list2)
list1 += 4 += 5
-1 +=: list1
println(list1)
//合并list
val list3 = list1 ++ list2
println(list1)
println(list2)
println(list3) //合并后
list1 ++= list2
println(list1) //合并后
println(list2)
//修改元素
list2(3) = 30
println(list2)
//删除元素
list2.remove(2)
println(list2)
//指定元素删除
list2 -= 30
println(list2)
//打印集合数据
buffer.foreach(println)
}
}
Set 集合
默认情况下，Scala 使用的是不可变集合，如果你想使用可变集合，需要引用
scala.collection.mutable.Set 包
不可变 Set
基本介绍
1）说明
（1）Set默认是不可变集合，数据无序
（2）数据不可重复
（3）遍历集合
（4）添加元素
（5）删除元素
（6）合并Set
案例实操
package chapter07
object Test06_ImmutableSet {
def main(args: Array[String]): Unit = {
//创建set
val set1 = Set(1,2,3,5,7,8,7,7,7)
println(set1) //自动去除重复的
//遍历集合
for(x<-set1){
println(x)
}
//添加元素
val set2 = set1.+(19)
val set3 = set1 + 20 //等于上面
println(set1)
println(set2)
println(set3)
//合并set
val set4 = Set(11,12,13,14)
var set5 = Set(15, 16, 17, 18)
set5 ++= set4
val set6 = set4 ++ set5
println(set6)
println(set5)
//删除元素
val set7 = set6 -13
println(set6)
println(set7)
}
}
可变集合
基本介绍
1）说明
（1）创建可变集合 mutable.Set
（2）打印集合
（3）集合添加元素
（4）向集合中添加元素，返回一个新的 Set
（5）删除数据
案例实操
package chapter07
import scala.collection.mutable
object Test07_MutableSet {
def main(args: Array[String]): Unit = {
//创建set
val set1 = mutable.Set(1,2,3,4,5)
println(set1)
//添加元素
set1 + 11
println(set1) //set1不改
val set2 = set1 + 1
println(set2)
set1 += 11
println(set1) //set1改了
set1.add(12)
println(set1) //推荐这种添加元素的方法（原集合有的话，不添加）
//删除元素
set1 -= 11
println(set1)
//合并两个set
val set3 = mutable.Set(12,22,32,42,52)
println(set1)
set1 ++ set3
println(set1)
println(set3)
val set4 = set1 ++ set3
println(set4)
}
}
Map 集合
Scala 中的 Map 和 Java 类似，也是一个散列表，它存储的内容也是键值对（key-value）映射。
不可变 Map
基本介绍
1）说明
（1）创建不可变集合 Map
（2）遍历元素
（3）访问数据
（4）如果 key不存在，返回 0
案例实操
package chapter07
object Test08_ImmutableMap {
def main(args: Array[String]): Unit = {
//创建map
val map1 : Map[String, Int]= Map("a" -> 12, "b"-> 13,"hello" -> 14)
println(map1)
println(map1.getClass)
//遍历元素
map1.foreach(println)
//等同于下面
map1.foreach((kv:(String,Int)) => println(kv))
//去map中所有的key或者value
for (key <- map1.keys){
println(s"$key ---> ${map1.get(key)}")
}
//访问某一个key的value
println(map1.get("a").get)
// println(map1.get("").get) //异常java.util.NoSuchElementException: None.get
println(map1.get("c")) //没有c 输出none
//上面方法容易抛异常，用下面的即使没有也不会抛异常
println("a: " + map1.getOrElse("a",0))
println("c: " + map1.getOrElse("c",0)) //后面的0是没有对应的数时的返回值
//或者直接下面可以获取value，没有的话，还是会抛异常
println(map1("a"))
// println(map1("c")) java.util.NoSuchElementException: key not found: c
}
}
可变 Map
基本结束
1）说明
（1）创建可变集合map
（2）打印集合
（3）增加数据
（4）删除数据
（5）修改数据
案例实操
package chapter07
import scala.collection.mutable
object Test09_MutableMap {
def main(args: Array[String]): Unit = {
//创建map
val map1 : mutable.Map[String, Int]= mutable.Map("a" -> 12, "b"-> 13,"hello" -> 14)
println(map1)
println(map1.getClass)
//添加元素
map1.put("c", 5)
map1.put("d", 6)
println(map1)
//用符号添加元素
map1 +=(("e",7))
println(map1)
//删除元素
map1.remove("e")
println(map1)
map1 -= ("d")
println(map1)
//修改元素
map1.put("c",8)
println(map1)
//合并两个map
val map2 : mutable.Map[String, Int]= mutable.Map("a2" -> 112, "b3"-> 113,"hello" -> 114)
map1 ++= map2
val map3 = map2 ++ map1
println(map1)
println(map3)
}
}
元组
基本介绍
1）说明
元组也是可以理解为一个容器，可以存放各种相同或不同类型的数据。说的简单点，就是将多个无关的数据封装为一个整体，称为元组。
注意：元组中最大只能有 22 个元素。
案例实操
（1）声明元组的方式：(元素 1，元素 2，元素 3)
（2）访问元组
（3）遍历元组
（4）嵌套元组
package chapter07
object Test10_Tuple {
def main(args: Array[String]): Unit = {
//创建元组
val tuple = ("hell0", 1 , 2.1 , true)
println(tuple)
//访问元组中的数据
println(tuple._1)
println(tuple._4)
//等同于下面的
println(tuple.productElement(1))
//遍历元组数据
for (elem <- tuple.productIterator)
println(elem)
//嵌套元组
val mulTuple = ("alice",2,3,(23,"scala"))
println(mulTuple._4._1)
}
}
并行集合
基本介绍
1）说明
Scala 为了充分使用多核 CPU，提供了并行集合（有别于前面的串行集合），用于多核
环境的并行计算。
案例实操
package chapter07
object Test20_Parallel {
def main(args: Array[String]): Unit = {
val range = 1 to 100
val result = range.map(
x => Thread.currentThread().getName
)
println(result)
val result1 = range.map(
y => Thread.currentThread().getId
)
println(result1)
println(result)
//并行执行
val result2 = range.par.map(
z => Thread.currentThread().getId
)
println(result2)
}
}