Questo articolo è stato tradotto automaticamente. Per visualizzare l'articolo in inglese, selezionare la casella di controllo Inglese. È possibile anche visualizzare il testo inglese in una finestra popup posizionando il puntatore del mouse sopra il testo.
Traduzione
Inglese

Metodo Stack<T>.Push (T)

 

Data di pubblicazione: ottobre 2016

Inserisce un oggetto all'inizio della classe Stack<T>.

Spazio dei nomi:   System.Collections.Generic
Assembly:  System (in System.dll)

public void Push(
	T item
)

Parametri

item
Type: T

Oggetto di cui effettuare il push in Stack<T>. Il valore può essere null per i tipi di riferimento.

Stack<T> viene implementato come una matrice.

Se Count è già pari alla capacità, la capacità del Stack<T> viene aumentata automaticamente la riallocazione della matrice interna, e gli elementi esistenti vengono copiati nella nuova matrice prima che venga aggiunto il nuovo elemento.

Se tipo T è un tipo di riferimento, null può essere inserito il Stack<T> come segnaposto, se necessario. Occupa uno slot nello stack e viene trattato come qualsiasi altro oggetto.

Se Count è inferiore alla capacità dello stack, Push è un'operazione o (1). Se la capacità deve essere incrementata per far posto al nuovo elemento, Push diventa un'operazione O (n) operazione, in cui n è Count.

Esempio di codice seguente vengono illustrati vari metodi della Stack<T> classe generica, inclusi il Push metodo.

L'esempio di codice crea uno stack di stringhe con capacità predefinita e utilizza il Push metodo per inserire cinque stringhe nello stack. Vengono enumerati gli elementi dello stack, che non cambia lo stato dello stack. Il Pop metodo viene utilizzato per estrarre la prima stringa dallo stack. Il Peek metodo viene utilizzato per esaminare l'elemento successivo nello stack, quindi il Pop metodo viene utilizzato per estrarlo.

Il ToArray metodo viene utilizzato per creare una matrice e copiare gli elementi dello stack, quindi la matrice viene passata per la Stack<T> costruttore che accetta IEnumerable<T>, creando una copia dello stack con l'ordine degli elementi invertiti. Vengono visualizzati gli elementi della copia.

Due volte la dimensione dello stack viene creata una matrice e CopyTo metodo viene utilizzato per copiare gli elementi di matrice a partire dal centro della matrice. Il Stack<T> costruttore viene utilizzato nuovamente per creare una copia dello stack con l'ordine degli elementi invertito; pertanto, i tre elementi null si trova alla fine.

Il Contains metodo viene utilizzato per indicare che la stringa "4" è nella prima copia dello stack, dopo il quale il Clear metodo cancella la copia e la Count proprietà indica che lo stack è vuoto.

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
 */

Universal Windows Platform
Disponibile da 8
.NET Framework
Disponibile da 2.0
Libreria di classi portabile
Supportato in: piattaforme .NET portabili
Silverlight
Disponibile da 2.0
Windows Phone Silverlight
Disponibile da 7.0
Windows Phone
Disponibile da 8.1
Torna all'inizio
Mostra: