Queue<T> 类

public class Queue<T> : System.Collections.Generic.IEnumerable<T>, System.Collections.Generic.IReadOnlyCollection<T>, System.Collections.ICollection

[System.Runtime.InteropServices.ComVisible(false)]
[System.Serializable]
public class Queue<T> : System.Collections.Generic.IEnumerable<T>, System.Collections.ICollection

[System.Runtime.InteropServices.ComVisible(false)]
[System.Serializable]
public class Queue<T> : System.Collections.Generic.IEnumerable<T>, System.Collections.Generic.IReadOnlyCollection<T>, System.Collections.ICollection

public class Queue<T> : System.Collections.Generic.IEnumerable<T>, System.Collections.ICollection

继承

Object

Queue<T>

属性

ComVisibleAttribute SerializableAttribute

实现

IEnumerable<T> IReadOnlyCollection<T> ICollection IEnumerable

下面的代码示例演示 Queue<T> 泛型类的几种方法。 该代码示例创建具有默认容量的字符串队列，并使用 Enqueue 方法对五个字符串进行排队。 枚举队列的元素，该元素不会更改队列的状态。 Dequeue 方法用于取消对第一个字符串进行排队。 Peek 方法用于查看队列中的下一项，然后使用 Dequeue 方法将其取消排队。

ToArray 方法用于创建数组并将队列元素复制到其中，然后将该数组传递给采用 IEnumerable<T>的 Queue<T> 构造函数，从而创建队列的副本。 将显示副本的元素。

创建队列大小的两倍的数组，CopyTo 方法用于复制数组中间开始的数组元素。 Queue<T> 构造函数再次用于创建队列的第二个副本，其中包含开头的三个 null 元素。

Contains 方法用于显示字符串“四”位于队列的第一个副本中，之后 Clear 方法清除副本，Count 属性显示队列为空。

using System;
using System.Collections.Generic;

class Example
{
    public static void Main()
    {
        Queue<string> numbers = new Queue<string>();
        numbers.Enqueue("one");
        numbers.Enqueue("two");
        numbers.Enqueue("three");
        numbers.Enqueue("four");
        numbers.Enqueue("five");

        // A queue can be enumerated without disturbing its contents.
        foreach( string number in numbers )
        {
            Console.WriteLine(number);
        }

        Console.WriteLine("\nDequeuing '{0}'", numbers.Dequeue());
        Console.WriteLine("Peek at next item to dequeue: {0}",
            numbers.Peek());
        Console.WriteLine("Dequeuing '{0}'", numbers.Dequeue());

        // Create a copy of the queue, using the ToArray method and the
        // constructor that accepts an IEnumerable<T>.
        Queue<string> queueCopy = new Queue<string>(numbers.ToArray());

        Console.WriteLine("\nContents of the first copy:");
        foreach( string number in queueCopy )
        {
            Console.WriteLine(number);
        }

        // Create an array twice the size of the queue and copy the
        // elements of the queue, starting at the middle of the
        // array.
        string[] array2 = new string[numbers.Count * 2];
        numbers.CopyTo(array2, numbers.Count);

        // Create a second queue, using the constructor that accepts an
        // IEnumerable(Of T).
        Queue<string> queueCopy2 = new Queue<string>(array2);

        Console.WriteLine("\nContents of the second copy, with duplicates and nulls:");
        foreach( string number in queueCopy2 )
        {
            Console.WriteLine(number);
        }

        Console.WriteLine("\nqueueCopy.Contains(\"four\") = {0}",
            queueCopy.Contains("four"));

        Console.WriteLine("\nqueueCopy.Clear()");
        queueCopy.Clear();
        Console.WriteLine("\nqueueCopy.Count = {0}", queueCopy.Count);
    }
}

/* This code example produces the following output:

one
two
three
four
five

Dequeuing 'one'
Peek at next item to dequeue: two
Dequeuing 'two'

Contents of the first copy:
three
four
five

Contents of the second copy, with duplicates and nulls:



three
four
five

queueCopy.Contains("four") = True

queueCopy.Clear()

queueCopy.Count = 0
 */

此类将泛型队列实现为循环数组。 存储在 Queue<T> 中的对象在一端插入，并从另一端删除。 需要临时存储以获取信息时，队列和堆栈非常有用;也就是说，在检索元素值后可能要放弃该元素时。 如果需要按照存储在集合中的相同顺序访问信息，请使用 Queue<T>。 如果需要按相反顺序访问信息，请使用 Stack<T>。 如果需要同时从多个线程访问集合，请使用 ConcurrentQueue<T> 或 ConcurrentStack<T>。

可以对 Queue<T> 及其元素执行三个主要操作：

• Enqueue 向 Queue<T>末尾添加元素。

• Dequeue 从 Queue<T>开头删除最早的元素。

• Peek 速览返回位于 Queue<T> 开头但不会将其从 Queue<T>中删除的最旧元素。

Queue<T> 的容量是 Queue<T> 可以保留的元素数。 随着元素添加到 Queue<T>，重新分配内部数组，容量会根据需要自动增加。 可以通过调用 TrimExcess来减少容量。

Queue<T> 接受 null 作为引用类型的有效值，并允许重复元素。

此类型的公共静态（Shared）成员是线程安全的。 不保证任何实例成员都是线程安全的。

只要集合未修改，Queue<T> 就可以同时支持多个读取器。 即便如此，通过集合进行枚举本质上不是线程安全的过程。 有关线程安全的队列，请参阅 ConcurrentQueue<T>。