Scala系列之：深入浅出理解集合
- 一、集合简介
- 二、不可变数组
- 三、可变数组
- 四、可变数组与不可变数组的转换
- 五、多维数组
一、集合简介
- Scala的集合有三大类：序列Seq、集Set、映射Map，所有的集合都扩展自Iterable特质。
- 对于几乎所有的集合类，Scala都同时提供了可变和不可变的版本，分别位于以下两个包：
- Scala不可变集合，就是指该集合对象不可修改，每次修改就会返回一个新对象，而不会对原对象进行修改。类似java中的String对象
- 可变集合，就是这个集合可以直接对原对象进行修改，而不会返回新的对象。类似于java中StringBuilder对象
二、不可变数组
方式一：
- val arr1 = new ArrayInt
- new是关键字
- [int]是指定可以存放的数据类型，如果希望存放任意数据类型，则指定Any
- (10)表示数组的大小，确定后就不可以变化
object ArrayTest {
def main(args: Array[String]): Unit = {
//1.创建数组
val arr: Array[Int] = new Array[Int](5)
//2.另一种创建方式
val arr2 = Array(12,37,42,58,97)
//访问元素
println(arr2(2))
arr(0) = 45
arr(1) = 77
arr(2) = 66
println(arr(0))
//数组遍历
//普通for循环
for(i <- 0 until arr.length){
println("遍历方式一")
println(arr(i))
}
println("遍历方式二")
for(i <- arr.indices) println(arr(i))
println("---增强for循环---------")
//增强for循环
for(elem <- arr) println(elem)
println("------iter遍历元素------")
val iter = arr2.iterator
while(iter.hasNext) println(iter.next())
//调用foreach方法
println("-------调用foreach方法----------")
arr.foreach((elem: Int) => println(elem))
arr.foreach(println)
println("----遍历元素，添加连接符-------")
println(arr.mkString("-----"))
println("----------添加元素----------")
val newArr = arr.:+(34)
println(arr.mkString("--"))
println(newArr.mkString("--"))
val newArr2 = newArr.+:(666)
println(newArr2.mkString("--"))
val newArr4 = 19 +: 29 +: arr :+ 77
println(newArr4.mkString("***"))
}
}输出如下所示：
42
45
遍历方式一
45
遍历方式一
77
遍历方式一
66
遍历方式一
0
遍历方式一
0
遍历方式二
45
77
66
0
0
---增强for循环---------
45
77
66
0
0
------iter遍历元素------
12
37
42
58
97
-------调用foreach方法----------
45
77
66
0
0
45
77
66
0
0
----遍历元素，添加连接符-------
45-----77-----66-----0-----0
----------添加元素----------
45--77--66--0--0
45--77--66--0--0--34
666--45--77--66--0--0--34
19***29***45***77***66***0***0***77三、可变数组
import scala.collection.mutable.ArrayBuffer
object ArrayTest2 {
def main(args: Array[String]): Unit = {
//1.创建可变数组
val arr1: ArrayBuffer[Int] = new ArrayBuffer[Int]()
val arr2 = ArrayBuffer(22,33,44,55)
println(arr1.mkString(", "))
println(arr2.mkString("-"))
println(arr2.toString())
//2.访问元素
println(arr2(0))
val newArr2 = arr2 += 19
println(newArr2)
println(arr2==newArr2)
//添加元素
arr1.append(45)
println(arr1)
arr1.insert(0,11,22)
println(arr1)
arr1.insertAll(2,arr2)
arr1.prepend(3)
println(arr1)
arr1.remove(3)
println(arr1)
arr1.remove(0,4)
println(arr1)
arr1 -= 19
println(arr1)
}
}输出如下所示：
22-33-44-55
ArrayBuffer(22, 33, 44, 55)
22
ArrayBuffer(22, 33, 44, 55, 19)
true
ArrayBuffer(45)
ArrayBuffer(11, 22, 45)
ArrayBuffer(3, 11, 22, 22, 33, 44, 55, 19, 45)
ArrayBuffer(3, 11, 22, 33, 44, 55, 19, 45)
ArrayBuffer(44, 55, 19, 45)
ArrayBuffer(44, 55, 45)四、可变数组与不可变数组的转换
import scala.collection.mutable
import scala.collection.mutable.ArrayBuffer
object ArrayTest3 {
def main(args: Array[String]): Unit = {
//可变数组转换为不可变数组
val arr: ArrayBuffer[Int] = ArrayBuffer(23,66,88)
val newArr = arr.toArray
println(newArr.mkString(", "))
println(arr)
//不可变数组转换为可变数组
val buffer: mutable.Buffer[Int] = newArr.toBuffer
println(buffer)
println(newArr)
}
}输出如下所示
23, 66, 88
ArrayBuffer(23, 66, 88)
ArrayBuffer(23, 66, 88)
[I@704d6e83五、多维数组
object ArrayTest4 {
def main(args: Array[String]): Unit = {
val array = Array.ofDim[Int](2, 3)
array(0)(2) = 19
array(1)(0) = 25
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()
}
println("----foreach-----")
array.foreach(line => line.foreach(println))
array.foreach(_.foreach(println))
}}输出如下所示：
[I@a74868d, [I@365185bd
0
0
19
25
0
0
0 0 19
25 0 0
----foreach-----
0
0
19
25
0
0
0
0
19
25
0
0
