编程

Scala常用数据结构

2025年3月11日 作者 unix2go

Scala 提供了丰富的数据结构支持，主要分为 不可变集合（Immutable Collections） 和 可变集合（Mutable Collections）。不可变集合是默认的设计选择，因为它们线程安全且更易于维护代码。以下是 Scala 中常用的数据结构及其特点、使用场景和示例。

1. 序列（Sequences）

1.1 List

  • 不可变链表（immutable linked list）。
  • 常用于需要频繁在头部追加元素的场景。
  • 特点：
    • 高效的头部操作（O(1)）。
    • 适合递归操作。
    • 随机访问性能较差（O(n)）。
val list = List(1, 2, 3)
val newList = 0 :: list // 在头部添加元素
println(newList) // List(0, 1, 2, 3)

1.2 Vector

  • 不可变序列，基于树状分块数组。
  • 常用于需要高效随机访问和尾部操作的场景。
  • 特点：
    • 随机访问时间复杂度为 O(log32(n))。
    • 比 List 更适合大规模数据处理。
val vector = Vector(1, 2, 3)
val updatedVector = vector :+ 4 // 在尾部添加元素
println(updatedVector) // Vector(1, 2, 3, 4)

1.3 Array

  • 可变数组，底层是 Java 的数组。
  • 常用于需要高性能、固定大小的集合。
  • 特点：
    • 支持随机访问，时间复杂度为 O(1)。
    • 元素可以被修改。
val array = Array(1, 2, 3)
array(0) = 10 // 修改元素
println(array.mkString(", ")) // 10, 2, 3

1.4 Range

  • 表示一个范围的序列，通常用于迭代。
  • 特点：
    • 高效生成范围序列。
    • 不占用额外内存。
val range = 1 to 10
println(range) // Range(1, 2, 3, ..., 10)

2. 集合（Sets）

2.1 Set

  • 无序集合，默认是 不可变集合。
  • 特点：
    • 不允许重复元素。
    • 提供高效的元素查找（基于哈希表）。
val set = Set(1, 2, 3, 3) // 不允许重复
println(set) // Set(1, 2, 3)

val newSet = set + 4 // 添加元素
println(newSet) // Set(1, 2, 3, 4)

2.2 Mutable Set

  • 可变版本的 Set。
  • 特点：
    • 允许直接修改集合。
import scala.collection.mutable

val mutableSet = mutable.Set(1, 2, 3)
mutableSet += 4 // 添加元素
println(mutableSet) // Set(1, 2, 3, 4)

3. 映射（Maps）

3.1 Map

  • 键值对集合，默认是 不可变集合。
  • 特点：
    • 键是唯一的。
    • 提供高效的键值映射查找。
val map = Map("a" -> 1, "b" -> 2)
println(map("a")) // 1

val newMap = map + ("c" -> 3) // 添加键值对
println(newMap) // Map(a -> 1, b -> 2, c -> 3)

3.2 Mutable Map

  • 可变版本的 Map。
  • 特点：
    • 允许直接修改键值对。
import scala.collection.mutable

val mutableMap = mutable.Map("a" -> 1, "b" -> 2)
mutableMap += ("c" -> 3) // 添加键值对
println(mutableMap) // Map(a -> 1, b -> 2, c -> 3)

4. 队列（Queues）

4.1 Queue

  • 不可变队列。
  • 特点：
    • 先进先出（FIFO）结构。
    • 适合需要按顺序处理元素的场景。
import scala.collection.immutable.Queue

val queue = Queue(1, 2, 3)
val (dequeued, newQueue) = queue.dequeue // 移除第一个元素
println(dequeued) // 1
println(newQueue) // Queue(2, 3)

4.2 Mutable Queue

  • 可变版本的 Queue。
  • 特点：
    • 允许直接修改队列。
import scala.collection.mutable

val mutableQueue = mutable.Queue(1, 2, 3)
mutableQueue.enqueue(4) // 添加元素
println(mutableQueue) // Queue(1, 2, 3, 4)

mutableQueue.dequeue() // 移除第一个元素
println(mutableQueue) // Queue(2, 3, 4)

5. 栈（Stacks）

5.1 Stack

  • 可变栈。
  • 特点：
    • 后进先出（LIFO）结构。
    • 常用于递归或需要回溯的场景。
import scala.collection.mutable

val stack = mutable.Stack(1, 2, 3)
stack.push(4) // 压栈
println(stack) // Stack(4, 1, 2, 3)

stack.pop() // 出栈
println(stack) // Stack(1, 2, 3)

6. 流（Streams）

  • 惰性集合，类似于 List，但元素是按需计算的。
  • 适合处理无限序列或延迟计算场景。
val stream = Stream.from(1) // 从 1 开始的无限序列
println(stream.take(5).toList) // List(1, 2, 3, 4, 5)

7. 元组（Tuples）

  • 用于存储固定数量的不同类型的元素。
  • 特点：
    • 元素可以是不同类型。
    • 常用于函数返回多个值的场景。
val tuple = (1, "hello", true)
println(tuple._1) // 1
println(tuple._2) // hello
println(tuple._3) // true

8. Option

  • 用于表示可能存在或不存在的值，避免 null。
  • 特点：
    • Some(value) 表示存在值。
    • None 表示没有值。
val maybeValue: Option[Int] = Some(42)
println(maybeValue.getOrElse(0)) // 42

val noValue: Option[Int] = None
println(noValue.getOrElse(0)) // 0

总结

根据具体需求选择适合的 Scala 数据结构，可以大幅提高代码的性能和可维护性！

Print Friendly, PDF & Email