Queue<T> Costruttori

Definizione

Spazio dei nomi:

System.Collections.Generic

Assembly:

System.Collections.dll

Inizializza una nuova istanza della classe Queue<T>.

Overload

Queue<T>()	Inizializza una nuova istanza della classe Queue<T> vuota e con capacità iniziale predefinita.
Queue<T>(IEnumerable<T>)	Inizializza una nuova istanza della classe Queue<T> che contiene gli elementi copiati dalla raccolta specificata e ha la capacità sufficiente per contenere il numero di elementi copiati.
Queue<T>(Int32)	Inizializza una nuova istanza della classe Queue<T> vuota e con capacità iniziale specificata.

Esempio

Nell'esempio di codice seguente viene illustrato questo costruttore e diversi altri metodi della Queue<T> classe generica. L'esempio di codice crea una coda di stringhe con capacità predefinita e usa il Enqueue metodo per accodare cinque stringhe. Gli elementi della coda vengono enumerati, che non modificano lo stato della coda. Il Dequeue metodo viene usato per rimuovere dalla coda la prima stringa. Il Peek metodo viene usato per esaminare l'elemento successivo nella coda e quindi il metodo viene usato per annullare la Dequeue coda.

Il ToArray metodo viene usato per creare una matrice e copiarvi gli elementi della coda, quindi la matrice viene passata al Queue<T> costruttore che accetta IEnumerable<T>, creando una copia della coda. Vengono visualizzati gli elementi della copia.

Viene creata una matrice due volte le dimensioni della coda e il CopyTo metodo viene usato per copiare gli elementi della matrice a partire dal centro della matrice. Il Queue<T> costruttore viene usato di nuovo per creare una seconda copia della coda contenente tre elementi Null all'inizio.

Il Contains metodo viene usato per indicare che la stringa "quattro" si trova nella prima copia della coda, dopo la quale il Clear metodo cancella la copia e la Count proprietà indica che la coda è vuota.

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
 */

open System
open System.Collections.Generic

let numbers = Queue()
numbers.Enqueue "one"
numbers.Enqueue "two"
numbers.Enqueue "three"
numbers.Enqueue "four"
numbers.Enqueue "five"

// A queue can be enumerated without disturbing its contents.
for number in numbers do
    printfn $"{number}"

printfn $"\nDequeuing '{numbers.Dequeue()}'"
printfn $"Peek at next item to dequeue: {numbers.Peek()}"
printfn $"Dequeuing '{numbers.Dequeue()}'"

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

printfn $"\nContents of the first copy:"
for number in queueCopy do
    printfn $"{number}"

// Create an array twice the size of the queue and copy the
// elements of the queue, starting at the middle of the
// array.
let array2 = numbers.Count * 2 |> Array.zeroCreate
numbers.CopyTo(array2, numbers.Count)

// Create a second queue, using the constructor that accepts an
// IEnumerable(Of T).
let queueCopy2 = Queue array2

printfn $"\nContents of the second copy, with duplicates and nulls:"
for number in queueCopy2 do
    printfn $"{number}"
printfn $"""\nqueueCopy.Contains "four" = {queueCopy.Contains "four"}"""

printfn $"\nqueueCopy.Clear()"
queueCopy.Clear()
printfn $"queueCopy.Count = {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

Imports System.Collections.Generic

Module Example

    Sub Main

        Dim numbers As New Queue(Of 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.
        For Each number As String In numbers
            Console.WriteLine(number)
        Next

        Console.WriteLine(vbLf & "Dequeuing '{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(Of T).
        Dim queueCopy As New Queue(Of String)(numbers.ToArray())

        Console.WriteLine(vbLf & "Contents of the first copy:")
        For Each number As String In queueCopy
            Console.WriteLine(number)
        Next
        
        ' Create an array twice the size of the queue, compensating
        ' for the fact that Visual Basic allocates an extra array 
        ' element. Copy the elements of the queue, starting at the
        ' middle of the array. 
        Dim array2((numbers.Count * 2) - 1) As String
        numbers.CopyTo(array2, numbers.Count)
        
        ' Create a second queue, using the constructor that accepts an
        ' IEnumerable(Of T).
        Dim queueCopy2 As New Queue(Of String)(array2)

        Console.WriteLine(vbLf & _
            "Contents of the second copy, with duplicates and nulls:")
        For Each number As String In queueCopy2
            Console.WriteLine(number)
        Next

        Console.WriteLine(vbLf & "queueCopy.Contains(""four"") = {0}", _
            queueCopy.Contains("four"))

        Console.WriteLine(vbLf & "queueCopy.Clear()")
        queueCopy.Clear()
        Console.WriteLine(vbLf & "queueCopy.Count = {0}", _
            queueCopy.Count)
    End Sub
End Module

' 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 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>()

Origine:

Queue.cs

Inizializza una nuova istanza della classe Queue<T> vuota e con capacità iniziale predefinita.

public:
 Queue();

public Queue ();

Public Sub New ()

Commenti

La capacità di un Queue<T> oggetto è il numero di elementi che l'oggetto Queue<T> può contenere. Man mano che gli elementi vengono aggiunti a un Queue<T>oggetto , la capacità viene aumentata automaticamente in base alle esigenze tramite la riallocazione della matrice interna.

Se è possibile stimare le dimensioni della raccolta, specificando la capacità iniziale è possibile eliminare la necessità di eseguire una serie di operazioni di ridimensionamento durante l'aggiunta Queue<T>di elementi a .

La capacità può essere ridotta chiamando TrimExcess.

Questo costruttore è un'operazione O(1).

Queue<T>(IEnumerable<T>)

Origine:

Queue.cs

Inizializza una nuova istanza della classe Queue<T> che contiene gli elementi copiati dalla raccolta specificata e ha la capacità sufficiente per contenere il numero di elementi copiati.

public:
 Queue(System::Collections::Generic::IEnumerable<T> ^ collection);

public Queue (System.Collections.Generic.IEnumerable<T> collection);

new System.Collections.Generic.Queue<'T> : seq<'T> -> System.Collections.Generic.Queue<'T>

Public Sub New (collection As IEnumerable(Of T))

Parametri

collection

IEnumerable<T>

Raccolta i cui elementi sono copiati nel nuovo oggetto Queue<T>.

Eccezioni

ArgumentNullException

collection è null.

Commenti

La capacità di un Queue<T> oggetto è il numero di elementi che l'oggetto Queue<T> può contenere. Man mano che gli elementi vengono aggiunti a un Queue<T>oggetto , la capacità viene aumentata automaticamente in base alle esigenze tramite la riallocazione della matrice interna.

Se è possibile stimare le dimensioni della raccolta, specificando la capacità iniziale è possibile eliminare la necessità di eseguire una serie di operazioni di ridimensionamento durante l'aggiunta Queue<T>di elementi a .

La capacità può essere ridotta chiamando TrimExcess.

Gli elementi vengono copiati nell'oggetto Queue<T> nello stesso ordine in cui vengono letti dall'oggetto IEnumerator<T> della raccolta.

Questo costruttore è un'operazione O(n), dove n è il numero di elementi in collection.

Queue<T>(Int32)

Origine:

Queue.cs

Inizializza una nuova istanza della classe Queue<T> vuota e con capacità iniziale specificata.

public:
 Queue(int capacity);

public Queue (int capacity);

new System.Collections.Generic.Queue<'T> : int -> System.Collections.Generic.Queue<'T>

Public Sub New (capacity As Integer)

Parametri

capacity

Int32

Numero iniziale degli elementi che Queue<T> può contenere.

Eccezioni

ArgumentOutOfRangeException

capacity è minore di zero.

Commenti

La capacità di un Queue<T> oggetto è il numero di elementi che l'oggetto Queue<T> può contenere. Man mano che gli elementi vengono aggiunti a un Queue<T>oggetto , la capacità viene aumentata automaticamente in base alle esigenze tramite la riallocazione della matrice interna.

Se è possibile stimare le dimensioni della raccolta, specificando la capacità iniziale è possibile eliminare la necessità di eseguire una serie di operazioni di ridimensionamento durante l'aggiunta Queue<T>di elementi a .

La capacità può essere ridotta chiamando TrimExcess.

Questo costruttore è un'operazione O(n), dove n è capacity.