目录
[Array 不可变数组](#Array 不可变数组)
[List 不可变列表](#List 不可变列表)
[ListBuffer 可变列表](#ListBuffer 可变列表)
[Set 集合（可变不可变）](#Set 集合（可变不可变）)
[Tuple 元组](#Tuple 元组)
Array 不可变数组
Scala
// Array 数组
// scala 中的数组下标是()
// scala 中的数组是值类型，不是引用类型
// scala 中的数组是定长的，一旦创建，长度不可变
// 创建一个长度为3的数组，并初始化
val arr = Array[String]("apple", "banana", "orange")
// 创建一个长度为3的数组
val arr1 = new Array[String](3)
// 给数组赋值
arr1(0) = "apple"
arr1(1) = "banana"
arr1(2) = "orange"
// 数组创建并初始化
val arr2 = Array("apple", "banana", "orange")
// 整型数组
val arr3 = Array(1, 2, 3, 4, 5)
// 创建一个包含1到9的数组
val arr4 = Array.range(1, 10)
// 遍历数组arr4
for (i <- arr4) {
println(i)
}
// 创建一个包含1到9，步长为2的数组
val arr5 = Array.range(1, 10, 2)
for (i <- arr5) {
println(i)
}ArrayBuffer可变数组
Scala
// ArrayBuffer
// 用这个可变数组前要导入
// import scala.collection.mutable.ArrayBuffer
// 创建一个可变数组
val arr6 = ArrayBuffer[String]()
// arr6.append("apple")
// val arr7 = ArrayBuffer("apple","banana","orange")
// += 追加元素
// += 操作符是在原数组基础上追加的
arr6 += "apple"
// 追加多个
arr6 += ("banana", "orange")
// ++= 追加一个数组
// ++=操作符用于将一个可迭代对象（如数组、列表等）
// 中的所有元素追加到目标可变对象（如可变数组）的末尾。
// ++=操作的本质是遍历右侧操作数中的每个元素，
// 并将这些元素逐个添加到左侧的可变对象中，
// 所以右侧操作数需要是能够被遍历的可迭代对象。
arr6 ++= Array("pear", "grape")
// 遍历数组
for (i <- arr6) {
println(i)
}
// -= 删除指定元素
arr6 -= "apple"
// -= 删除一个多个元素
arr6 -= ("banana", "orange")
// --= 删除一个数组
arr6 --= Array("pear", "grape")
// 遍历数组
for (i <- arr6) {
println(i)
}
println("\n")
// 创建一个可变数组
val arr7 = ArrayBuffer(11, 22, 33, 44, 55, 66)
// 删除指定下标的元素
arr7.remove(1)
for (i <- arr7) {
println(i)
}
println("\n")
// 删除指定下标和指定长度的元素
arr7.remove(1, 2)
for (i <- arr7) {
println(i)
}List 不可变列表
Scala
// List 列表
// 创建一个列表
val list1 = List(1, 2, 3)
// 创建一个空列表
val list2 = List()
// 创建一个包含11到19的列表
val list3 = List.range(11, 20)
// 创建一个包含20到29，步长为2的列表
val list4 = List.range(20, 30, 2)
// 遍历列表list4
for (i <- list4) {
println(i)
}
println("\n")
// ++ 是用于连接两个列表的操作符
// 将list3中的所有元素追加到list1的末尾，
// 从而创建一个 新的列表 list5
val list5 = list1 ++ list3
for (i <- list5) {
println(i)
}
println("\n")
// :: 是用于在列表的开头添加元素的操作符
val list6 = 20 :: list1
for (i <- list6) {
println(i)
}
println("\n")
// ::: 是用于连接两个列表的操作符
// 将list1中的所有元素追加到list2的末尾，
// 从而创建一个 新的列表 list7
val list7 = list2 ::: list1
for (i <- list7) {
println(i)
}ListBuffer 可变列表
Scala
// ListBuffer 可变列表
// 要先导入下面
// import scala.collection.mutable.ListBuffer
// 创建一个可变列表
val list8 = new ListBuffer[String]()
// += 追加元素
list8 += "张三"
// += 追加多个元素
list8 += ("李四", "王五")
// ++= 追加一个列表
list8 ++= List("赵六", "钱七")
// 遍历
for (i <- list8) {
println(i)
}
println("\n")
// -= 删除指定元素
list8 -= "张三"
// -= 删除多个元素
list8 -= ("李四", "王五")
// --= 删除一个列表
list8 --= List("赵六", "钱七")
// 遍历
for (i <- list8) {
println(i)
}
println("\n")
// 创建一个可变列表
val list9 = ListBuffer(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
// 删除指定下标的元素
list9.remove(1)
// 遍历
for (i <- list9) {
println(i)
}
println("\n")
// 删除指定下标和指定长度的元素
list9.remove(0, 2)
// 遍历
for (i <- list9) {
println(i)
}
println("\n")Set 集合（可变不可变）
Scala
// Set 集合
// 会自动实现去重
// 是无序的
// 创建一个不可变集合
val s1 = Set(1, 2, 3, 4, 5)
for (i <- s1) {
println(i)
}
println("\n")
// 添加元素，生成一个新的集s2
val s2 = s1 + 6
for (i <- s2) {
println(i)
}
println("\n")
// 判断s2是否包含6，包含7
val a1 = s2.contains(6)
val a2 = s2.contains(7)
println(a1) //true
println(a2) // false
println("\n")
// Set 可变集合
// 要导入
import scala.collection.mutable.Set
// 创建一个空的可变集合
val s3 = Set.empty[Int]
// 添加元素
s3 += (44, 22, 22, 33) // 会自动实现去重
for (i <- s3) {
println(i)
}
println("\n")
val s5 = Set(1, 2, 3, 4, 5)
// 删除元素
s5 -= 1
for (i <- s5) {
println(i)
}
println("\n")
val b1 = s5.contains(3)
println(b1) // true
val b2 = s5.contains(6)
println(b2) // false
println("\n")Map映射(可变不可变)(键值对)
Scala
// Map 映射
// Map 是一种键值对的集合，其中每个键都是唯一的，每个键都映射到一个值。
// Map 的键和值可以是任意类型的对象，但键必须是可哈希的。
// Map 是不可变的，但可以通过添加或删除键值对来创建一个新的 Map。
// Map 的键值对是通过键来访问的，可以使用键来获取对应的值。
// Map 的键值对是无序的，但可以通过键的顺序来访问它们。
// Map 的键值对是可变的，可以通过修改键值对来改变 Map 的内容。
// 创建一个不可变映射
val map1 = Map("apple" -> 1, "banana" -> 2, "orange" -> 3)
// 遍历
for ((k, v) <- map1) { // k 是键，v 是值
println(k + " : " + v)
}
println("\n")
val c1 = map1.contains("apple")
println(c1) // true
println("\n")
// 创建一个可变映射
// 要导入
import scala.collection.mutable.Map
val map2 = Map("aa"-> 11,"bb"->22,"cc"->33)
// 添加键值对
map2 += ("dd" -> 44,"ff"-> 66)
map2("ee") = 55
// 遍历
for ((k, v) <- map2) {
println(k + " : " + v)
}
println("\n")
// 删除键值对
map2 -= "aa"
map2 -= ("ee","cc")
// 遍历
for ((k, v) <- map2) {
println(k + " : " + v)
}
println("\n")
// 获取指定键的值
val v1 = map2("bb")
println(v1) // 22
println("\n")
// 获取指定键的值，如果不存在则返回默认值
val v2 = map2.getOrElse("gg", 0)
println(v2) // 0
println("\n")
// 获取所有的键和值,返回一个集合
val set1 = map2.keys
val set2 = map2.values
// 遍历
for (i <- set1) {
println(i)
}
for (i <- set2) {
println(i)
}
println("\n")Tuple 元组
Scala
// Tuple 元组
// 元组是 Scala 中的一种数据结构，它可以包含多个不同类型的元素，但元组的长度是固定的。
// 元组中的元素可以通过索引来访问，索引从 1 开始。
// 元组是不可变的，一旦创建就不能修改。
// 元组可以用于返回多个值，或者将多个值组合成一个单一的值。
// 元组可以用于模式匹配，以便从复杂的结构中提取出特定的元素。
// 创建一个三元组，有三个元素，元组类型为(int,String,double)
val t1 = (1, "hello", 3.14)
// 使用下划线_语法 来访问元组中的元素。
// tuple._n取出元祖的第 n 个元素，第一元素下标为1
val a = t1._1
val b = t1._2
val c = t1._3
println(a)
println(b)
println(c)
println("\n")
// 遍历元组
for (i <- t1.productIterator) {
println(i)
}
// productIterator方法
// productIterator方法的主要作用是提供一种统一的方式来遍历对象的所有元素，
// 无论这个对象是元组还是样例类。
// 它返回一个迭代器，这个迭代器可以用于遍历对象中的所有元素。
// 可以使用for循环来遍历元组中的所有元素。
// 可以使用foreach方法来遍历元组中的所有元素。
// 可以使用map方法来遍历元组中的所有元素，并将每个元素映射到一个新的值。
// 可以使用filter方法来遍历元组中的所有元素，并返回满足特定条件的元素。
// 可以使用zip方法来将两个元组中的元素组合成一个新的元组。
// 可以使用unzip方法来将一个元组中的元素拆分成两个元组。
// 可以使用flatten方法来将一个元组中的所有元素展开成一个单一的元组。
// 可以使用fold方法来将一个元组中的所有元素组合成一个单一的值。
println("\n")字符串
Scala
// 字符串
// 可以看成是一个字符数组
// 字符串是 Scala 中的一种数据类型，它可以包含任意数量的字符。
// 字符串是不可变的，一旦创建就不能修改。
// 字符串可以通过索引来访问，索引从 0 开始。
// 字符串可以通过连接运算符（+）来连接。
// 字符串可以通过插值运算符（s）来插入变量。
// 字符串可以通过正则表达式来匹配和替换。
// 字符串可以通过字符串方法来操作，例如toUpperCase、toLowerCase、substring等。
// 字符串可以用于表示文本数据，例如文件名、URL、用户名等。
// 字符串可以用于表示二进制数据，例如图片、音频、视频等。
val str1 = "hello world"
// 分割字符串，调用split方法，结果为一个数组
val arr11 = str1.split(" ") // 按空格分割
for (i <- arr11) {
println(i)
}
println("\n")
val str2 = "I love you"
// 字符串的长度
val len = str2.length
println(len)
println("\n")
// 字符串的索引
val cc1 = str2(0)
println("str2(0)位置是 " + cc1)
println("\n")
val cc2 = str2.charAt(4)
println("str2(4)位置是 " + cc2)
// 字符串的遍历
for (i <- str2) {
println(i)
}
println("\n")
// 字符串的连接
val str3 = "I " + "love " + "you"
println(str3)
println("\n")
// 字符串的插值
val name = "Alice"
val age = 20
val str4 = s"My name is $name, I am $age years old."
println(str4)
println("\n")
// 字符串的匹配
val str5 = "hello world"
val pattern = "hello"
val result = str5.matches(pattern)
println(result)
println("\n")
// 字符串的替换
// replace方法，将字符串中的第一次出现的指定字符替换为新的字符
// replaceAll方法，将字符串中的出现的所有指定字符替换为新的字符，支持正则表达式
val str6 = "hello world"
val result1 = str6.replace("hello", "hi")
val r = str6.replaceAll("world","Scala")
println("result1的结果是 " + result1)
println("r的结果是 " + r)
println("\n")
// 字符串的截取
val str7 = "hello world"
val result2 = str7.substring(0, 5)
println(result2)
println("\n")
// 字符串的转换,全换大写
val str8 = "hello world"
val result3 = str8.toUpperCase
println(result3)
println("\n")
// 字符串的转换，全换小写
val result4 = str8.toLowerCase
println(result4)
println("\n")
// 字符串的反转
val result5 = str8.reverse
println(result5)
println("\n")
// 字符串的去除空格
val result6 = str8.trim
println(result6)
println("\n")
// 字符串的首字母大写
val result7 = str8.capitalize
println(result7)
println("\n")
// 字符串的包含
val result8 = str8.contains("hello")
println(result8)
println("\n")
// 出现hello的第一个索引位置
val result9 = str8.indexOf("hello")
println(result9)
println("\n")
// 出现hello的最后一个索引位置
val result10 = str8.lastIndexOf("hello")
println(result10)
println("\n")
// 字符串是否以hello开头
val result11 = str8.startsWith("hello")
println(result11)
println("\n")
// 字符串是否以world结束
val result12 = str8.endsWith("world")
println(result12)
println("\n")
// 字符串是否为空
val result13 = str8.isEmpty
println(result13)
println("\n")split("\\s+")解释
Scala
val words = sentence.split("\\s+")在正则表达式中，\\s 表示空白字符，包括空格、制表符（\t）、换行符（\n）等。而 + 是一个量词，表示前面的字符（这里就是空白字符 \\s）可以出现一次或多次。
所以在 sentence.split("\\s+") 这个语句中，是按照一个或多个连续的空白字符来分割字符串 sentence 的。
例如，如果有一个字符串 "Hello World"，使用这个表达式分割后，就会得到 ["Hello", "World"] 两个子字符串。