Stack<T> Klasa

Definicja

Reprezentuje kolekcję o rozmiarze "ostatniego" w pierwszej kolejności (LIFO) wystąpień tego samego typu.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)

Parametry typu

T

Określa typ elementów w stosie.Specifies the type of elements in the stack.

Dziedziczenie
Stack<T>
Atrybuty
Implementuje

Przykłady

Poniższy przykład kodu ilustruje kilka metod klasy ogólnej Stack<T>.The following code example demonstrates several methods of the Stack<T> generic class. Przykładowy kod tworzy stos ciągów z pojemnością domyślną i używa metody Push do wypychania pięciu ciągów na stos.The code example creates a stack of strings with default capacity and uses the Push method to push five strings onto the stack. Elementy stosu są wyliczane, co nie powoduje zmiany stanu stosu.The elements of the stack are enumerated, which does not change the state of the stack. Metoda Pop służy do wyłączania pierwszego ciągu na stosie.The Pop method is used to pop the first string off the stack. Metoda Peek jest używana do przeszukiwania następnego elementu na stosie, a następnie Metoda Pop służy do wyłączania.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.

Metoda ToArray służy do tworzenia tablicy i kopiowania do niej elementów stosu, a następnie tablica jest przenoszona do konstruktora Stack<T>, który pobiera IEnumerable<T>, tworząc kopię stosu z kolejnością elementów odwróconych.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. Zostaną wyświetlone elementy kopiowane.The elements of the copy are displayed.

Tworzona jest podwójna tablica rozmiaru stosu, a metoda CopyTo jest używana do kopiowania elementów tablicy, zaczynając od środka tablicy.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. Konstruktor Stack<T> jest ponownie używany do tworzenia kopii stosu z kolejnością elementów odwróconych; w związku z tym trzy elementy null są na końcu.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.

Metoda Contains służy do pokazywania, że ciąg "cztery" znajduje się w pierwszej kopii stosu, po której Metoda Clear czyści kopię, a właściwość Count pokazuje, że stos jest pusty.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

Uwagi

Stack<T> jest zaimplementowany jako tablica.Stack<T> is implemented as an array.

Stosy i kolejki są przydatne, gdy potrzebujesz magazynu tymczasowego na potrzeby informacji; oznacza to, że jeśli chcesz odrzucić element po pobraniu jego wartości.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. Użyj Queue<T>, jeśli chcesz uzyskać dostęp do informacji w tej samej kolejności, w której jest przechowywany w kolekcji.Use Queue<T> if you need to access the information in the same order that it is stored in the collection. Użyj System.Collections.Generic.Stack<T>, jeśli chcesz uzyskać dostęp do informacji w odwrotnej kolejności.Use System.Collections.Generic.Stack<T> if you need to access the information in reverse order.

Używaj System.Collections.Concurrent.ConcurrentStack<T> i System.Collections.Concurrent.ConcurrentQueue<T> typów, gdy chcesz uzyskać dostęp do kolekcji z wielu wątków jednocześnie.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.

Typowym zastosowaniem System.Collections.Generic.Stack<T> jest zachowywanie Stanów zmiennych podczas wywołań do innych procedur.A common use for System.Collections.Generic.Stack<T> is to preserve variable states during calls to other procedures.

Trzy główne operacje można wykonywać na System.Collections.Generic.Stack<T> i jego elementach:Three main operations can be performed on a System.Collections.Generic.Stack<T> and its elements:

Pojemność Stack<T> to liczba elementów, które Stack<T> mogą być przechowywane.The capacity of a Stack<T> is the number of elements the Stack<T> can hold. Po dodaniu elementów do Stack<T>pojemność jest automatycznie zwiększana zgodnie z wymaganiami przez ponowną alokację tablicy wewnętrznej.As elements are added to a Stack<T>, the capacity is automatically increased as required by reallocating the internal array. Wydajność można zmniejszyć, wywołując TrimExcess.The capacity can be decreased by calling TrimExcess.

Jeśli wartość Count jest mniejsza niż pojemność stosu, Push jest operacją O (1).If Count is less than the capacity of the stack, Push is an O(1) operation. Jeśli pojemność musi zostać zwiększona w celu uwzględnienia nowego elementu, Push jest operacją O (n), gdzie n jest Count.If the capacity needs to be increased to accommodate the new element, Push becomes an O(n) operation, where n is Count. Pop jest operacją O (1).Pop is an O(1) operation.

Stack<T> akceptuje null jako prawidłową wartość dla typów odwołań i umożliwia duplikowanie elementów.Stack<T> accepts null as a valid value for reference types and allows duplicate elements.

Konstruktory

Stack<T>()

Inicjuje nowe wystąpienie klasy Stack<T>, która jest pusta i ma domyślną pojemność początkową.Initializes a new instance of the Stack<T> class that is empty and has the default initial capacity.

Stack<T>(IEnumerable<T>)

Inicjuje nowe wystąpienie klasy Stack<T>, która zawiera elementy skopiowane z określonej kolekcji i ma wystarczającą pojemność, aby pomieścić liczbę skopiowanych elementów.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)

Inicjuje nowe wystąpienie klasy Stack<T>, które jest puste i ma określoną pojemność początkową lub domyślną pojemność początkową, w zależności od tego, która wartość jest większa.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.

Właściwości

Count

Pobiera liczbę elementów zawartych w słowniku Stack<T>.Gets the number of elements contained in the Stack<T>.

Metody

Clear()

Usuwa wszystkie obiekty z Stack<T>.Removes all objects from the Stack<T>.

Contains(T)

Określa, czy element znajduje się w Stack<T>.Determines whether an element is in the Stack<T>.

CopyTo(T[], Int32)

Kopiuje Stack<T> do istniejącej Arrayjednowymiarowej, rozpoczynając od określonego indeksu tablicy.Copies the Stack<T> to an existing one-dimensional Array, starting at the specified array index.

Equals(Object)

Określa, czy określony obiekt jest równy bieżącemu obiektowi.Determines whether the specified object is equal to the current object.

(Odziedziczone po Object)
GetEnumerator()

Zwraca moduł wyliczający dla Stack<T>.Returns an enumerator for the Stack<T>.

GetHashCode()

Służy jako domyślna funkcja skrótu.Serves as the default hash function.

(Odziedziczone po Object)
GetType()

Pobiera Type bieżącego wystąpienia.Gets the Type of the current instance.

(Odziedziczone po Object)
MemberwiseClone()

Tworzy skróconą kopię bieżącego Object.Creates a shallow copy of the current Object.

(Odziedziczone po Object)
Peek()

Zwraca obiekt w górnej części Stack<T> bez usuwania go.Returns the object at the top of the Stack<T> without removing it.

Pop()

Usuwa i zwraca obiekt w górnej części Stack<T>.Removes and returns the object at the top of the Stack<T>.

Push(T)

Wstawia obiekt w górnej części Stack<T>.Inserts an object at the top of the Stack<T>.

ToArray()

Kopiuje Stack<T> do nowej tablicy.Copies the Stack<T> to a new array.

ToString()

Zwraca ciąg, który reprezentuje bieżący obiekt.Returns a string that represents the current object.

(Odziedziczone po Object)
TrimExcess()

Ustawia pojemność na rzeczywistą liczbę elementów w Stack<T>, jeśli ta liczba jest mniejsza niż 90% bieżącej pojemności.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)

Jawne implementacje interfejsu

ICollection.CopyTo(Array, Int32)

Kopiuje elementy ICollection do Array, rozpoczynając od określonego indeksu Array.Copies the elements of the ICollection to an Array, starting at a particular Array index.

ICollection.IsSynchronized

Pobiera wartość wskazującą, czy dostęp do ICollection jest synchronizowany (bezpieczny wątkowo).Gets a value indicating whether access to the ICollection is synchronized (thread safe).

ICollection.SyncRoot

Pobiera obiekt, który może służyć do synchronizowania dostępu do ICollection.Gets an object that can be used to synchronize access to the ICollection.

IEnumerable.GetEnumerator()

Zwraca moduł wyliczający, który dokonuje iteracji w kolekcji.Returns an enumerator that iterates through a collection.

IEnumerable<T>.GetEnumerator()

Zwraca moduł wyliczający, który dokonuje iteracji w kolekcji.Returns an enumerator that iterates through the collection.

Metody rozszerzania

CopyToDataTable<T>(IEnumerable<T>)

Zwraca DataTable, który zawiera kopie obiektów DataRow, przy użyciu obiektu wejściowego IEnumerable<T>, gdzie T parametru generycznego jest 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)

Kopiuje DataRow obiektów do określonego DataTable, używając obiektu wejściowego IEnumerable<T>, gdzie T parametru generycznego jest 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)

Kopiuje DataRow obiektów do określonego DataTable, używając obiektu wejściowego IEnumerable<T>, gdzie T parametru generycznego jest DataRow.Copies DataRow objects to the specified DataTable, given an input IEnumerable<T> object where the generic parameter T is DataRow.

Cast<TResult>(IEnumerable)

Rzutuje elementy IEnumerable określonego typu.Casts the elements of an IEnumerable to the specified type.

OfType<TResult>(IEnumerable)

Filtruje elementy IEnumerable w oparciu o określony typ.Filters the elements of an IEnumerable based on a specified type.

AsParallel(IEnumerable)

Włącza przetwarzanie równoległe zapytania.Enables parallelization of a query.

AsQueryable(IEnumerable)

Konwertuje IEnumerable na IQueryable.Converts an IEnumerable to an IQueryable.

Ancestors<T>(IEnumerable<T>)

Zwraca kolekcję elementów, które zawierają elementy nadrzędne każdego węzła w kolekcji źródłowej.Returns a collection of elements that contains the ancestors of every node in the source collection.

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

Zwraca przefiltrowany kolekcji elementów, które zawierają elementy nadrzędne każdego węzła w kolekcji źródłowej.Returns a filtered collection of elements that contains the ancestors of every node in the source collection. Kolekcja zawiera tylko elementy, które mają pasujące XName.Only elements that have a matching XName are included in the collection.

DescendantNodes<T>(IEnumerable<T>)

Zwraca kolekcję węzłów podrzędnych każdego dokumentu i elementu w kolekcji źródłowej.Returns a collection of the descendant nodes of every document and element in the source collection.

Descendants<T>(IEnumerable<T>)

Zwraca kolekcję elementów, które zawierają elementy podrzędne każdego elementu i dokumentu w kolekcji źródłowej.Returns a collection of elements that contains the descendant elements of every element and document in the source collection.

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

Zwraca przefiltrowany kolekcji elementów, które zawierają elementy podrzędne każdego elementu i dokumentu w kolekcji źródłowej.Returns a filtered collection of elements that contains the descendant elements of every element and document in the source collection. Kolekcja zawiera tylko elementy, które mają pasujące XName.Only elements that have a matching XName are included in the collection.

Elements<T>(IEnumerable<T>)

Zwraca kolekcję elementów podrzędnych każdego elementu i dokumentu w kolekcji źródłowej.Returns a collection of the child elements of every element and document in the source collection.

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

Zwraca filtrowaną kolekcję elementów podrzędnych każdego elementu i dokumentu w kolekcji źródłowej.Returns a filtered collection of the child elements of every element and document in the source collection. Kolekcja zawiera tylko elementy, które mają pasujące XName.Only elements that have a matching XName are included in the collection.

InDocumentOrder<T>(IEnumerable<T>)

Zwraca kolekcję węzłów, która zawiera wszystkie węzły w kolekcji źródłowej, posortowane w kolejności dokumentu.Returns a collection of nodes that contains all nodes in the source collection, sorted in document order.

Nodes<T>(IEnumerable<T>)

Zwraca kolekcję węzłów podrzędnych każdego dokumentu i elementu w kolekcji źródłowej.Returns a collection of the child nodes of every document and element in the source collection.

Remove<T>(IEnumerable<T>)

Usuwa każdy węzeł w kolekcji źródłowej z węzła nadrzędnego.Removes every node in the source collection from its parent node.

Dotyczy

Bezpieczeństwo wątkowe

Publiczne statyczne (Shared w Visual Basic) składowe tego typu są bezpieczne wątkowo.Public static (Shared in Visual Basic) members of this type are thread safe. Dla żadnych elementów członkowskich wystąpień nie ma gwarancji bezpieczeństwa wątkowego.Any instance members are not guaranteed to be thread safe.

Stack<T> może obsługiwać wielu czytników współbieżnie, o ile kolekcja nie jest modyfikowana.A Stack<T> can support multiple readers concurrently, as long as the collection is not modified. Nawet w ten sposób Wyliczanie za pomocą kolekcji nie jest w sposób wewnętrzny bezpieczny dla wątków.Even so, enumerating through a collection is intrinsically not a thread-safe procedure. Aby zagwarantować bezpieczeństwo wątków podczas wyliczania, można zablokować kolekcję podczas całego procesu wyliczania.To guarantee thread safety during enumeration, you can lock the collection during the entire enumeration. Aby zezwolić wielu wątkom na dostęp do kolekcji w celu odczytu i zapisu danych, należy zaimplementować własny mechanizm synchronizacji.To allow the collection to be accessed by multiple threads for reading and writing, you must implement your own synchronization.

Zobacz też