SCALA 集合框架文档翻译-Concrete Mutable Collection Classes

最新推荐文章于 2023-06-27 22:54:09 发布

libing_thinking

最新推荐文章于 2023-06-27 22:54:09 发布

阅读量743

点赞数

分类专栏： SCALA

SCALA 专栏收录该内容

16 篇文章 0 订阅

订阅专栏

具体可变集合类

英文原文：http://docs.scala-lang.org/overviews/collections/concrete-mutable-collection-classes.html

上一章已经介绍了 Scala 标准库中最常使用的不可变具体集合类。本文将对具体可变集合类进行说明。

Array Buffers

ArrayBuffer 中保存了一个数组和一个集合大小值。因为对 ArrayBuffer 的操作只是简单的操作其底层所基于的数组，所以操作速度等同于数组。另外，ArrayBuffer 能高效的将元素添加到其尾部。添加一个元素到 ArrayBuffer 尾部平均耗费常数时间。因此，当新元素总是添加到 ArrayBuffer 尾部时，ArrayBuffer 能非常高效的构建一个大集合。

scala> val buf = scala.collection.mutable.ArrayBuffer.empty[Int]
buf: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer()
scala> buf += 1
res32: buf.type = ArrayBuffer(1)
scala> buf += 10
res33: buf.type = ArrayBuffer(1, 10)
scala> buf.toArray
res34: Array[Int] = Array(1, 10)

List Buffers

ListBuffer 与 ArrayBuffer 类似，只是内部使用一个链表实现。如果打算在 Buffer 构建好之后转化为一个 List，那么建议使用 ListBuffer 而不是 ArrayBuffer。

scala> val buf = scala.collection.mutable.ListBuffer.empty[Int]
buf: scala.collection.mutable.ListBuffer[Int] = ListBuffer()
scala> buf += 1
res35: buf.type = ListBuffer(1)
scala> buf += 10
res36: buf.type = ListBuffer(1, 10)
scala>buf.toList
res37: List[Int] = List(1, 10)

StringBuilders

就像 ArrayBuffer 用于构建 Array、ListBuffer 用于构建 List 一样，StringBuilder 则被用来构建 String。由于 StringBuild 用的很频繁，所以它已经被导入到了默认命名空间。创建一个 StringBuilder 只需要简单的 new StringBuilder 即可：

scala> val buf = new StringBuilder
buf: StringBuilder =
scala> buf += 'a'
res38: buf.type = a
scala> buf ++= "bcdef"
res39: buf.type = abcdef
scala> buf.toString
res41: String = abcdef

Linked Lists

链表是一个可变序列，其中包含的所有节点都由后继指针串联起来。他们可以通过 LinkedList 得到支持。在很多编程语言中，空链表使用 null 表示。在 scala 集合框架中，这个惯例不成立，这是由于即使是空序列也必须支持所有的序列方法。特别的，LinkedList.empty.isEmpty 应该返回 true 而不是一个 NullPointerException 空指针异常。空 LinkedLIst 将以特殊的方式编码：他们的 next 指针字段执行它自己。就像其他不可变链表类一样，遍历 LinkedList 时最好顺序遍历。除此之外，在 LinkedList 中插入一个元素或者另一个 LinkedList 将变得很容易。

Double Linked Lists

双链表与单链表类似，只是它的节点中多了一个指向它的前驱节点的可变指针字段。这个附加链接的主要好处是它使得元素删除更加快速。双链表由类 DoubeLinkedList 支持。

Mutable Lists

MutableList 包含一个单链表以及一个指向该链表结尾空节点的指针。由于指向尾节点的指针避免了遍历链表去寻找尾节点，所以现在向链表结尾添加新元素只需要常数时间复杂度。MutableList 现在是 Scala 标准库中 mutable.LinearSeq 的标准实现。

除了不可变队列外，Scala 还提供了可变队列。可变队列的使用与不可变队列类似，但对于 enqueue 入队操作，可以使用 += 和 ++= 操作进行替代。还有，在可变队列上的 dequeue 操作将只会移除队列的头部元素并返回该元素。下面是一个例子：

scala> val queue = new scala.collection.mutable.Queue[String]
queue: scala.collection.mutable.Queue[String] = Queue()
scala> queue += "a"
res10: queue.type = Queue(a)
scala> queue ++= List("b", "c")
res11: queue.type = Queue(a, b, c)
scala>  queue
res12: scala.collection.mutable.Queue[String] = Queue(a, b, c)
scala> queue.dequeue
res13: String = a
scala> queue
res14: scala.collection.mutable.Queue[String] = Queue(b, c)

Array Sequences

数组序列是一个固定长度可变序列，其内部实现将元素存储于一个 Array[Object] 数组中。在 Scala 中，它由类 ArraySeq 实现。

当你需要利用数组的高效特征，又想创建序列的通用实例，同时由于不知道元素类型并且在运行时也没有一个 ClassManifest 可以提供元素类型，这时候一般会选择使用 ArraySeq。这些问题将在数组章节介绍。

stacks

上一章节已经介绍了不可变 Stack。Stack 也有一个可变的版本，具体是由类 mutable.Stack 实现。除了它的修改都是在本身进行外，它的工作机制与不可变 Stack 相同。

scala> val stack = new scala.collection.mutable.Stack[Int]
stack: scala.collection.mutable.Stack[Int] = Stack()
scala> stack.push(1)
res0: stack.type = Stack(1)
scala> stack
res1: scala.collection.mutable.Stack[Int] = Stack(1)
scala> stack.push(2)
res2: stack.type = Stack(1, 2)
scala> stack
res3: scala.collection.mutable.Stack[Int] = Stack(1, 2)
scala> stack.pop
res10: Int = 2
scala> stack
res11: scala.collection.mutable.Stack[Int] = Stack(1)

Array Stacks

ArrayStack 是可变 Stack 的另一种实现，它后端是基于一个按需改变大小的数组。它能提供快速的索引，并且对于大多数操作来说它的效率比可变 Stack 高。

Hash Tables

哈希表内部将它的元素存储在一个数组中，每个元素按照元素哈希值放置在数组的不同位置上。只要其内部数组上还没有其他元素具体相同的哈希值，那么向哈希表中添加一个元素只需耗费常数时间。因此，只要哈希表中元素的哈希值的分布良好，那么哈希表将非常快。所以，可变 Map 和 Set 的默认实现都是基于哈希表。可以直接使用 mutable.HashSet 和 mutable.HashMap 访问其具体类。

HashSet 和 HashMap 的使用就像其他 Set 和 Map 类。这里有一些简单的例子：
scala> val map = scala.collection.mutable.HashMap.empty[Int, String]
map: scala.collection.mutable.HashMap[Int, String] = Map()
scala> map += (1 -> "make a web site")
res42: map.type = Map(1 -> make a web site)
scala> map += (3 -> "profit!")
res43: map.type = Map(1 -> make a web site, 3 -> profit)
scala> map(1)
res44: String = make a web site
scala> map contains 2
res45: Boolean = false

在哈希表上迭代不能保证按照特定的顺序。迭代只是简单的在其内部数组上按不确定的顺序进行。如果需要一个有序的迭代，可以使用链式版本的 Map 或者 Set。一个链式版本的 Map 或者 Set 跟通常版本的 Map 或者 Set 类似，只不过它还包含一个按元素添加顺序链接起来的链表。在链式版本的集合上进行迭代总是能按照元素添加的初始顺序进行。

Weak Hash Maps

一个弱哈希表是一种特殊类型的哈希表，垃圾收集器会忽略从 Map 到其中键值的引用。这意味着一个键在没有其他引用指向它时，对应的键值对会从 Map 中消失。弱哈希表对缓存这类任务非常有用，比如说可以在某计算密集型函数调用时缓存其参数列表到计算结果的键值对，后面有相同参数列表调用时直接返回计算结果。这种情况下，如果存储到普通哈希表中，则哈希表将会无边界增长，表中的任何键都不会被回收。使用弱哈希表避免了这个问题。只要键变得不可达，那么该键对应的项就会从弱哈希表中移除。在 Scala 中弱哈希表是由 WeakHashMap 类实现的，它是对底层 Java 类 java.util.WeakHashMap 进行了包裹封装。

Concurrent Maps

一个并发 Map 可以同时被几个线程访问。除了通常的 Map 类的操作，它还提供了下列原子操作：

Operations in class ConcurrentMap

方法	作用
----	-----
m putIfAbsent(k, v)	如果键 k 不存在，则添加键值对 k -> m 到表中
m remove (k, v)	如果键 k 映射到值 v，则从表中移除键 k 对应项
m replace (k, old, new)	如果键 k 原来映射到值 old，则修改其映射指向值 new
m replace (k, v)	如果键 k 原来映射到某个值，则修改其映射指向值 v

ConcurrentMap 是 scala 集合框架中的一个特质。当前，它的唯一实现类是 Java 库中的 java.util.concurrent.ConcurrentMap，这个类可以使用标准 Java/Scala 集合类转化规则自动转化为一个 Scala 中的 Map 类。

Mutable Bitsets

可变版本的位图 mutable.BitSet 与不可变版本的类似，只不过它的操作都是原地修改集合本身。可变版本的位图比不可变版本的位图在更新操作上会稍有效率提高，因为他们不会拷贝没有改变的长整型元素。

scala> val bits = scala.collection.mutable.BitSet.empty
bits: scala.collection.mutable.BitSet = BitSet()
scala> bits += 1
res49: bits.type = BitSet(1)
scala> bits += 3
res50: bits.type = BitSet(1, 3)
scala> bits
res51: scala.collection.mutable.BitSet = BitSet(1, 3)