Scala（Array,List,Set,Map,Tuple,字符串 使用的简单介绍）

目录

Array 不可变数组

 ArrayBuffer可变数组

List 不可变列表

ListBuffer 可变列表

Set 集合（可变不可变）

Map映射(可变不可变)(键值对) 

Tuple 元组 

 字符串

Array 不可变数组

//    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可变数组

    //    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 不可变列表

    //    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 可变列表

    //    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 集合（可变不可变）

    //    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映射(可变不可变)(键值对) 

    //    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 元组 

    // 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 中的一种数据类型，它可以包含任意数量的字符。
    // 字符串是不可变的，一旦创建就不能修改。
    // 字符串可以通过索引来访问，索引从 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+")解释

val words = sentence.split("\\s+")

在正则表达式中，\\s 表示空白字符，包括空格、制表符（\t）、换行符（\n）等。而 + 是一个量词，表示前面的字符（这里就是空白字符 \\s）可以出现一次或多次。

所以在 sentence.split("\\s+") 这个语句中，是按照一个或多个连续的空白字符来分割字符串 sentence 的。

例如，如果有一个字符串 "Hello World"，使用这个表达式分割后，就会得到 ["Hello", "World"] 两个子字符串。