当前位置：首页 > article >正文

Scala编程_数组、列表、元组、集合与映射

article 2025/3/13 11:06:31

简介：

Scala 是一种多范式编程语言，结合了面向对象编程和函数式编程的特性。它运行在 Java 虚拟机上，并且可以与 Java 代码无缝互操作。我主要记录一些我之前看过这本书的记录等。详细说一下Scala 中的一些基本数据结构，包括数组、列表、元组、集合和映射。

1. 数组（Array）

数组是 Scala 中最基本的数据结构之一，用于存储相同类型的元素。Scala 的数组是可变的，意味着修改数组中的元素。

创建数组

通过多种方式创建数组：

val greetStrings = new Array[String](3)
greetStrings.update(0, "hello")
greetStrings.update(1, ",")
greetStrings.update(2, "world!!\n")

这里我们创建了一个长度为 3 的字符串数组，并使用 update 方法为数组赋值。Scala 中的数组索引从 0 开始。

访问数组元素

apply 方法来访问数组中的元素：

for (i <- 0 to 2) {
  print(greetStrings.apply(i))
}

简洁方式创建和初始化数组：

val greetS1 = Array("hello", ",", "world!!")
for (i <- 0.to(2)) {
  print(greetS1.apply(i))
}

数组的不可变性

虽然数组本身是可变的，但数组的长度是不可变的。一旦创建了一个数组，就不能改变它的大小。

2. 列表（List）

列表是 Scala 中另一种常用的数据结构，与数组不同，列表是不可变的。这意味着一旦创建了一个列表，就不能修改它的内容。

创建列表

使用 List 对象创建一个列表：

val s1 = List(1, 2)
val s2 = List(3, 4)

列表的拼接

::: 操作符来拼接两个列表：

val s3 = s1 ::: s2
println(s3)  // 输出: List(1, 2, 3, 4)

在列表前添加元素

使用 :: 操作符在列表的前面添加一个元素：

val s4 = 1 :: s3
println(s4)  // 输出: List(1, 1, 2, 3, 4)

3. 元组（Tuple）

元组是 Scala 中用于存储不同类型元素的数据结构。与列表不同，元组是不可变的，并且可以存储不同类型的元素。

创建元组

使用圆括号来创建一个元组：

val pari1 = (1, "22")

访问元组元素

使用 ._1、._2 等方法来访问元组中的元素：

println(pari1._1)  // 输出: 1
println(pari1._2)  // 输出: 22

4. 集合（Set）

集合是 Scala 中用于存储唯一元素的数据结构。Scala 提供了可变和不可变两种版本的集合。

创建可变集合

使用 mutable.Set 来创建一个可变集合：

import scala.collection.mutable
val movieSet = mutable.Set("Li", "Wu")

添加元素

使用 += 操作符向可变集合中添加元素：

movieSet += "love"
println(movieSet)  // 输出: Set(Li, Wu, love)

不可变集合

Scala 默认的集合是不可变的，无需引入任何包即可使用：

val immutableSet = Set("apple", "banana")

5. 映射（Map）

映射是 Scala 中用于存储键值对的数据结构。Scala 提供了可变和不可变两种版本的映射。

创建可变映射

使用 mutable.Map 来创建一个可变映射：

import scala.collection.mutable
val tmap = mutable.Map[Int, String]()
tmap += (1 -> "guangzhou")
tmap += (2 -> "beijing")
tmap += (3 -> "shenzheng")
println(tmap(3))  // 输出: shenzheng

创建不可变映射

Scala 默认的映射是不可变的，你无需引入任何包即可使用：

val tiMap = Map(1 -> "hebei", 2 -> "chengde", 3 -> "shijiazhuang", 4 -> "beijing")
println(s"tiMap = ${tiMap}")  // 输出: tiMap = Map(1 -> hebei, 2 -> chengde, 3 -> shijiazhuang, 4 -> beijing)

以上就是我对这块知识点的总结，这是基础中的基础了。

IDEA里头的整体代码

自己拿着跑一跑吧

package ScalaBiancheng

import java.util.Properties

/**
 * Scala
 */
object Scala01_1RuMen {
  def main(args: Array[String]): Unit = {


    val prop = new Properties()
    val num1 = Array("qwe", "qe", "eqe")
    val num2 = Array.apply("qwe", "qe", "eqe")

    /**
     * 用类型参数化数组 ARRAY
     * 数组：用户相同类型的对象的可变数组
     */
    val greetStrings = new Array[String](3)
    greetStrings.update(0, "hello")
    greetStrings.update(1, ",")
    greetStrings.update(2, "world!!\n")
    for (i <- 0 to 2) {
      print(greetStrings.apply(i))
    }

    val greetS1 = Array("hello", ",", "world!!")
    for (i <- 0.to(2)) {
      print(greetS1.apply(i))
    }


    /**
     * List 列表 不可变
     */
    val s1 = List(1, 2)
    val s2 = List(3, 4)
    val s3 = s1 ::: s2 // :::是list的一个方法，用来拼接
    println(s3)

    // :: 在前面添加一个元素
    val s4 = 1 :: s3
    println(s4)


    /**
     * 元组 不可变，但能存不同的元素,最多22个
     *
     */

    var pari1 = (1, "22")
    println(pari1._1)
    println(pari1._2)

    /**
     * 集合set
     * 分为可变集合和不可变集合，可变的引入包
     * += 定义在可变集合里面，
     */
    import scala.collection.mutable
    val movieSet = mutable.Set("Li", "Wu")
    movieSet += "love"

    println(movieSet)
    movieSet.+=("0819")
    println(movieSet)

    /**
     * map集合,Scala 也提供了 Map 的可变 和不可变的版本，用类继承关系来区分
     * 创建，初始化并使用一个可变的映射
     */
    import scala.collection.mutable
    val tmap = mutable.Map[Int, String]()
    tmap += (1 -> "guangzhou")
    tmap += (2 -> "beijing")
    tmap += (3 -> "shenzheng")
    println(tmap(3))
    //创建一个不可变映射,无需引入，因为默认的映射就是不可变的
    val tiMap = (1 -> "hebei", 2 -> "chengde", 3 -> "shijiazhuang", 4 -> "beijing")
    println(s"tiMap = ${tiMap}")


  }

}