Stack<T> Stack<T> Stack<T> Stack<T> Class

Definição

Representa uma coleção UEPS (último a entrar, primeiro a sair) de tamanho variável das instâncias do mesmo tipo especificado.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)

Parâmetros de tipo

T

Especifica o tipo dos elementos na pilha.Specifies the type of elements in the stack.

Herança
Stack<T>Stack<T>Stack<T>Stack<T>
Atributos
Implementações

Exemplos

O exemplo de código a seguir demonstra vários métodos Stack<T> da classe genérica.The following code example demonstrates several methods of the Stack<T> generic class. O exemplo de código cria uma pilha de cadeias de caracteres com capacidade Push padrão e usa o método para enviar por push cinco cadeias de caracteres para a pilha.The code example creates a stack of strings with default capacity and uses the Push method to push five strings onto the stack. Os elementos da pilha são enumerados, o que não altera o estado da pilha.The elements of the stack are enumerated, which does not change the state of the stack. O Pop método é usado para retirar a primeira cadeia de caracteres da pilha.The Pop method is used to pop the first string off the stack. O Peek método é usado para examinar o próximo item na pilha e, em seguida, o Pop método é usado para desativá-lo.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.

O ToArray método é usado para criar uma matriz e copiar os elementos da pilha para ela, então a matriz é passada para Stack<T> o construtor que IEnumerable<T>usa, criando uma cópia da pilha com a ordem dos elementos invertidos.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. Os elementos da cópia são exibidos.The elements of the copy are displayed.

Uma matriz duas vezes o tamanho da pilha é criado e o CopyTo método é usado para copiar os elementos da matriz que começam no meio da matriz.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. O Stack<T> Construtor é usado novamente para criar uma cópia da pilha com a ordem dos elementos invertido; portanto, os três elementos nulos estão no final.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.

O Contains método é usado para mostrar que a cadeia de caracteres "quatro" está na primeira cópia da pilha, após a qual Clear o método limpa a cópia e a Count Propriedade mostra que a pilha está vazia.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

Comentários

Stack<T>é implementado como uma matriz.Stack<T> is implemented as an array.

As pilhas e as filas são úteis quando você precisa de armazenamento temporário para obter informações; ou seja, quando você pode querer descartar um elemento depois de recuperar seu valor.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. Use Queue<T> se você precisar acessar as informações na mesma ordem em que elas são armazenadas na coleção.Use Queue<T> if you need to access the information in the same order that it is stored in the collection. Use System.Collections.Generic.Stack<T> se você precisar acessar as informações na ordem inversa.Use System.Collections.Generic.Stack<T> if you need to access the information in reverse order.

Use os System.Collections.Concurrent.ConcurrentStack<T> tipos System.Collections.Concurrent.ConcurrentQueue<T> e quando precisar acessar a coleção de vários threads simultaneamente.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.

Um uso comum para System.Collections.Generic.Stack<T> o é preservar os Estados variáveis durante chamadas para outros procedimentos.A common use for System.Collections.Generic.Stack<T> is to preserve variable states during calls to other procedures.

Três operações principais podem ser executadas em um System.Collections.Generic.Stack<T> e seus elementos:Three main operations can be performed on a System.Collections.Generic.Stack<T> and its elements:

  • PushInsere um elemento na parte superior do Stack.Push inserts an element at the top of the Stack.

  • PopRemove um elemento da parte superior do Stack<T>.Pop removes an element from the top of the Stack<T>.

  • PeekRetorna um elemento que está na parte superior do Stack<T> , mas não o Stack<T>remove do.Peek returns an element that is at the top of the Stack<T> but does not remove it from the Stack<T>.

A capacidade de um Stack<T> é o número de elementos que Stack<T> o pode conter.The capacity of a Stack<T> is the number of elements the Stack<T> can hold. À medida que os elementos são Stack<T>adicionados a um, a capacidade é aumentada automaticamente conforme necessário, realocando a matriz interna.As elements are added to a Stack<T>, the capacity is automatically increased as required by reallocating the internal array. A capacidade pode ser reduzida chamando TrimExcess.The capacity can be decreased by calling TrimExcess.

Se Count for menor que a capacidade da pilha, Push será uma operação O (1).If Count is less than the capacity of the stack, Push is an O(1) operation. Se a capacidade precisa ser aumentada para acomodar o novo elemento, Push torna-se umanoperação O () n , Countonde está.If the capacity needs to be increased to accommodate the new element, Push becomes an O(n) operation, where n is Count. Popé uma operação O (1).Pop is an O(1) operation.

Stack<T>aceita null como um valor válido para tipos de referência e permite elementos duplicados.Stack<T> accepts null as a valid value for reference types and allows duplicate elements.

Construtores

Stack<T>() Stack<T>() Stack<T>() Stack<T>()

Inicializa uma nova instância da classe Stack<T> que está vazia e tem a capacidade inicial padrão.Initializes a new instance of the Stack<T> class that is empty and has the default initial capacity.

Stack<T>(IEnumerable<T>) Stack<T>(IEnumerable<T>) Stack<T>(IEnumerable<T>) Stack<T>(IEnumerable<T>)

Inicializa uma nova instância da classe Stack<T>, que contém os elementos copiados da coleção especificada e tem capacidade suficiente para acomodar o número de elementos copiados.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) Stack<T>(Int32) Stack<T>(Int32) Stack<T>(Int32)

Inicializa uma nova instância da classe Stack<T> que está vazia e tem a capacidade inicial especificada ou a capacidade inicial padrão, a que for maior.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.

Propriedades

Count Count Count Count

Obtém o número de elementos contidos no Stack<T>.Gets the number of elements contained in the Stack<T>.

Métodos

Clear() Clear() Clear() Clear()

Remove todos os objetos da Stack<T>.Removes all objects from the Stack<T>.

Contains(T) Contains(T) Contains(T) Contains(T)

Determina se um elemento está no Stack<T>.Determines whether an element is in the Stack<T>.

CopyTo(T[], Int32) CopyTo(T[], Int32) CopyTo(T[], Int32) CopyTo(T[], Int32)

Copia o Stack<T> para um unidimensional Array existente, começando no índice da matriz especificada.Copies the Stack<T> to an existing one-dimensional Array, starting at the specified array index.

Equals(Object) Equals(Object) Equals(Object) Equals(Object)

Determina se o objeto especificado é igual ao objeto atual.Determines whether the specified object is equal to the current object.

(Inherited from Object)
GetEnumerator() GetEnumerator() GetEnumerator() GetEnumerator()

Retorna um enumerador para o Stack<T>.Returns an enumerator for the Stack<T>.

GetHashCode() GetHashCode() GetHashCode() GetHashCode()

Serve como a função de hash padrão.Serves as the default hash function.

(Inherited from Object)
GetType() GetType() GetType() GetType()

Obtém o Type da instância atual.Gets the Type of the current instance.

(Inherited from Object)
MemberwiseClone() MemberwiseClone() MemberwiseClone() MemberwiseClone()

Cria uma cópia superficial do Object atual.Creates a shallow copy of the current Object.

(Inherited from Object)
Peek() Peek() Peek() Peek()

Retorna o objeto na parte superior do Stack<T> sem removê-lo.Returns the object at the top of the Stack<T> without removing it.

Pop() Pop() Pop() Pop()

Remove e retorna o objeto na parte superior do Stack<T>.Removes and returns the object at the top of the Stack<T>.

Push(T) Push(T) Push(T) Push(T)

Insere um objeto na parte superior do Stack<T>.Inserts an object at the top of the Stack<T>.

ToArray() ToArray() ToArray() ToArray()

Copia o Stack<T> em uma nova matriz.Copies the Stack<T> to a new array.

ToString() ToString() ToString() ToString()

Retorna uma cadeia de caracteres que representa o objeto atual.Returns a string that represents the current object.

(Inherited from Object)
TrimExcess() TrimExcess() TrimExcess() TrimExcess()

Definirá a capacidade para o número real de elementos no Stack<T>, se esse número for menor que 90% da capacidade atual.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) TryPeek(T) TryPeek(T) TryPeek(T)
TryPop(T) TryPop(T) TryPop(T) TryPop(T)

Implantações explícitas de interface

ICollection.CopyTo(Array, Int32) ICollection.CopyTo(Array, Int32) ICollection.CopyTo(Array, Int32) ICollection.CopyTo(Array, Int32)

Copia os elementos do ICollection para um Array, começando em um determinado índice Array.Copies the elements of the ICollection to an Array, starting at a particular Array index.

ICollection.IsSynchronized ICollection.IsSynchronized ICollection.IsSynchronized ICollection.IsSynchronized

Obtém um valor que indica se o acesso à ICollection é sincronizado (thread-safe).Gets a value indicating whether access to the ICollection is synchronized (thread safe).

ICollection.SyncRoot ICollection.SyncRoot ICollection.SyncRoot ICollection.SyncRoot

Obtém um objeto que pode ser usado para sincronizar o acesso ao ICollection.Gets an object that can be used to synchronize access to the ICollection.

IEnumerable.GetEnumerator() IEnumerable.GetEnumerator() IEnumerable.GetEnumerator() IEnumerable.GetEnumerator()

Retorna um enumerador que itera em uma coleção.Returns an enumerator that iterates through a collection.

IEnumerable<T>.GetEnumerator() IEnumerable<T>.GetEnumerator() IEnumerable<T>.GetEnumerator() IEnumerable<T>.GetEnumerator()

Retorna um enumerador que itera pela coleção.Returns an enumerator that iterates through the collection.

Métodos de Extensão

CopyToDataTable<T>(IEnumerable<T>) CopyToDataTable<T>(IEnumerable<T>) CopyToDataTable<T>(IEnumerable<T>) CopyToDataTable<T>(IEnumerable<T>)

Retorna um DataTable que contém cópias dos objetos DataRow, dado um objeto IEnumerable<T> de entrada em que o parâmetro genérico T é DataRow.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) CopyToDataTable<T>(IEnumerable<T>, DataTable, LoadOption) CopyToDataTable<T>(IEnumerable<T>, DataTable, LoadOption) CopyToDataTable<T>(IEnumerable<T>, DataTable, LoadOption)

Copia objetos DataRow no DataTable especificado, dado um objeto IEnumerable<T> de entrada em que o parâmetro genérico 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) CopyToDataTable<T>(IEnumerable<T>, DataTable, LoadOption, FillErrorEventHandler) CopyToDataTable<T>(IEnumerable<T>, DataTable, LoadOption, FillErrorEventHandler) CopyToDataTable<T>(IEnumerable<T>, DataTable, LoadOption, FillErrorEventHandler)

Copia objetos DataRow no DataTable especificado, dado um objeto IEnumerable<T> de entrada em que o parâmetro genérico 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) Cast<TResult>(IEnumerable) Cast<TResult>(IEnumerable) Cast<TResult>(IEnumerable)

Converte os elementos de um IEnumerable para o tipo especificado.Casts the elements of an IEnumerable to the specified type.

OfType<TResult>(IEnumerable) OfType<TResult>(IEnumerable) OfType<TResult>(IEnumerable) OfType<TResult>(IEnumerable)

Filtra os elementos de um IEnumerable com base em um tipo especificado.Filters the elements of an IEnumerable based on a specified type.

AsParallel(IEnumerable) AsParallel(IEnumerable) AsParallel(IEnumerable) AsParallel(IEnumerable)

Habilita a paralelização de uma consulta.Enables parallelization of a query.

AsQueryable(IEnumerable) AsQueryable(IEnumerable) AsQueryable(IEnumerable) AsQueryable(IEnumerable)

Converte um IEnumerable em um IQueryable.Converts an IEnumerable to an IQueryable.

Ancestors<T>(IEnumerable<T>) Ancestors<T>(IEnumerable<T>) Ancestors<T>(IEnumerable<T>) Ancestors<T>(IEnumerable<T>)

Retorna uma coleção de elementos que contém os ancestrais de cada nó na coleção de origem.Returns a collection of elements that contains the ancestors of every node in the source collection.

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

Retorna uma coleção filtrada de elementos que contém os ancestrais de cada nó na coleção de origem.Returns a filtered collection of elements that contains the ancestors of every node in the source collection. Somente os elementos que têm um XName correspondente são incluídos na coleção.Only elements that have a matching XName are included in the collection.

DescendantNodes<T>(IEnumerable<T>) DescendantNodes<T>(IEnumerable<T>) DescendantNodes<T>(IEnumerable<T>) DescendantNodes<T>(IEnumerable<T>)

Retorna uma coleção dos nós descendentes de todos os documentos e elementos na coleção de origem.Returns a collection of the descendant nodes of every document and element in the source collection.

Descendants<T>(IEnumerable<T>) Descendants<T>(IEnumerable<T>) Descendants<T>(IEnumerable<T>) Descendants<T>(IEnumerable<T>)

Retorna uma coleção de elementos que contém os elementos descendentes de cada elemento e o documento na coleção de origem.Returns a collection of elements that contains the descendant elements of every element and document in the source collection.

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

Retorna uma coleção filtrada de elementos que contém os elementos descendentes de cada elemento e o documento na coleção de origem.Returns a filtered collection of elements that contains the descendant elements of every element and document in the source collection. Somente os elementos que têm um XName correspondente são incluídos na coleção.Only elements that have a matching XName are included in the collection.

Elements<T>(IEnumerable<T>) Elements<T>(IEnumerable<T>) Elements<T>(IEnumerable<T>) Elements<T>(IEnumerable<T>)

Retorna uma coleção dos filhos elementos de cada elemento e o documento na coleção de origem.Returns a collection of the child elements of every element and document in the source collection.

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

Retorna uma coleção filtrada dos elementos filho de cada elemento e documento na coleção de origem.Returns a filtered collection of the child elements of every element and document in the source collection. Somente os elementos que têm um XName correspondente são incluídos na coleção.Only elements that have a matching XName are included in the collection.

InDocumentOrder<T>(IEnumerable<T>) InDocumentOrder<T>(IEnumerable<T>) InDocumentOrder<T>(IEnumerable<T>) InDocumentOrder<T>(IEnumerable<T>)

Retorna uma coleção de nós que contém todos os nós na coleção de origem, classificados em ordem segundo o documento.Returns a collection of nodes that contains all nodes in the source collection, sorted in document order.

Nodes<T>(IEnumerable<T>) Nodes<T>(IEnumerable<T>) Nodes<T>(IEnumerable<T>) Nodes<T>(IEnumerable<T>)

Retorna uma coleção dos nós filhos de todos os documentos e elementos na coleção de origem.Returns a collection of the child nodes of every document and element in the source collection.

Remove<T>(IEnumerable<T>) Remove<T>(IEnumerable<T>) Remove<T>(IEnumerable<T>) Remove<T>(IEnumerable<T>)

Remove todos os nós na coleção de origem do respectivo nó pai.Removes every node in the source collection from its parent node.

Aplica-se a

Acesso thread-safe

Os membros estáticos públicos (Shared no Visual Basic) desse são thread-safe.Public static (Shared in Visual Basic) members of this type are thread safe. Não há garantia de que qualquer membro de instância seja thread-safe.Any instance members are not guaranteed to be thread safe.

Um Stack<T> pode dar suporte a vários leitores simultaneamente, desde que a coleção não seja modificada.A Stack<T> can support multiple readers concurrently, as long as the collection is not modified. Mesmo assim, a enumeração por meio de uma coleção é intrinsecamente não um procedimento de thread-safe.Even so, enumerating through a collection is intrinsically not a thread-safe procedure. Para garantir acesso thread-safe durante a enumeração, é possível bloquear a coleção durante toda a enumeração.To guarantee thread safety during enumeration, you can lock the collection during the entire enumeration. Para permitir que a coleção seja acessada por vários threads para leitura e gravação, você deve implementar sua própria sincronização.To allow the collection to be accessed by multiple threads for reading and writing, you must implement your own synchronization.

Veja também