一、Array
1、不可变数组(Array)
// <1>、--=== 声明并初始化一个不可变数组 ===--
// <1.1>、静态的声明并初始化一个不可变数组
var array1 = Array(1, 2, 3, 4, 5)
println(s"array1= ${array1.mkString("[", ",", "]")}") // array1= [1,2,3,4,5]
// <1.2>、动态的声明并初始化一个不可变数组
var array2 = new Array[Int](5) // 这个数组中的元素都是默认值
println(s"array2= ${array2.mkString("[", ",", "]")}") // array2= [0,0,0,0,0]
// <2>、--=== 修改不可变数组内容 ===--
// <2.1>、修改静态初始化后的不可变数组内容
array1(1) = 10
println(s"array1= ${array1.mkString("[", ",", "]")}") // array1= [1,10,3,4,5]
// <2.1>、修改动态初始化后的不可变数组内容
for (i <- array2.indices) array2(i) = i
println(s"array2= ${array2.mkString("[", ",", "]")}") // array2= [0,1,2,3,4]
// <3>、--=== 追加元素 ===--
// array1 += (2) // 编译时异常,不可变数组无法扩展数组长度
// array2 += 3 // 编译时异常,不可变数组无法扩展数组长度
// <4>、--=== 删除元素 ===--
// array1 -= (1) // 编译时异常,不可变数组无法缩小数组长度
总结:
Ⅰ、不可变数组可以通过动态和静态两种方式创建,一旦创建完成,长度无法扩展或者缩小
Ⅱ、不可变数组在创建完成后,数组内的元素的值是可以进行修改的
Ⅲ、不可变数组的长度不可变,值可变
2、可变数组(ArrayBuffer)
// <1>、--=== 声明并初始化一个可变数组 ===--
// <1.1>、静态的声明并初始化一个可变数组
var array3 = ArrayBuffer(1, 2, 3, 4, 5)
println(s"array3= ${array3.mkString("[", ",", "]")}") // array3= [1,2,3,4,5]
// <1.2>、动态的声明并初始化一个可变数组
var array4 = new ArrayBuffer[Int] // 动态初始化的 ArrayBuffer 是一个空数组
println(s"array4= ${array4.mkString("[", ",", "]")}") // array4= []
// <2>、--=== 在可变数组中追加元素 ===--
// <2.1>、方式一
array3 += 20
println(s"array3= ${array3.mkString("[", ",", "]")}") // array3= [1,2,3,4,5,20]
// <2.2>、方式二
for (i <- 0 to 4) array4.append(i * 10)
println(s"array4= ${array4.mkString("[", ",", "]")}") // array4= [0,10,20,30,40]
// <3>、--=== 在可变数组中追加数组 ===--
array4 ++= (ArrayBuffer(11, 22, 33, 44))
println(s"array4= ${array4.mkString("[", ",", "]")}") // array4= [0,10,20,30,40,11,22,33,44]
// <4>、--=== 在可变数组中删除数组 ===-
array4 --= (ArrayBuffer(11, 22))
println(s"array4= ${array4.mkString("[", ",", "]")}") // array4= [0,10,20,30,40,33,44]
// <5>、--=== 修改可变数组内容 ===--
array3(4) = 15 // 将第 5 个元素的值修改成 15
println(s"array3= ${array3.mkString("[", ",", "]")}") // array3= [1,2,3,4,15,20]
// <6>、--=== 移除可变数组元素 ===--
array3.remove(0) // 移除第 1 个元素
println(s"array3= ${array3.mkString("[", ",", "]")}") // array3= [2,3,4,15,20]
总结:
Ⅰ、可变数组可以通过动态和静态两种方式创建
Ⅱ、可变数组在创建完成后,数组内的元素的值是可以进行修改的
Ⅲ、可变数组在创建完成后,可以往后面继续追加元素或者其他数组
Ⅳ、可变数组的长度可变,值可变
二、List
1、不可变列表(List)
// <1>、--=== 声明并初始化一个不可变列表 ===--
var list1 = List(1, 2, 3, 4, 5)
println(s"list1= ${list1.mkString("[", ",", "]")}") // list1= [1,2,3,4,5]
var list2 = Nil // 代表创建一个空列表
println(s"list2= ${list2.mkString("[", ",", "]")}") // list2= []
// <2>、--=== 修改不可变列表内容 ===--
// list1(1)= 10 // 代码报编译时异常,不可变列表内容不可以修改
// <3>、--=== 追加元素 ===--
// list1 += (2) // 编译时异常,不可变数组无法扩展数组长度
// list2 += 3 // 编译时异常,不可变数组无法扩展数组长度
// <4>、--=== 删除元素 ===--
// list1 -= (2) // 编译时异常,不可变列表无法缩小数组长度
总结:
Ⅰ、不可变列表一旦创建完成,长度无法扩展或者缩小
Ⅱ、不可变数组在创建完成后,数组内的元素的值是不可以进行修改的
Ⅲ、不可变数组在创建完成后,长度和值均不能修改
2、可变列表(ListBuffer)
// <1.1>、静态的声明并初始化一个可变列表
var list3 = ListBuffer(1, 2, 3, 4, 5)
println(s"array3= ${list3.mkString("[", ",", "]")}") // array3= [1,2,3,4,5]
// <1.2>、动态的声明并初始化一个可变列表
var list4 = new ListBuffer[Int] // 动态初始化的 ListBuffer 是一个空列表
println(s"list4= ${list4.mkString("[", ",", "]")}") // list4= []
// <2>、--=== 在可变列表中追加元素 ===--
// <2.1>、方式一
list3 += 20
println(s"list3= ${list3.mkString("[", ",", "]")}") // list3= [1,2,3,4,5,20]
// <2.2>、方式二
for (i <- 0 to 4) list4.append(i * 10)
println(s"list4= ${list4.mkString("[", ",", "]")}") // list4= [0,10,20,30,40]
// <3>、--=== 在可变列表中追加数组 ===--
list4 ++= (List(11, 22, 33, 44))
println(s"list4= ${list4.mkString("[", ",", "]")}") // list4= [0,10,20,30,40,11,22,33,44]
// <4>、--=== 在可变列表中删除数组 ===-
list4 --= (List(11, 22))
println(s"list4= ${list4.mkString("[", ",", "]")}") // list4= [0,10,20,30,40,33,44]
// <5>、--=== 修改可变列表内容 ===--
list3(4) = 15 // 将第 5 个元素的值修改成 15
println(s"list3= ${list3.mkString("[", ",", "]")}") // list3= [1,2,3,4,15,20]
// <6>、--=== 移除可变列表元素 ===--
list3.remove(0) // 移除第 1 个元素
println(s"list3= ${list3.mkString("[", ",", "]")}") // list3= [2,3,4,15,20]
总结:
Ⅰ、可变列表可以通过动态和静态两种方式创建
Ⅱ、可变列表在创建完成后,列表内的元素的值是可以进行修改的
Ⅲ、可变列表在创建完成后,可以往后面继续追加元素或者其他列表
Ⅳ、可变列表的长度可变,值可变
三、Set
// ====== 2、immutable.Set ======
// <1>、--=== 声明并初始化一个集合 ===--
var set1 = immutable.Set(1, 2, 3, 4, 5, 6)
println(s"set1= ${set1.mkString("[", ",", "]")}") // set1= [5,1,6,2,3,4]
// <2>、--=== 追加元素 ===--
set1 += (9)
println(s"set1= ${set1.mkString("[", ",", "]")}") // set1= [5,1,6,9,2,3,4]
set1 += (1) // 无法往集合中添加重复元素
println(s"set1= ${set1.mkString("[", ",", "]")}") // set1= [5,1,6,9,2,3,4]
// <3>、--=== 删除元素 ===--
set1 -= (1)
println(s"set1= ${set1.mkString("[", ",", "]")}") // set1= [5,6,9,2,3,4]
// ====== 2、mutable.Set ======
// <1>、--=== 声明并初始化一个集合 ===--
var set2 = mutable.Set(3, 4, 5, 6, 7, 8)
println(s"set2= ${set2.mkString("[", ",", "]")}") // set2= [5,6,3,7,4,8]
// <2>、--=== 追加元素 ===--
set1 += (9)
println(s"set1= ${set1.mkString("[", ",", "]")}") // set1= [5,1,6,9,2,3,4]
set1 += (1) // 无法往集合中添加重复元素
println(s"set1= ${set1.mkString("[", ",", "]")}") // set1= [5,1,6,9,2,3,4]
// <3>、--=== 删除元素 ===--
set1 -= (1)
println(s"set1= ${set1.mkString("[", ",", "]")}") // set1= [5,6,9,2,3,4]
总结:
Ⅰ、集合创建后里面的元素的顺序和存入时的顺序不一致,所以集合无法通过下标访问
Ⅱ、集合中无法存放重复的数据
Ⅲ、集合在创建完成后,长度可以修改
Ⅳ、集合中存放的是无序且不重复的数据,集合无法通过下标获取对应元素,集合在初始化完成后长度可扩展
四、Tuple
// <1>、--=== 声明并初始化一个元组 ===--
// 方法一
var tuple1 = new Tuple5[Int, Double, Int, String, Double](1, 2.2, 2, "1", 3)
println(s"tuple1= ${tuple1.toString()}") // tuple1= (1,2.2,2,1,3.0)
// 方法二
var tuple2 = ("111", "233", 2.3, 1, 2.34)
println(s"tuple2= ${tuple2.toString()}") // tuple2= (111,233,2.3,1,2.34)
// <2>、--=== 获取元组中的数据 ===--
var first = tuple2._1
println(first) // 111
var second = tuple2._2
println(second) // 233
var third = tuple2._3
println(third) // 2.3
var forth = tuple2._4
println(forth) // 1
var fifth = tuple2._5
println(fifth) // 2.34
// <3>、--=== 遍历元组中的数据 ===--
val iterator = tuple2.productIterator
for (i <- iterator) println(i)
总结:
Ⅰ、元组的值是通过将单个的值包含在圆括号中构成的
Ⅱ、元组的数据一旦初始化后,其中的元素就不能被修改
Ⅲ、元组最多存放 22 个元素,可以精确指定每一个元素的元素类型
五、Map
1、不可变 map(immutable.Map)
// <1>、--=== 创建并初始化一个不可变 map ===--
// 方法一
var map1 = immutable.Map[String, String](
("name", "userName"),
("age", "14")
)
println(s"map1= ${map1}") // map1= Map(name -> userName, age -> 14)
// 方法二
var map2 = immutable.Map[String, String](
"name" -> "userName",
"age" -> "14"
)
println(s"map2= ${map2}") // map2= Map(name -> userName, age -> 14)
// <2>、--=== 给不可变 map 追加 kv 对 ===--
// <2.1>、追加 k-v 对
map1 += ("height" -> "122")
println(s"map1= ${map1}") // map1= Map(name -> userName, age -> 14, height -> 122)
// <2.2>、修改现有 key 对应的 value
// map1("name") = "Tom" // 编译时异常,不能修改已经存在的 key 对应的 value
// <3>、--=== 删除不可变 map 已有的 kv 对 ===--
map1 -= ("age")
println(s"map1= ${map1}") // map1= Map(name -> userName, height -> 122)
// <4>、--=== 根据 key 值获取对应的 value 值 ===--
println(map1("name"))
总结:
Ⅰ、map 是键值对偶的集合,对偶元组的最简单形态
Ⅱ、map 的 key 不允许重复,一旦出现重复后面添加的值会将前面添加的值覆盖
Ⅲ、不可变 map 在初始化后,已经存在的键的值无法被修改
Ⅳ、不可变 map 在初始化后,可以对 map 进行追加或者删除
2、可变 map(mutable.Map)
// <1>、--=== 创建并初始化一个可变 map ===--
var map3 = mutable.Map[String, String](
"key1" -> "value1",
"key2" -> "value3",
"key3" -> "value3"
)
// <2>、--=== 给不可变 map 追加 kv 对 ===--
// <2.1>、追加 k-v 对
map3 += ("key4" -> "value4")
println(s"map3= ${map3}") // map3= Map(key2 -> value3, key4 -> value4, key1 -> value1, key3 -> value3)
// <2.2>、修改现有 key 对应的 value
map3("key1") = "newValue1"
println(s"map3= ${map3}") // map3= Map(key2 -> value3, key4 -> value4, key1 -> newValue1, key3 -> value3)
// <3>、--=== 删除不可变 map 已有的 kv 对 ===--
map3 -= ("key1")
println(s"map3= ${map3}") // map3= Map(key2 -> value3, key4 -> value4, key3 -> value3)
总结:
Ⅰ、可变 map 在初始化后,已经存在的键的值可以被修改
Ⅱ、可变 map 在初始化后,可以对 map 进行追加或者删除