Stack<T> Classe

Definizione

Rappresenta una raccolta di istanze LIFO (Last-In-First-Out) a dimensione variabile dello stesso tipo specificato.Represents a variable size last-in-first-out (LIFO) collection of instances of the same specified type.

generic <typename T>
public ref class Stack : System::Collections::Generic::IEnumerable<T>, System::Collections::Generic::IReadOnlyCollection<T>, System::Collections::ICollection
[System.Runtime.InteropServices.ComVisible(false)]
[System.Serializable]
public class Stack<T> : System.Collections.Generic.IEnumerable<T>, System.Collections.Generic.IReadOnlyCollection<T>, System.Collections.ICollection
type Stack<'T> = class
    interface seq<'T>
    interface ICollection
    interface IReadOnlyCollection<'T>
    interface IEnumerable
Public Class Stack(Of T)
Implements ICollection, IEnumerable(Of T), IReadOnlyCollection(Of T)

Parametri di tipo

T

Specifica il tipo di elementi nello stack.Specifies the type of elements in the stack.

Ereditarietà
Stack<T>
Attributi
Implementazioni

Esempi

Nell'esempio di codice seguente vengono illustrati diversi Stack<T> metodi della classe generica.The following code example demonstrates several methods of the Stack<T> generic class. Nell'esempio di codice viene creato uno stack di stringhe con la capacità predefinita Push e viene utilizzato il metodo per effettuare il push di cinque stringhe nello stack.The code example creates a stack of strings with default capacity and uses the Push method to push five strings onto the stack. Gli elementi dello stack vengono enumerati, che non modifica lo stato dello stack.The elements of the stack are enumerated, which does not change the state of the stack. Il Pop metodo viene utilizzato per estrarre la prima stringa dallo stack.The Pop method is used to pop the first string off the stack. Il Peek metodo viene usato per esaminare l'elemento successivo nello stack, quindi il Pop metodo viene usato per estrarlo.The Peek method is used to look at the next item on the stack, and then the Pop method is used to pop it off.

Il ToArray metodo viene usato per creare una matrice e copiarvi gli elementi dello stack, quindi la matrice viene passata Stack<T> al costruttore che accetta IEnumerable<T>, creando una copia dello stack con l'ordine degli elementi invertiti.The ToArray method is used to create an array and copy the stack elements to it, then the array is passed to the Stack<T> constructor that takes IEnumerable<T>, creating a copy of the stack with the order of the elements reversed. Vengono visualizzati gli elementi della copia.The elements of the copy are displayed.

Viene creata una matrice per due volte la dimensione dello stack e il CopyTo metodo viene usato per copiare gli elementi della matrice a partire dal centro della matrice.An array twice the size of the stack is created, and the CopyTo method is used to copy the array elements beginning at the middle of the array. Il Stack<T> costruttore viene nuovamente utilizzato per creare una copia dello stack con l'ordine degli elementi invertiti; pertanto, i tre elementi null si trovano alla fine.The Stack<T> constructor is used again to create a copy of the stack with the order of elements reversed; thus, the three null elements are at the end.

Il Contains metodo viene utilizzato per indicare che la stringa "quattro" si trova nella prima copia dello stack, dopo la quale il Clear metodo cancella la copia e la Count proprietà indica che lo stack è vuoto.The Contains method is used to show that the string "four" is in the first copy of the stack, after which the Clear method clears the copy and the Count property shows that the stack is empty.

using System;
using System.Collections.Generic;

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

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

        Console.WriteLine("\nPopping '{0}'", numbers.Pop());
        Console.WriteLine("Peek at next item to destack: {0}", 
            numbers.Peek());
        Console.WriteLine("Popping '{0}'", numbers.Pop());

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

        Console.WriteLine("\nContents of the first copy:");
        foreach( string number in stack2 )
        {
            Console.WriteLine(number);
        }
        
        // Create an array twice the size of the stack and copy the
        // elements of the stack, starting at the middle of the 
        // array. 
        string[] array2 = new string[numbers.Count * 2];
        numbers.CopyTo(array2, numbers.Count);
        
        // Create a second stack, using the constructor that accepts an
        // IEnumerable(Of T).
        Stack<string> stack3 = new Stack<string>(array2);

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

        Console.WriteLine("\nstack2.Contains(\"four\") = {0}", 
            stack2.Contains("four"));

        Console.WriteLine("\nstack2.Clear()");
        stack2.Clear();
        Console.WriteLine("\nstack2.Count = {0}", stack2.Count);
    }
}

/* This code example produces the following output:

five
four
three
two
one

Popping 'five'
Peek at next item to destack: four
Popping 'four'

Contents of the first copy:
one
two
three

Contents of the second copy, with duplicates and nulls:
one
two
three




stack2.Contains("four") = False

stack2.Clear()

stack2.Count = 0
 */
Imports System.Collections.Generic

Module Example

    Sub Main

        Dim numbers As New Stack(Of String)
        numbers.Push("one")
        numbers.Push("two")
        numbers.Push("three")
        numbers.Push("four")
        numbers.Push("five")

        ' A stack can be enumerated without disturbing its contents.
        For Each number As String In numbers
            Console.WriteLine(number)
        Next

        Console.WriteLine(vbLf & "Popping '{0}'", numbers.Pop())
        Console.WriteLine("Peek at next item to pop: {0}", _
            numbers.Peek())    
        Console.WriteLine("Popping '{0}'", numbers.Pop())

        ' Create another stack, using the ToArray method and the
        ' constructor that accepts an IEnumerable(Of T). Note that
        ' the order of items on the new stack is reversed.
        Dim stack2 As New Stack(Of String)(numbers.ToArray())

        Console.WriteLine(vbLf & "Contents of the first copy:")
        For Each number As String In stack2
            Console.WriteLine(number)
        Next
        
        ' Create an array twice the size of the stack, compensating
        ' for the fact that Visual Basic allocates an extra array 
        ' element. Copy the elements of the stack, starting at the
        ' middle of the array. 
        Dim array2((numbers.Count * 2) - 1) As String
        numbers.CopyTo(array2, numbers.Count)
        
        ' Create a second stack, using the constructor that accepts an
        ' IEnumerable(Of T). The elements are reversed, with the null
        ' elements appearing at the end of the stack when enumerated.
        Dim stack3 As New Stack(Of String)(array2)

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

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

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

' This code example produces the following output:
'
'five
'four
'three
'two
'one
'
'Popping 'five'
'Peek at next item to pop: four
'Popping 'four'
'
'Contents of the first copy:
'one
'two
'three
'
'Contents of the second copy, with duplicates and nulls:
'one
'two
'three
'
'
'
'
'stack2.Contains("four") = False
'
'stack2.Clear()
'
'stack2.Count = 0

Commenti

Stack<T>viene implementato come matrice.Stack<T> is implemented as an array.

Gli stack e le code sono utili quando è necessaria l'archiviazione temporanea per informazioni. ovvero, quando potrebbe essere necessario rimuovere un elemento dopo il recupero del relativo valore.Stacks and queues are useful when you need temporary storage for information; that is, when you might want to discard an element after retrieving its value. Usare Queue<T> se è necessario accedere alle informazioni nello stesso ordine in cui sono archiviate nella raccolta.Use Queue<T> if you need to access the information in the same order that it is stored in the collection. Usare System.Collections.Generic.Stack<T> se è necessario accedere alle informazioni in ordine inverso.Use System.Collections.Generic.Stack<T> if you need to access the information in reverse order.

Usare i System.Collections.Concurrent.ConcurrentStack<T> tipi System.Collections.Concurrent.ConcurrentQueue<T> e quando è necessario accedere alla raccolta da più thread contemporaneamente.Use the System.Collections.Concurrent.ConcurrentStack<T> and System.Collections.Concurrent.ConcurrentQueue<T> types when you need to access the collection from multiple threads concurrently.

Un uso comune di System.Collections.Generic.Stack<T> consiste nel mantenere gli Stati delle variabili durante le chiamate ad altre routine.A common use for System.Collections.Generic.Stack<T> is to preserve variable states during calls to other procedures.

È possibile eseguire tre operazioni principali su un System.Collections.Generic.Stack<T> oggetto e sui relativi elementi:Three main operations can be performed on a System.Collections.Generic.Stack<T> and its elements:

  • Pushinserisce un elemento all'inizio dell'oggetto Stack.Push inserts an element at the top of the Stack.

  • PopRimuove un elemento dall'inizio dell'oggetto Stack<T>.Pop removes an element from the top of the Stack<T>.

  • PeekRestituisce un elemento che si trova all'inizio dell'oggetto Stack<T> , ma non lo rimuove Stack<T>da.Peek returns an element that is at the top of the Stack<T> but does not remove it from the Stack<T>.

La capacità di un Stack<T> oggetto è il numero di Stack<T> elementi che può essere in attesa.The capacity of a Stack<T> is the number of elements the Stack<T> can hold. Quando gli elementi vengono aggiunti a Stack<T>un oggetto, la capacità viene aumentata automaticamente in base alle esigenze riallocando la matrice interna.As elements are added to a Stack<T>, the capacity is automatically increased as required by reallocating the internal array. La capacità può essere ridotta TrimExcesschiamando.The capacity can be decreased by calling TrimExcess.

Se Count è minore della capacità dello stack, Push è un'operazione O (1).If Count is less than the capacity of the stack, Push is an O(1) operation. Se la capacità deve essere aumentata per adattarsi al Push nuovo elemento, diventa un'operazione O (n), dove n è Count.If the capacity needs to be increased to accommodate the new element, Push becomes an O(n) operation, where n is Count. Popè un'operazione O (1).Pop is an O(1) operation.

Stack<T>accetta null come valore valido per i tipi di riferimento e consente elementi duplicati.Stack<T> accepts null as a valid value for reference types and allows duplicate elements.

Costruttori

Stack<T>()

Inizializza una nuova istanza della classe Stack<T> vuota e con capacità iniziale predefinita.Initializes a new instance of the Stack<T> class that is empty and has the default initial capacity.

Stack<T>(IEnumerable<T>)

Inizializza una nuova istanza della classe Stack<T> che contiene gli elementi copiati dalla raccolta specificata e ha la capacità sufficiente per contenere il numero di elementi copiati.Initializes a new instance of the Stack<T> class that contains elements copied from the specified collection and has sufficient capacity to accommodate the number of elements copied.

Stack<T>(Int32)

Consente l'inizializzazione di una nuova istanza della classe Stack<T>, che è vuota e ha la capacità iniziale maggiore tra quella specificata e quella predefinita.Initializes a new instance of the Stack<T> class that is empty and has the specified initial capacity or the default initial capacity, whichever is greater.

Proprietà

Count

Ottiene il numero di elementi contenuti in Stack<T>.Gets the number of elements contained in the Stack<T>.

Metodi

Clear()

Rimuove tutti gli oggetti da Stack<T>.Removes all objects from the Stack<T>.

Contains(T)

Determina se un elemento è incluso in Stack<T>.Determines whether an element is in the Stack<T>.

CopyTo(T[], Int32)

Consente di copiare lo Stack<T> in una Array unidimensionale esistente, partendo dall'indice della matrice specificata.Copies the Stack<T> to an existing one-dimensional Array, starting at the specified array index.

Equals(Object)

Determina se l'oggetto specificato è uguale all'oggetto corrente.Determines whether the specified object is equal to the current object.

(Ereditato da Object)
GetEnumerator()

Restituisce un enumeratore per l'insieme Stack<T>.Returns an enumerator for the Stack<T>.

GetHashCode()

Funge da funzione hash predefinita.Serves as the default hash function.

(Ereditato da Object)
GetType()

Ottiene l'oggetto Type dell'istanza corrente.Gets the Type of the current instance.

(Ereditato da Object)
MemberwiseClone()

Crea una copia superficiale dell'oggetto Object corrente.Creates a shallow copy of the current Object.

(Ereditato da Object)
Peek()

Viene restituito l'oggetto all'inizio dello Stack<T> senza rimuoverlo.Returns the object at the top of the Stack<T> without removing it.

Pop()

Rimuove e restituisce l'oggetto all'inizio dello Stack<T>.Removes and returns the object at the top of the Stack<T>.

Push(T)

Inserisce un oggetto all'inizio dello Stack<T>.Inserts an object at the top of the Stack<T>.

ToArray()

Consente di copiare lo Stack<T> in una nuova matrice.Copies the Stack<T> to a new array.

ToString()

Restituisce una stringa che rappresenta l'oggetto corrente.Returns a string that represents the current object.

(Ereditato da Object)
TrimExcess()

Imposta la capacità dell'insieme sul numero reale di elementi contenuti nell'oggetto Stack<T>, se questo numero è inferiore al 90 per cento della capacità corrente.Sets the capacity to the actual number of elements in the Stack<T>, if that number is less than 90 percent of current capacity.

TryPeek(T)
TryPop(T)

Implementazioni dell'interfaccia esplicita

ICollection.CopyTo(Array, Int32)

Copia gli elementi di ICollection in Array a partire da un particolare indice Array.Copies the elements of the ICollection to an Array, starting at a particular Array index.

ICollection.IsSynchronized

Ottiene un valore che indica se l'accesso a ICollection è sincronizzato (thread-safe).Gets a value indicating whether access to the ICollection is synchronized (thread safe).

ICollection.SyncRoot

Ottiene un oggetto che può essere usato per sincronizzare l'accesso a ICollection.Gets an object that can be used to synchronize access to the ICollection.

IEnumerable.GetEnumerator()

Restituisce un enumeratore che consente di eseguire l'iterazione di una raccolta.Returns an enumerator that iterates through a collection.

IEnumerable<T>.GetEnumerator()

Restituisce un enumeratore che consente di scorrere la raccolta.Returns an enumerator that iterates through the collection.

Metodi di estensione

CopyToDataTable<T>(IEnumerable<T>)

Restituisce un oggetto DataTable che contiene copie degli oggetti DataRow, dato un oggetto IEnumerable<T> di input dove il parametro generico DataRow è T.Returns a DataTable that contains copies of the DataRow objects, given an input IEnumerable<T> object where the generic parameter T is DataRow.

CopyToDataTable<T>(IEnumerable<T>, DataTable, LoadOption)

Copia gli oggetti DataRow nell'oggetto DataTable specificato, dato un oggetto IEnumerable<T> di input dove il parametro generico T è DataRow.Copies DataRow objects to the specified DataTable, given an input IEnumerable<T> object where the generic parameter T is DataRow.

CopyToDataTable<T>(IEnumerable<T>, DataTable, LoadOption, FillErrorEventHandler)

Copia gli oggetti DataRow nell'oggetto DataTable specificato, dato un oggetto IEnumerable<T> di input dove il parametro generico T è DataRow.Copies DataRow objects to the specified DataTable, given an input IEnumerable<T> object where the generic parameter T is DataRow.

Cast<TResult>(IEnumerable)

Esegue il cast degli elementi di un oggetto IEnumerable nel tipo specificato.Casts the elements of an IEnumerable to the specified type.

OfType<TResult>(IEnumerable)

Filtra gli elementi di un oggetto IEnumerable in base a un tipo specificato.Filters the elements of an IEnumerable based on a specified type.

AsParallel(IEnumerable)

Consente la parallelizzazione di una query.Enables parallelization of a query.

AsQueryable(IEnumerable)

Converte un oggetto IEnumerable in un oggetto IQueryable.Converts an IEnumerable to an IQueryable.

Ancestors<T>(IEnumerable<T>)

Restituisce una raccolta di elementi che contiene i predecessori di ciascun nodo nella raccolta di origine.Returns a collection of elements that contains the ancestors of every node in the source collection.

Ancestors<T>(IEnumerable<T>, XName)

Restituisce una raccolta di elementi filtrati che contiene i predecessori di ciascun nodo nella raccolta di origine.Returns a filtered collection of elements that contains the ancestors of every node in the source collection. Solo gli elementi che hanno un oggetto XName corrispondente vengono inclusi nella raccolta.Only elements that have a matching XName are included in the collection.

DescendantNodes<T>(IEnumerable<T>)

Restituisce una raccolta di nodi discendenti di ciascun documento ed elemento nella raccolta di origine.Returns a collection of the descendant nodes of every document and element in the source collection.

Descendants<T>(IEnumerable<T>)

Restituisce una raccolta di elementi che contiene gli elementi discendenti di ciascun elemento e documento nella raccolta di origine.Returns a collection of elements that contains the descendant elements of every element and document in the source collection.

Descendants<T>(IEnumerable<T>, XName)

Restituisce una raccolta filtrata di elementi che contiene gli elementi discendenti di ciascun elemento e documento nella raccolta di origine.Returns a filtered collection of elements that contains the descendant elements of every element and document in the source collection. Solo gli elementi che hanno un oggetto XName corrispondente vengono inclusi nella raccolta.Only elements that have a matching XName are included in the collection.

Elements<T>(IEnumerable<T>)

Restituisce una raccolta di elementi figlio di ciascun elemento e documento nella raccolta di origine.Returns a collection of the child elements of every element and document in the source collection.

Elements<T>(IEnumerable<T>, XName)

Restituisce una raccolta filtrata degli elementi figlio di ciascun elemento e documento nella raccolta di origine.Returns a filtered collection of the child elements of every element and document in the source collection. Solo gli elementi che hanno un oggetto XName corrispondente vengono inclusi nella raccolta.Only elements that have a matching XName are included in the collection.

InDocumentOrder<T>(IEnumerable<T>)

Restituisce una raccolta di nodi che contiene tutti i nodi nella raccolta di origine ordinati in base all'ordine con cui sono riportati nel documento.Returns a collection of nodes that contains all nodes in the source collection, sorted in document order.

Nodes<T>(IEnumerable<T>)

Restituisce una raccolta di nodi figlio di ciascun documento ed elemento nella raccolta di origine.Returns a collection of the child nodes of every document and element in the source collection.

Remove<T>(IEnumerable<T>)

Rimuove ciascun nodo nella raccolta di origine dal nodo padre.Removes every node in the source collection from its parent node.

Si applica a

Thread safety

I membri staticiShared pubblici (in Visual Basic) di questo tipo sono thread-safe.Public static (Shared in Visual Basic) members of this type are thread safe. I membri di istanza non sono garantiti come thread-safe.Any instance members are not guaranteed to be thread safe.

Un Stack<T> oggetto può supportare più lettori contemporaneamente, purché la raccolta non venga modificata.A Stack<T> can support multiple readers concurrently, as long as the collection is not modified. Anche in questo caso, l'enumerazione di una raccolta non è intrinsecamente una procedura thread-safe.Even so, enumerating through a collection is intrinsically not a thread-safe procedure. Per assicurare la protezione del thread durante l'enumerazione, è possibile bloccare la raccolta durante l'intera enumerazione.To guarantee thread safety during enumeration, you can lock the collection during the entire enumeration. Per consentire l'accesso alla raccolta in lettura e scrittura da parte di più thread, è necessario implementare la propria sincronizzazione.To allow the collection to be accessed by multiple threads for reading and writing, you must implement your own synchronization.

Vedi anche