Queue<T> Constructors
Definitie
Belangrijk
Bepaalde informatie heeft betrekking op een voorlopige productversie die aanzienlijk kan worden gewijzigd voordat deze wordt uitgebracht. Microsoft biedt geen enkele expliciete of impliciete garanties met betrekking tot de informatie die hier wordt verstrekt.
Initialiseert een nieuw exemplaar van de Queue<T> klasse.
Overloads
| Name | Description |
|---|---|
| Queue<T>() |
Initialiseert een nieuw exemplaar van de Queue<T> klasse die leeg is en heeft de standaardinitiële capaciteit. |
| Queue<T>(IEnumerable<T>) |
Initialiseert een nieuw exemplaar van de Queue<T> klasse die elementen bevat die zijn gekopieerd uit de opgegeven verzameling en heeft voldoende capaciteit voor het aantal gekopieerde elementen. |
| Queue<T>(Int32) |
Initialiseert een nieuw exemplaar van de Queue<T> klasse die leeg is en heeft de opgegeven initiële capaciteit. |
Voorbeelden
In het volgende codevoorbeeld ziet u deze constructor en verschillende andere methoden van de Queue<T> algemene klasse. In het codevoorbeeld wordt een wachtrij met tekenreeksen met standaardcapaciteit gemaakt en wordt de methode gebruikt om vijf tekenreeksen in de Enqueue wachtrij te plaatsen. De elementen van de wachtrij worden opgesomd, waardoor de status van de wachtrij niet wordt gewijzigd. De Dequeue methode wordt gebruikt om de eerste tekenreeks uit de wachtrij te verwijderen. De Peek methode wordt gebruikt om het volgende item in de wachtrij te bekijken en vervolgens wordt de Dequeue methode gebruikt om het uit de wachtrij te verwijderen.
De ToArray methode wordt gebruikt om een matrix te maken en de wachtrijelementen naar de matrix te kopiëren. Vervolgens wordt de matrix doorgegeven aan de Queue<T> constructor die nodig IEnumerable<T>is om een kopie van de wachtrij te maken. De elementen van de kopie worden weergegeven.
Er wordt een matrix twee keer zo groot als de wachtrij gemaakt en de CopyTo methode wordt gebruikt om de matrixelementen te kopiëren vanaf het midden van de matrix. De Queue<T> constructor wordt opnieuw gebruikt om een tweede kopie van de wachtrij te maken die drie null-elementen aan het begin bevat.
De Contains methode wordt gebruikt om aan te geven dat de tekenreeks 'vier' zich in de eerste kopie van de wachtrij bevindt, waarna de methode de Clear kopie wist en de Count eigenschap laat zien dat de wachtrij leeg is.
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>()
Initialiseert een nieuw exemplaar van de Queue<T> klasse die leeg is en heeft de standaardinitiële capaciteit.
public:
Queue();public Queue();Public Sub New ()Opmerkingen
De capaciteit van een Queue<T> is het aantal elementen dat de Queue<T> kan bevatten. Als er elementen aan een Queue<T>worden toegevoegd, wordt de capaciteit automatisch verhoogd zoals vereist door de interne matrix opnieuw te verplaatsen.
Als de grootte van de verzameling kan worden geschat, hoeft u bij het opgeven van de initiële capaciteit niet meer een aantal groottebewerkingen uit te voeren terwijl er elementen aan de Queue<T>verzameling worden toegevoegd.
De capaciteit kan worden verminderd door aan te roepen TrimExcess.
Deze constructor is een O(1)-bewerking.
Van toepassing op
Queue<T>(IEnumerable<T>)
Initialiseert een nieuw exemplaar van de Queue<T> klasse die elementen bevat die zijn gekopieerd uit de opgegeven verzameling en heeft voldoende capaciteit voor het aantal gekopieerde elementen.
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))Parameters
- collection
- IEnumerable<T>
De verzameling waarvan de elementen naar de nieuwe Queue<T>worden gekopieerd.
Uitzonderingen
collection is null.
Opmerkingen
De capaciteit van een Queue<T> is het aantal elementen dat de Queue<T> kan bevatten. Als er elementen aan een Queue<T>worden toegevoegd, wordt de capaciteit automatisch verhoogd zoals vereist door de interne matrix opnieuw te verplaatsen.
Als de grootte van de verzameling kan worden geschat, hoeft u bij het opgeven van de initiële capaciteit niet meer een aantal groottebewerkingen uit te voeren terwijl er elementen aan de Queue<T>verzameling worden toegevoegd.
De capaciteit kan worden verminderd door aan te roepen TrimExcess.
De elementen worden in Queue<T> dezelfde volgorde gekopieerd als de elementen worden gelezen door de IEnumerator<T> verzameling.
Deze constructor is een O(n)-bewerking, waarbij n het aantal elementen in collection.
Van toepassing op
Queue<T>(Int32)
Initialiseert een nieuw exemplaar van de Queue<T> klasse die leeg is en heeft de opgegeven initiële capaciteit.
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)Parameters
Uitzonderingen
capacity is kleiner dan nul.
Opmerkingen
De capaciteit van een Queue<T> is het aantal elementen dat de Queue<T> kan bevatten. Als er elementen aan een Queue<T>worden toegevoegd, wordt de capaciteit automatisch verhoogd zoals vereist door de interne matrix opnieuw te verplaatsen.
Als de grootte van de verzameling kan worden geschat, hoeft u bij het opgeven van de initiële capaciteit niet meer een aantal groottebewerkingen uit te voeren terwijl er elementen aan de Queue<T>verzameling worden toegevoegd.
De capaciteit kan worden verminderd door aan te roepen TrimExcess.
Deze constructor is een O(n)-bewerking, waarbij n .capacity
Caution
Als capacity afkomstig is van gebruikersinvoer, geeft u de voorkeur aan het gebruik van de constructor zonder parameters en kunt u de grootte van de verzameling wijzigen als elementen worden toegevoegd. Als u een door de gebruiker opgegeven waarde moet gebruiken, kunt u deze vastzetten op een redelijke limiet (bijvoorbeeld Math.Clamp(untrustedValue, 0, 20)) of controleren of het aantal elementen overeenkomt met de opgegeven waarde.