集合是一种用来存储各种对象和数据的容器
Scala集合分为可变和不可变的集合,不可变集合可以安全的并发访问
- 可变集合可以在适当的地方被更新或拓展,这意味着你可以修改,添加,移除一个集合的元素
- 不可变集合,相比之下,永远不会改变。不过,仍然可以模拟添加,移除或更新操作。但是这些操作将在每一种情况下都返回一个新的集合,同时使原来的集合不发生改变
Scala集合两个主要的包:
- 不可变集合:scala.collection.immutable
- 可变集合:scala.collection.mutable
- Scala默认采用不可变集合
Scala的集合有三大类:序列Seq、集合Set、映射Map,所有的集合都拓展自Iterable特质
定长数组Array
数据的构建
- 使用new关键字创建一个定长数组
val array = new Array[Int](30) //长度为30的整型数组,所有元素初始化为0
- 直接使用Array创建并初始化一个数组
val sArr = Array("hello","world") //长度为2的Array[String],类型是推断出来的,所以不需要new
数组的赋值
数组名(index) = 值
sArr(0) = "Hello Tom" //使用()而不是[]来访问元素
获取数组元素
数组名(index)
val result = sArr(1)
可变数组ArrayBuffer
对于长度按需要变化的数组,Java有ArrayList,Scala中的等效数据结构为ArrayBuffer
ArrayBuffer是一种mutable的数据容器,相对于Array来说,最大的的区别结束可以自由增删元素,ArrayBuffer构建完毕后,还可以转换为immutable的Array容器
Array和ArrayBuffer的转换
- Array与ArrayBuffer的转换
定长数组转换成变长数组
val ab = a.toBuffer
变长数组转换成定长数组
val a = array.toArray
- 数组的遍历
全遍历常用遍历
for(i <- array) println(i)
条件遍历
for(i <- array if i!= 2) println(i)
foreach
array.foreach(a => println(a))
内置常见函数
求和
Array(1,7,9).sum
求最大值
ArrayBuffer.max
排序
//升序
val b = ArrayBuffer(1,7,9,2)
val bSorted = b.sorted //1,2,7,9
b.sortWith(_<_).foreach(println(_))
//降序
b.sortWith(_>_).foreach(println(_))
显示数组内容
println(b.mkString("And")) //分隔符
println(b.mkString("<",".",">")) //<1.7.9.2> 指定前缀、分隔符、后缀
Map
在Scala中,把哈希表这种数据结构叫做映射
Map是一个对偶,映射的k-v键值对的集合,在一个map中可以包含若干组k-v映射关系,前提条件是k不能重复
Scala中的Map存储的内容是键值对(key-value),Scala中不可变的Map是有序的,可变的Map是无序的。
Scala中,有可变Map(scala.collection.mutable.Map)和不可变Map(sclaa.collection.immutable.Map)
不可变映射
val personAge = Map("Alice"->20,"Job"->18)
上述代码构造出一个不可变的Map[String,Int],其值不能被改变
也可以用此方法创建Map
val personAges = Map(("Alice"->20),("Marry"->18))
注:->用来创建元组,“sa”->1 即 (“Alice”,20)
val personMap = Map[String,Int]("zs"->13,"ls"->14)
val key = "ww"
if (personMap.contains(key)) {
val optionAge: Option[Int] = personMap.get(key)
println(optionAge.get)
println(personMap(key))
}else{
println("no key")
println(personMap.getOrElse(key,-1)) //默认值
}
//personMap("ww") = 16 不可以
println(personMap)
println(personMap.drop(1)) //drop删除 返回一个新的集合 原来的不变
可变映射
如果想要一个可变映射,则用
val personAge = scala.collection.mutable.Map("Alice"->20,"Job"->18)
如果想从一个空的映射开始,需要选定一个映射实现并给出类型参数
val personAge = new scala.collection.mutable.HashMap[String,Int]
在Scala中,映射是对偶的集合,对偶简单地说就是两个值构成的组,这两个值并不一定是同一个类型的
遍历
val ks = nameMap.keys
for (key <- ks){
val value = nameMap(key)
println(key + "--->" + value)
}
//Scala推荐的方式1
for ((k,v) <- nameMap) {
println(k + "->" + v)
}
//Scala推荐的方式2
for (kv <- nameMap) {
println(kv._1 + "-->" + kv._2)
}
//Scala推荐的方式3
nameMap.foreach(kv => {
println(kv._1 + "-->" + kv._2)
})
元组Tuple
映射是键/值对的集合,对偶足元组(Tuple)的最简单形态,元组是不同类型的值的聚集。元组的值是通过将单个的值包含在圆括号中构成的。例如 (1,3.14,“abc”)是一个元组,类型为Tuple3[Int,Double,java.lang.String]
- 获取元组元素
val t = (1,3.14,"abc")
println(t._1 + "\t" + t._2 + "\t" + t._3)
val (first,second,third,fourth) = t
println(first + " " + second + third + fourth)
println("New York".partition(_.isUpper))
- 遍历元素
t.productIterator.foreach(x => println(x))
**注意:**和数组或字符串中的位置不同,元组的各组元从1开始,而不是0。可以把t._2写成t _2,即用空格而不是句点,但不能写成t_2
zip拉链操作
zip操作,就是将两个单列的集合,组合成双列的集合,集合中的每一组元素就是上述学习过的tuple。
val province = Array("河南","山东","陕西","福建","四川")
val capital = Array("郑州","济南","西安","福州")
val pcs:Array[(String,String)] = province.zip(capital) // 多余的自动裁剪
for (pc <- pcs){
val p = pc._1
val c = pc._2
println(s"province:${p}, capital:${c}")
}
val pcAll:Array[(String,String)] = province.zipAll(capital,"","") // 多余的根据提供的内容自填充 for (pc <- pcAll){
val p = pc._1
val c = pc._2
println(s"province:${p}, capital:${c}")
}