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)
}
}