Professionelle Bücher. Auch für Einsteiger.

Inhaltsverzeichnis
Vorwort
1 Neues in Java 7
2 Threads und nebenläufige Programmierung
3 Datenstrukturen und Algorithmen
4 Raum und Zeit
5 Dateien, Verzeichnisse und Dateizugriffe
6 Datenströme
7 Die eXtensible Markup Language (XML)
8 Dateiformate
9 Grafische Oberflächen mit Swing
10 Grafikprogrammierung
11 Netzwerkprogrammierung
12 Verteilte Programmierung mit RMI
13 RESTful und SOAP Web-Services
14 JavaServer Pages und Servlets
15 Applets
16 Datenbankmanagement mit JDBC
17 Technologien für die Infrastruktur
18 Reflection und Annotationen
19 Dynamische Übersetzung und Skriptsprachen
20 Logging und Monitoring
21 Java Native Interface (JNI)
22 Sicherheitskonzepte
23 Dienstprogramme für die Java-Umgebung
Stichwort
Download: - openbook, ca. 21,3 MB
Buch bestellen
Ihre Meinung?
<< zurück | Galileo Computing / <openbook> / Java 7 - Mehr als eine Insel | vor >>
Java 7 - Mehr als eine Insel von Christian Ullenboom Das Handbuch zu den Java SE-Bibliotheken
Java 7 - Mehr als eine Insel Galileo Computing 1433 S., 2012, geb. 49,90 Euro, ISBN 978-3-8362-1507-7 |
| 3 Datenstrukturen und Algorithmen
|  | 3.1 Datenstrukturen und die Collection-API
|  |  | 3.1.1 Designprinzip mit Schnittstellen, abstrakten und konkreten Klassen
|  |  | 3.1.2 Die Basis-Schnittstellen Collection und Map
|  |  | 3.1.3 Die Utility-Klassen Collections und Arrays
|  |  | 3.1.4 Das erste Programm mit Container-Klassen
|  |  | 3.1.5 Die Schnittstelle Collection und Kernkonzepte
|  |  | 3.1.6 Schnittstellen, die Collection erweitern, und Map
|  |  | 3.1.7 Konkrete Container-Klassen
|  |  | 3.1.8 Generische Datentypen in der Collection-API
|  |  | 3.1.9 Die Schnittstelle Iterable und das erweiterte for
|  | 3.2 Listen
|  |  | 3.2.1 Erstes Listen-Beispiel
|  |  | 3.2.2 Auswahlkriterium ArrayList oder LinkedList
|  |  | 3.2.3 Die Schnittstelle List
|  |  | 3.2.4 ArrayList
|  |  | 3.2.5 LinkedList
|  |  | 3.2.6 Der Feld-Adapter Arrays.asList()
|  |  | 3.2.7 ListIterator *
|  |  | 3.2.8 toArray() von Collection verstehen – die Gefahr einer Falle erkennen
|  |  | 3.2.9 Primitive Elemente in Datenstrukturen verwalten
|  | 3.3 Mengen (Sets)
|  |  | 3.3.1 Ein erstes Mengen-Beispiel
|  |  | 3.3.2 Methoden der Schnittstelle Set
|  |  | 3.3.3 HashSet
|  |  | 3.3.4 TreeSet – die sortierte Menge
|  |  | 3.3.5 Die Schnittstellen NavigableSet und SortedSet
|  |  | 3.3.6 LinkedHashSet
|  | 3.4 Stack (Kellerspeicher, Stapel)
|  |  | 3.4.1 Die Methoden von Stack
|  | 3.5 Queues (Schlangen) und Deques
|  |  | 3.5.1 Queue-Klassen
|  |  | 3.5.2 Deque-Klassen
|  |  | 3.5.3 Blockierende Queues und Prioritätswarteschlangen
|  |  | 3.5.4 PriorityQueue
|  | 3.6 Assoziative Speicher
|  |  | 3.6.1 Die Klassen HashMap und TreeMap
|  |  | 3.6.2 Einfügen und Abfragen der Datenstruktur
|  |  | 3.6.3 Über die Bedeutung von equals() und hashCode()
|  |  | 3.6.4 Eigene Objekte hashen
|  |  | 3.6.5 IdentityHashMap
|  |  | 3.6.6 Das Problem von veränderten Elementen
|  |  | 3.6.7 Aufzählungen und Ansichten des Assoziativspeichers
|  |  | 3.6.8 Die Arbeitsweise einer Hash-Tabelle *
|  | 3.7 Die Properties-Klasse
|  |  | 3.7.1 Properties setzen und lesen
|  |  | 3.7.2 Properties verketten
|  |  | 3.7.3 Hierarchische Eigenschaften
|  |  | 3.7.4 Eigenschaften auf der Konsole ausgeben *
|  |  | 3.7.5 Properties laden und speichern
|  |  | 3.7.6 Klassenbeziehungen: Properties und Hashtable *
|  | 3.8 Mit einem Iterator durch die Daten wandern
|  |  | 3.8.1 Die Schnittstelle Iterator
|  |  | 3.8.2 Der Iterator kann (eventuell auch) löschen
|  |  | 3.8.3 Einen Zufallszahleniterator schreiben
|  |  | 3.8.4 Iteratoren von Sammlungen, das erweiterte for und Iterable
|  |  | 3.8.5 Fail-Fast-Iterator und die ConcurrentModificationException
|  |  | 3.8.6 Die Schnittstelle Enumerator *
|  | 3.9 Algorithmen in Collections
|  |  | 3.9.1 Die Bedeutung von Ordnung mit Comparator und Comparable
|  |  | 3.9.2 Sortieren
|  |  | 3.9.3 Den größten und kleinsten Wert einer Collection finden
|  |  | 3.9.4 Nicht-änderbare Datenstrukturen, immutable oder nur-lesen?
|  |  | 3.9.5 Null Object Pattern und leere Sammlungen/Iteratoren zurückgeben
|  |  | 3.9.6 Mit der Halbierungssuche nach Elementen fahnden
|  |  | 3.9.7 Ersetzen, Kopieren, Füllen, Umdrehen, Rotieren *
|  |  | 3.9.8 Listen durchwürfeln *
|  |  | 3.9.9 Häufigkeit eines Elements *
|  |  | 3.9.10 Singletons *
|  |  | 3.9.11 nCopies() *
|  | 3.10 Spezielle thread-sichere Datenstrukturen
|  |  | 3.10.1 Wait-free-Algorithmen
|  |  | 3.10.2 Nebenläufiger Assoziativspeicher und die Schnittstelle ConcurrentMap
|  |  | 3.10.3 ConcurrentLinkedQueue
|  |  | 3.10.4 CopyOnWriteArrayList und CopyOnWriteArraySet
|  |  | 3.10.5 Wrapper zur Synchronisation
|  |  | 3.10.6 Blockierende Warteschlangen
|  |  | 3.10.7 ArrayBlockingQueue und LinkedBlockingQueue
|  |  | 3.10.8 PriorityBlockingQueue
|  | 3.11 Google Guava (aka Google Collections Library)
|  |  | 3.11.1 Beispiel Multi-Set und Multi-Map
|  |  | 3.11.2 Datenstrukturen aus Guava
|  |  | 3.11.3 Utility-Klassen von Guava
|  |  | 3.11.4 Prädikate
|  |  | 3.11.5 Transformationen
|  | 3.12 Die Klasse BitSet für Bitmengen *
|  |  | 3.12.1 Ein BitSet anlegen, füllen und erfragen
|  |  | 3.12.2 Mengenorientierte Operationen
|  |  | 3.12.3 Methodenübersicht
|  |  | 3.12.4 Primzahlen in einem BitSet verwalten
|  | 3.13 Zum Weiterlesen
## 3.4 Stack (Kellerspeicher, Stapel) Die Klasse Stack repräsentiert einen Stapelspeicher, auch Keller genannt, der als LIFO-(Last-in-First-out-)Datenstruktur definiert ist. Beim Hinzufügen von Elementen wächst die Datenstruktur dynamisch. Die Klasse Stack ist eine Erweiterung der Klasse Vector (wir diskutieren diese prickelnde Designentscheidung weiter unten im Abschnitt »Ein Stack ist ein Vector – aha!«), womit die Klasse zusätzliche Funktionalität besitzt, beispielsweise die Fähigkeit zur Aufzählung und zum wahlfreien Zugriff auf Kellerelemente.
Beispiel
Füge in den Stack zwei Strings ein, und lies sie wieder aus:
    Stack<String> stack = new Stack<String>();
    stack.push( "Tanja" );
    stack.push( "Tina" );
    String s1 = stack.pop();
    String s2 = stack.pop();
### 3.4.1 Die Methoden von Stack Stack besitzt nur wenige zusätzliche Methoden.
    class java.util.Stack<E>
    extends Vector<E>
Stack() Der Konstruktor erzeugt einen neuen Stack. boolean empty() Testet, ob Elemente auf dem Stapel vorhanden sind. E push(E item) Das Element item wird auf den Stapel gebracht. E pop() Holt das letzte Element vom Stapel. EmptyStackException signalisiert einen leeren Stapel. E peek() Das oberste Element wird nur vom Stapel gelesen, aber nicht wie bei pop() entfernt. Bei leerem Stapel wird eine EmptyStackException ausgelöst. int search(Object o) Sucht im Stapel nach dem obersten Eintrag, der mit dem Objekt o übereinstimmt. Gibt die Distanz von der Spitze zurück oder –1, falls das Objekt nicht im Stapel ist. 1 bedeutet, dass der gesuchte Eintrag ganz oben auf dem Stapelspeicher liegt, 2 bezeichnet die zweitoberste Position und so weiter. Die Zählweise ist ungewöhnlich, da sie nicht nullbasiert ist wie alle anderen Methoden, die mit Positionen arbeiten. Doch hier handelt es sich ausdrücklich um die Distanz und nicht um die Position!
Hinweis
Exceptions von Stack: Im Gegensatz zu Vector kann Stack die Exception EmptyStackException erzeugen, um einen leeren Stapel zu signalisieren. Durch einen Rückgabewert null ist ein Fehlschlag nicht angezeigt, da null ein gültiger Rückgabewert sein kann.
#### Ein Stack ist ein Vector – aha! Eine genaue Betrachtung der Klasse Stack zeigt den unsinnigen und falschen Einsatz der Vererbung, und es stellt sich die Frage, warum sich der Autor Jonathan Payne für jene Variante entschieden hat. Stack erbt alle Methoden von Vector (einer List) und damit viele Methoden, die im krassen Gegensatz zu den charakteristischen Eigenschaften eines Stapels stehen. Dazu zählen unter anderem die Methoden elementAt(), indexOf(), insertElementAt(), removeElementAt(), setElementAt() und weitere. Wenn eine Unterklasse nicht bedingungslos alle Eigenschaften der Oberklasse unterstützt, ist die Vererbung falsch angewendet. ### Ihr Kommentar Wie hat Ihnen das <openbook> gefallen? Wir freuen uns immer über Ihre freundlichen und kritischen Rückmeldungen. >> Zum Feedback-Formular
<< zurück | <top> | vor >>
Zum Katalog
Java 7 – Mehr als eine Insel Jetzt bestellen
Ihre Meinung?
Wie hat Ihnen das <openbook> gefallen? Ihre Meinung
Buchempfehlungen
| Java und XML
| Einstieg in Eclipse 3.7
| Android 3
| NetBeans Platform 7
| Java ist auch eine Insel
| Apps entwickeln für Android 4
| Java 7
Shopping
Versandkostenfrei bestellen in Deutschland und Österreich Info

Copyright © Galileo Press 2012
Für Ihren privaten Gebrauch dürfen Sie die Online-Version natürlich ausdrucken. Ansonsten unterliegt das 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.

[Galileo Computing]
Galileo Press, Rheinwerkallee 4, 53227 Bonn, Tel.: 0228.42150.0, Fax 0228.42150.77, info@galileo-press.de