Galileo Computing < openbook > Galileo Computing - Professionelle Bücher. Auch für Einsteiger.
Professionelle Bücher. Auch für Einsteiger.

Inhaltsverzeichnis
Vorwort zur 5. Auflage
1 Allgemeine Einführung in .NET
2 Grundlagen der Sprache C#
3 Klassendesign
4 Vererbung, Polymorphie und Interfaces
5 Delegates und Ereignisse
6 Weitere .NET-Datentypen
7 Weitere Möglichkeiten von C#
8 Auflistungsklassen (Collections)
9 Fehlerbehandlung und Debugging
10 LINQ to Objects
11 Multithreading und die Task Parallel Library (TPL)
12 Arbeiten mit Dateien und Streams
13 Binäre Serialisierung
14 Einige wichtige .NET-Klassen
15 Projektmanagement und Visual Studio 2010
16 XML
17 WPF – Die Grundlagen
18 WPF-Containerelemente
19 WPF-Steuerelemente
20 Konzepte der WPF
21 Datenbindung
22 2D-Grafik
23 ADO.NET – verbindungsorientierte Objekte
24 ADO.NET – Das Command-Objekt
25 ADO.NET – Der SqlDataAdapter
26 ADO.NET – Daten im lokalen Speicher
27 ADO.NET – Aktualisieren der Datenbank
28 Stark typisierte DataSets
29 LINQ to SQL
30 Weitergabe von Anwendungen
Stichwort

Buch bestellen
Ihre Meinung?

Spacer
<< zurück
Visual C# 2010 von Andreas Kühnel
Das umfassende Handbuch
Buch: Visual C# 2010

Visual C# 2010
geb., mit DVD
1295 S., 49,90 Euro
Rheinwerk Computing
ISBN 978-3-8362-1552-7
Pfeil 8 Auflistungsklassen (Collections)
Pfeil 8.1 Die Listen des Namespace »System.Collections«
Pfeil 8.1.1 Die elementaren Schnittstellen der Auflistungsklassen
Pfeil 8.2 Die Klasse »ArrayList«
Pfeil 8.2.1 Einträge hinzufügen
Pfeil 8.2.2 Datenaustausch zwischen einem Array und einer ArrayList
Pfeil 8.2.3 Die Elemente einer ArrayList sortieren
Pfeil 8.2.4 Sortieren von Arrays mit »ArrayList.Adapter«
Pfeil 8.3 Die Klasse »Hashtable«
Pfeil 8.3.1 Methoden und Eigenschaften der Schnittstelle »IDictionary«
Pfeil 8.3.2 Beispielprogramm zur Klasse »Hashtable«
Pfeil 8.4 Die Klassen »Queue« und »Stack«
Pfeil 8.4.1 Die »Stack«-Klasse
Pfeil 8.5 Objektauflistungen im Überblick
Pfeil 8.6 Generische Auflistungsklassen
Pfeil 8.6.1 Die Interfaces der generischen Auflistungsklassen
Pfeil 8.6.2 Die generische Auflistungsklasse »List<T>«
Pfeil 8.7 Eigene Auflistungen mit »yield« durchlaufen


Galileo Computing - Zum Seitenanfang

8.4 Die Klassen »Queue« und »Stack« Zur nächsten ÜberschriftZur vorigen Überschrift

Ganz spezielle Listen werden durch die Klassen Stack und Queue zur Verfügung gestellt, denn beide implementieren weder das Interface IList noch IDictionary. Dennoch werden sie den Auflistungen zugerechnet, weil sie die Schnittstellen ICollection und somit auch IEnumerable implementieren.

Stack ist eine Datenstruktur, die nach dem LIFO-Prinzip (Last In First Out) arbeitet: Das Element, das als Letztes eingefügt wurde, wird beim folgenden Lesevorgang wieder entnommen. Daraus folgt, dass man auf das Element, das als Erstes auf den Stack gelegt worden ist, erst dann wieder zugreifen kann, wenn alle anderen Elemente den Stack verlassen haben.

Ein Queue-Objekt ist das Pendant zu Stack. Es arbeitet nach dem FIFO-Prinzip (First In First Out): Das zuerst in die Queue geschobene Element wird auch als Erstes wieder entnommen. Das Prinzip gleicht also einer Warteschlange an der Kasse eines Fußballstadions.


Galileo Computing - Zum Seitenanfang

8.4.1 Die »Stack«-Klasse topZur vorigen Überschrift

Schauen wir uns an einem Beispiel an, wie man mit der Klasse Stack arbeitet.


// -------------------------------------------------------------
// Beispiel: ...\Kapitel 8\StackSample
// -------------------------------------------------------------
class Program {
  static void Main(string[] args) {
    Stack myStack = new Stack(11); 
    // Stack füllen
    for(int i = 0; i <= 10; i++)
      myStack.Push(i * i);     
    // Ausgabe an der Konsole
    PrintStack(myStack);
    Console.ReadLine();   
  }
  public static void PrintStack(Stack obj) {
    // alle Elemente aus dem Stack holen
    while(obj.Count != 0) {
      Console.WriteLine(obj.Pop());
    }
  }
}

Das Hinzufügen neuer Elemente geschieht durch den Aufruf der Methode Push, die als Argument ein Objekt erwartet. Im Beispielcode wird eine Schleife durchlaufen, in der insgesamt elf Zahlen auf den Stack gelegt werden. Es handelt sich dabei immer um das Quadrat des aktuellen Schleifenzählers.

Zugegriffen werden kann nur auf das oberste Element im Stack. Dabei handelt es sich immer um das Objekt, das als Letztes mit der Push-Methode auf den Stack gelegt wurde.

Es bieten sich zwei Alternativen an, das oberste Element auszuwerten: Mit Pop wird das oberste Element nicht nur zurückgeliefert, sondern gleichzeitig auch der Stack-Verwaltung entzogen. Mit Peek erhält man zwar die Referenz, ohne das Element jedoch gleichzeitig zu entfernen. Im Beispiel wird der Stack so lange mit Pop abgegriffen, bis die Liste wieder leer ist. Die Reihenfolge der Zahlen beim Hinzufügen lautete:


0 1 4 9 16 25 36 ... 81 100

Die Rückgabe erfolgt mit:


100 81 64 ... 25 16 9 4 1 0

Der Aufruf des parameterlosen Konstruktors der Klasse Stack führt zu einer Kapazität von 10 Elementen, die bei Bedarf automatisch erhöht wird, um weitere Elemente aufzunehmen. Dabei werden alle Elemente in ein neues Array kopiert. Wenn Sie wissen, dass Sie diese Anzahl überschreiten werden, sollten Sie aus Gründen einer besseren Performance den parametrisierten Konstruktor wählen, der die Übergabe der erforderlichen Startkapazität ermöglicht:


Stack stack = new Stack(100);

Reicht das immer noch nicht aus und wird zur Laufzeit die Initialisierungsgröße trotzdem überschritten, verdoppelt sich die Kapazität automatisch.

Die Klasse »Queue«

Das Beispiel, das vorhin die Klasse Stack veranschaulichte, wird nun auf ein Queue-Objekt umgeschrieben:


// -------------------------------------------------------------
// Beispiel: ...\Kapitel 8\QueueSample
// -------------------------------------------------------------
class Program {
  static void Main(string[] args) {
    Queue myQueue = new Queue();
    // Queue füllen
    for(int i = 0; i <= 10; i++)
      myQueue.Enqueue(i * i); 
    // Ausgabe an der Konsole
    PrintStack(myQueue);
    Console.ReadLine();
  }
  public static void PrintStack(Queue obj) {
    // alle Elemente aus dem Stack holen
    while(obj.Count != 0) {
      Console.WriteLine(obj.Dequeue());
    }
  }
}

Diesmal sind es die beiden Methoden Enqueue und Dequeue, mit denen Elemente in die Liste geschoben und wieder aus ihr geholt werden. Dequeue liefert nicht nur die Referenz des Elements, das sich am Anfang befindet; es holt dieses Element auch aus der Warteschlange. Wie bei der Klasse Stack können Sie sich mit Peek auch die Referenz dieses Elements besorgen und es gleichzeitig in der Liste lassen.

Der Elementzugriff erfolgt in derselben Reihenfolge, in der die Objekte der Liste hinzugefügt wurden: Das erste hinzugefügte Element wird auch als erstes herausgeholt, danach kann man das zweite in die Warteschlange gelegte Element holen usw. Ein Zugriff auf ein beliebiges Element ist weder beim Stack noch bei der Queue möglich.

Die Standardkapazität eines Queue-Objekts beträgt 32 Elemente, die Sie mittels eines anderen Konstruktors bei der Instanziierung bedarfsgerecht festlegen können.



Ihr Kommentar

Wie hat Ihnen das <openbook> gefallen? Wir freuen uns immer über Ihre freundlichen und kritischen Rückmeldungen. >> Zum Feedback-Formular
<< zurück
  Zum Katalog
Zum Katalog: Visual C# 2010

Visual C# 2010
Jetzt bestellen


 Ihre Meinung?
Wie hat Ihnen das <openbook> gefallen?
Ihre Meinung

 Buchempfehlungen
Zum Katalog: Professionell entwickeln mit Visual C# 2012






 Professionell
 entwickeln mit
 Visual C# 2012


Zum Katalog: Windows Presentation Foundation






 Windows Presentation
 Foundation


Zum Katalog: Schrödinger programmiert C++






 Schrödinger
 programmiert C++


Zum Katalog: C++ Handbuch






 C++ Handbuch


Zum Katalog: C/C++






 C/C++


 Shopping
Versandkostenfrei bestellen in Deutschland und Österreich
InfoInfo




Copyright © Rheinwerk Verlag GmbH 2010
Für Ihren privaten Gebrauch dürfen Sie die Online-Version natürlich ausdrucken. Ansonsten unterliegt das <openbook> denselben Bestimmungen, wie die gebundene Ausgabe: Das Werk einschließlich aller seiner Teile ist urheberrechtlich geschützt. Alle Rechte vorbehalten einschließlich der Vervielfältigung, Übersetzung, Mikroverfilmung sowie Einspeicherung und Verarbeitung in elektronischen Systemen.


Nutzungsbestimmungen | Datenschutz | Impressum

Rheinwerk Verlag GmbH, Rheinwerkallee 4, 53227 Bonn, Tel.: 0228.42150.0, Fax 0228.42150.77, service@rheinwerk-verlag.de

Cookie-Einstellungen ändern