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

Definición

Representa una colección LIFO (el último en entrar es el primero en salir) de tamaño variable de instancias del mismo 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 el tipo de elementos de la pila.Specifies the type of elements in the stack.

Herencia
Stack<T>Stack<T>Stack<T>Stack<T>
Atributos
Implementaciones

Ejemplos

En el ejemplo de código siguiente se muestran varios Stack<T> métodos de la clase genérica.The following code example demonstrates several methods of the Stack<T> generic class. En el ejemplo de código se crea una pila de cadenas con la capacidad Push predeterminada y se usa el método para introducir cinco cadenas en la pila.The code example creates a stack of strings with default capacity and uses the Push method to push five strings onto the stack. Los elementos de la pila se enumeran, lo que no cambia el estado de la pila.The elements of the stack are enumerated, which does not change the state of the stack. El Pop método se usa para extraer la primera cadena de la pila.The Pop method is used to pop the first string off the stack. El Peek método se utiliza para examinar el siguiente elemento de la pila y, a continuación, Pop se usa el método para desactivarlo.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.

El ToArray método se utiliza para crear una matriz y copiar los elementos de la pila en ella. a continuación, la matriz Stack<T> se pasa al IEnumerable<T>constructor que toma, creando una copia de la pila con el orden de los 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. Se muestran los elementos de la copia.The elements of the copy are displayed.

Se crea una matriz dos veces el tamaño de la pila y se CopyTo usa el método para copiar los elementos de la matriz a partir de la mitad de la 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. El Stack<T> constructor se utiliza de nuevo para crear una copia de la pila con el orden de los elementos invertidos; por lo tanto, los tres elementos NULL se encuentran al 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.

El Contains método se usa para mostrar que la cadena "cuatro" está en la primera copia de la pila, después de la Clear cual el método borra la copia y Count la propiedad muestra que la pila está vacía.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

Comentarios

Stack<T>se implementa como una matriz.Stack<T> is implemented as an array.

Las pilas y las colas son útiles cuando se necesita almacenamiento temporal para obtener información; es decir, cuando es posible que desee descartar un elemento después de recuperar su 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> si necesita tener acceso a la información en el mismo orden en que se almacena en la colección.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> si necesita tener acceso a la información en orden inverso.Use System.Collections.Generic.Stack<T> if you need to access the information in reverse order.

Use los System.Collections.Concurrent.ConcurrentStack<T> tipos System.Collections.Concurrent.ConcurrentQueue<T> y cuando necesite tener acceso a la colección desde varios subprocesos simultáneamente.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 común de System.Collections.Generic.Stack<T> es conservar los Estados variables durante las llamadas a otros procedimientos.A common use for System.Collections.Generic.Stack<T> is to preserve variable states during calls to other procedures.

Se pueden realizar tres operaciones principales en System.Collections.Generic.Stack<T> y sus elementos:Three main operations can be performed on a System.Collections.Generic.Stack<T> and its elements:

  • Pushinserta un elemento en la parte superior de Stack.Push inserts an element at the top of the Stack.

  • Popquita un elemento de la parte superior de Stack<T>.Pop removes an element from the top of the Stack<T>.

  • PeekDevuelve un elemento que está en la parte superior de Stack<T> pero no lo quita Stack<T>de.Peek returns an element that is at the top of the Stack<T> but does not remove it from the Stack<T>.

La capacidad de Stack<T> es el número de elementos que Stack<T> puede contener.The capacity of a Stack<T> is the number of elements the Stack<T> can hold. A medida que se agregan Stack<T>elementos a una, la capacidad aumenta automáticamente según sea necesario reasignando la matriz interna.As elements are added to a Stack<T>, the capacity is automatically increased as required by reallocating the internal array. La capacidad se puede reducir mediante una TrimExcessllamada a.The capacity can be decreased by calling TrimExcess.

Si Count es menor que la capacidad de la pila, Push es una operación O (1).If Count is less than the capacity of the stack, Push is an O(1) operation. Si es necesario aumentar la capacidad para alojar el nuevo elemento, Push se convierte en unanoperación O () n , Countdonde es.If the capacity needs to be increased to accommodate the new element, Push becomes an O(n) operation, where n is Count. Popes una operación O (1).Pop is an O(1) operation.

Stack<T>acepta null como un valor válido para los tipos de referencia y permite elementos duplicados.Stack<T> accepts null as a valid value for reference types and allows duplicate elements.

Constructores

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

Inicializa una nueva instancia de la clase Stack<T> que está vacía y tiene la capacidad inicial predeterminada.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 una nueva instancia de la clase Stack<T> que contiene elementos copiados de la colección especificada y tiene una capacidad suficiente para aceptar el 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 una nueva instancia de la clase Stack<T> que está vacía y tiene la capacidad inicial especificada o la capacidad inicial predeterminada, la que sea mayor.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.

Propiedades

Count Count Count Count

Obtiene el número de elementos incluidos en Stack<T>.Gets the number of elements contained in the Stack<T>.

Métodos

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

Quita todos los objetos de la colección Stack<T>.Removes all objects from the Stack<T>.

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

Determina si un elemento se encuentra en Stack<T>.Determines whether an element is in the Stack<T>.

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

Copia Stack<T> en una Array unidimensional existente, a partir del índice especificado de la matriz.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 si el objeto especificado es igual al objeto actual.Determines whether the specified object is equal to the current object.

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

Devuelve un enumerador para la colección Stack<T>.Returns an enumerator for the Stack<T>.

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

Sirve como la función hash predeterminada.Serves as the default hash function.

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

Obtiene el Type de la instancia actual.Gets the Type of the current instance.

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

Crea una copia superficial del objeto Object actual.Creates a shallow copy of the current Object.

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

Devuelve el objeto situado al principio de Stack<T> sin eliminarlo.Returns the object at the top of the Stack<T> without removing it.

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

Quita y devuelve el objeto situado al principio de Stack<T>.Removes and returns the object at the top of the Stack<T>.

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

Inserta un objeto al principio de Stack<T>.Inserts an object at the top of the Stack<T>.

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

Copia Stack<T> en una nueva matriz.Copies the Stack<T> to a new array.

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

Devuelve una cadena que representa el objeto actual.Returns a string that represents the current object.

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

Establece la capacidad en el número real de elementos en la colección Stack<T>, si este número supone menos del 90 por ciento de la capacidad actual.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)

Implementaciones de interfaz explícitas

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

Copia los elementos de ICollection en Array, empezando por un índice determinado de Array.Copies the elements of the ICollection to an Array, starting at a particular Array index.

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

Obtiene un valor que indica si el acceso a la interfaz ICollection está sincronizado (es seguro para subprocesos).Gets a value indicating whether access to the ICollection is synchronized (thread safe).

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

Obtiene un objeto que se puede usar para sincronizar el acceso a ICollection.Gets an object that can be used to synchronize access to the ICollection.

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

Devuelve un enumerador que recorre en iteración una colección.Returns an enumerator that iterates through a collection.

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

Devuelve un enumerador que procesa una iteración en la colección.Returns an enumerator that iterates through the collection.

Métodos de extensión

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

Devuelve un objeto DataTable que contiene copias de los objetos DataRow, dado un objeto IEnumerable<T> de entrada donde el parámetro T genérico es 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 en el objeto DataTable especificado, dado un objeto IEnumerable<T> de entrada donde el parámetro T genérico es 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 en el objeto DataTable especificado, dado un objeto IEnumerable<T> de entrada donde el parámetro T genérico es 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)

Convierte los elementos de IEnumerable en el 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 los elementos de IEnumerable en función de un tipo especificado.Filters the elements of an IEnumerable based on a specified type.

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

Habilita la paralelización de una consulta.Enables parallelization of a query.

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

Convierte una interfaz IEnumerable en IQueryable.Converts an IEnumerable to an IQueryable.

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

Devuelve una colección de elementos que contiene los antecesores de todos los nodos de la colección de origen.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)

Devuelve una colección de elementos filtrada que contiene los antecesores de todos los nodos de la colección de origen.Returns a filtered collection of elements that contains the ancestors of every node in the source collection. En la colección sólo se incluyen los elementos que tienen un objeto XName coincidente.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>)

Devuelve una colección de los nodos descendientes de todos los documentos y elementos de la colección de origen.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>)

Devuelve una colección de elementos que contiene los elementos descendientes de todos los elementos y documentos de la colección de origen.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)

Devuelve una colección filtrada de elementos que contiene los elementos descendientes de todos los elementos y documentos de la colección de origen.Returns a filtered collection of elements that contains the descendant elements of every element and document in the source collection. En la colección sólo se incluyen los elementos que tienen un objeto XName coincidente.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>)

Devuelve una colección de los elementos secundarios de todos los elementos y documentos de la colección de origen.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)

Devuelve una colección filtrada de los elementos secundarios de todos los elementos y documentos de la colección de origen.Returns a filtered collection of the child elements of every element and document in the source collection. En la colección sólo se incluyen los elementos que tienen un objeto XName coincidente.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>)

Devuelve una colección de nodos que contiene todos los nodos de la colección de origen, clasificados por 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>)

Devuelve una colección de los nodos secundarios de todos los documentos y elementos de la colección de origen.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>)

Quita todos los nodos de la colección de origen de su nodo primario.Removes every node in the source collection from its parent node.

Se aplica a

Seguridad para subprocesos

Los miembros estáticos públicos (Shared en Visual Basic) de este tipo son seguros para subprocesos.Public static (Shared in Visual Basic) members of this type are thread safe. No se garantiza que los miembros de instancias sean seguros para la ejecución de subprocesos.Any instance members are not guaranteed to be thread safe.

Un Stack<T> puede admitir varios lectores simultáneamente, siempre y cuando no se modifique la colección.A Stack<T> can support multiple readers concurrently, as long as the collection is not modified. Aun así, la enumeración a través de una colección no es intrínsecamente un procedimiento seguro para subprocesos.Even so, enumerating through a collection is intrinsically not a thread-safe procedure. A fin de garantizar la seguridad de los subprocesos, se puede bloquear la colección durante toda la enumeración.To guarantee thread safety during enumeration, you can lock the collection during the entire enumeration. Para permitir que varios subprocesos obtengan acceso de lectura y escritura a la colección, debe implementar su propia sincronización.To allow the collection to be accessed by multiple threads for reading and writing, you must implement your own synchronization.

Consulte también: