Scala Queue +=:() 方法

Scala中的Queue是一种常见的数据结构，它是一个先进先出（FIFO）的集合。Scala Queue类中有许多方法可以用于操作队列，其中一个唯一的方法是+=:()。

1.+=:() 方法介绍

+=:()方法用于将元素添加到队列的前面。它需要一个参数，该参数是要添加的元素。该方法返回一个队列，该队列与原队列相同，只是多了一个新元素。这个方法的符号表示为“+=:”。

以下是一个使用+=:()方法来添加元素到队列的示例：

import scala.collection.mutable.Queue

val queue = Queue(1, 2, 3)
val newQueue = 0 +=: queue

println(queue) // Queue(1, 2, 3)
println(newQueue) // Queue(0, 1, 2, 3)

在这个例子中，我们创建了一个Queue对象，其中包含3个整数1，2，和3。我们然后使用+=:()方法将0添加到Queue的前面。我们创建了一个名为newQueue的新队列变量，该变量是添加新元素后的原队列。我们打印出原队列和新队列来验证新元素是否被成功添加到队列的前面。

我们还可以使用+=:()方法来添加元素到空队列中：

import scala.collection.mutable.Queue

val emptyQueue = Queue.empty[Int]
val newQueue = 0 +=: emptyQueue

println(emptyQueue) // Queue()
println(newQueue) // Queue(0)

在这个例子中，我们创建了一个空的Queue对象，然后使用+=:()添加了一个新元素0。我们打印出原队列和新队列来验证新元素是否被成功添加到队列的前面。

2.+=:() 方法源码

“+=:”的信息需要被提示出来，因此我们需要将Scala源码的一部分插入到markdown中。以下是+=:()的Scala源代码：

def +=:(elem: A): this.type = {
  elems.prependToList(elem)
  this
}

该方法采用一个参数，一个类型参数为A的元素，然后将其添加到Queue的头部。该方法将“this”返回给调用者。

“prependToList”方法将元素插入到列表的头部。如果列表为空，则创建包含一个元素的“QueueNode”对象。否则，将元素插入“QueueNode”的头部。

/** A class representing an element of the linked list forming the basis
 *  of a queue internally.
 *  INTERNAL API.
 */
private[mutable] final class QueueNode[A](private[this] var _elem: A) {
  private[this] var _next: QueueNode[A] = _
  def elem = _elem
  def next = _next
  def next_=(x: QueueNode[A]) = _next = x
  def elem_=(x: A) = _elem = x
}

/** A linked list based mutable queue.
 *  This class provides constant time enqueue and dequeue operations.
 *
 *  Type paramters:
 *    - A the type of the elements contained in this queue.
 *
 *  @author  Martin Odersky
 *  @version 2.8
 *  @since   1
 *
 *  @define Coll Queue
 *  @define coll queue
 *  @define thatinfo the class of the returned collection. In the standard library configuration,
 *    `That` is always `Queue[U]` because an implicit of type `CanBuildFrom[Queue, U, Queue[U]]`
 *    is defined in object `Queue`.
 *  @define CannotRemoveUndefinedElement
 */
final class Queue[A] private (private[this] var first: QueueNode[A], private[this] var last0:QueueNode[A])
  extends AbstractIterable[A]
    with scala.collection.mutable.Queue[A]
    with scala.collection.Iterable[A]
    with scala.collection.generic.GenericTraversableTemplate[A, Queue]
    with scala.collection.LinearSeqOptimized[A, Queue[A]]
    with Serializable {

  override def companion: GenericCompanion[Queue] = Queue

  @deprecated("Use `isEmpty` instead of `empty`", "2.11.0")
  def empty: Boolean = isEmpty

  def this() = this(null, null)   // deferred - let first, last be nulls

  /** Returns the first element in the queue, and removes this element
   *  from the queue.
   *
   *  @return the first element of the queue.
   *  @throws java.util.NoSuchElementException if the queue is empty.
   */
  def dequeue(): A =
    if (isEmpty) throw new NoSuchElementException("queue empty")
    else {
      val res = first.elem
      first = first.next
      if (first eq null) last0 = null
      res
    }

  /** Returns the first element in the queue which satisfies the
   *  given predicate, and removes this element from the queue.
   *
   *  @param  p   the predicate used for choosing the first element
   *  @return the first element of the queue for which p yields true
   *  @throws java.util.NoSuchElementException if no element exists such that
   *          p yields true
   */
  def dequeueFirst(p: A => Boolean): A = {
    if (isEmpty) throw new NoSuchElementException("queue empty")
    else {
      var cur = first
      if (p(cur.elem)) {
        first = first.next
        if (first eq null) last0 = null
        cur.elem
      }
      else {
        while ((cur.next ne null) && !p(cur.next.elem))
          cur = cur.next
        if (cur.next eq null)
          throw new NoSuchElementException("queue empty")
        val res = cur.next.elem
        if (cur.next eq last0) last0 = cur
        cur.next = cur.next.next
        res
      }
    }
  }
  ...
  /** Returns a regular scala.collection.immutable.Queue containing
   *  the same elements.
   */
  def to[Col[_]](implicit cbf: CanBuildFrom[Nothing, A, Col[A]]): Col[A] = this.iterator.to(cbf)

}

总结

Scala Queue +=:()方法是一种添加元素到Queue前面的方法。它将一个元素添加到一个已有的队列的前面。这个方法是Queue类中的唯一的方法。该方法返回一个队列，该队列与原来的Queue相同，只是多了一个新元素。使用+=:()方法，我们可以创建一个空的Queue对象，并将元素添加到队列中。

参考

• Scala Documentation - mutable Queue