Rheinwerk Computing < openbook > Rheinwerk Computing - Professionelle Bücher. Auch für Einsteiger.
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

Buch bestellen
Ihre Meinung?

Spacer
Java 7 - Mehr als eine Insel von Christian Ullenboom
Das Handbuch zu den Java SE-Bibliotheken
Buch: Java 7 - Mehr als eine Insel

Java 7 - Mehr als eine Insel
Rheinwerk Computing
1433 S., 2012, geb.
49,90 Euro, ISBN 978-3-8362-1507-7
Pfeil 3 Datenstrukturen und Algorithmen
Pfeil 3.1 Datenstrukturen und die Collection-API
Pfeil 3.1.1 Designprinzip mit Schnittstellen, abstrakten und konkreten Klassen
Pfeil 3.1.2 Die Basis-Schnittstellen Collection und Map
Pfeil 3.1.3 Die Utility-Klassen Collections und Arrays
Pfeil 3.1.4 Das erste Programm mit Container-Klassen
Pfeil 3.1.5 Die Schnittstelle Collection und Kernkonzepte
Pfeil 3.1.6 Schnittstellen, die Collection erweitern, und Map
Pfeil 3.1.7 Konkrete Container-Klassen
Pfeil 3.1.8 Generische Datentypen in der Collection-API
Pfeil 3.1.9 Die Schnittstelle Iterable und das erweiterte for
Pfeil 3.2 Listen
Pfeil 3.2.1 Erstes Listen-Beispiel
Pfeil 3.2.2 Auswahlkriterium ArrayList oder LinkedList
Pfeil 3.2.3 Die Schnittstelle List
Pfeil 3.2.4 ArrayList
Pfeil 3.2.5 LinkedList
Pfeil 3.2.6 Der Feld-Adapter Arrays.asList()
Pfeil 3.2.7 ListIterator *
Pfeil 3.2.8 toArray() von Collection verstehen – die Gefahr einer Falle erkennen
Pfeil 3.2.9 Primitive Elemente in Datenstrukturen verwalten
Pfeil 3.3 Mengen (Sets)
Pfeil 3.3.1 Ein erstes Mengen-Beispiel
Pfeil 3.3.2 Methoden der Schnittstelle Set
Pfeil 3.3.3 HashSet
Pfeil 3.3.4 TreeSet – die sortierte Menge
Pfeil 3.3.5 Die Schnittstellen NavigableSet und SortedSet
Pfeil 3.3.6 LinkedHashSet
Pfeil 3.4 Stack (Kellerspeicher, Stapel)
Pfeil 3.4.1 Die Methoden von Stack
Pfeil 3.5 Queues (Schlangen) und Deques
Pfeil 3.5.1 Queue-Klassen
Pfeil 3.5.2 Deque-Klassen
Pfeil 3.5.3 Blockierende Queues und Prioritätswarteschlangen
Pfeil 3.5.4 PriorityQueue
Pfeil 3.6 Assoziative Speicher
Pfeil 3.6.1 Die Klassen HashMap und TreeMap
Pfeil 3.6.2 Einfügen und Abfragen der Datenstruktur
Pfeil 3.6.3 Über die Bedeutung von equals() und hashCode()
Pfeil 3.6.4 Eigene Objekte hashen
Pfeil 3.6.5 IdentityHashMap
Pfeil 3.6.6 Das Problem von veränderten Elementen
Pfeil 3.6.7 Aufzählungen und Ansichten des Assoziativspeichers
Pfeil 3.6.8 Die Arbeitsweise einer Hash-Tabelle *
Pfeil 3.7 Die Properties-Klasse
Pfeil 3.7.1 Properties setzen und lesen
Pfeil 3.7.2 Properties verketten
Pfeil 3.7.3 Hierarchische Eigenschaften
Pfeil 3.7.4 Eigenschaften auf der Konsole ausgeben *
Pfeil 3.7.5 Properties laden und speichern
Pfeil 3.7.6 Klassenbeziehungen: Properties und Hashtable *
Pfeil 3.8 Mit einem Iterator durch die Daten wandern
Pfeil 3.8.1 Die Schnittstelle Iterator
Pfeil 3.8.2 Der Iterator kann (eventuell auch) löschen
Pfeil 3.8.3 Einen Zufallszahleniterator schreiben
Pfeil 3.8.4 Iteratoren von Sammlungen, das erweiterte for und Iterable
Pfeil 3.8.5 Fail-Fast-Iterator und die ConcurrentModificationException
Pfeil 3.8.6 Die Schnittstelle Enumerator *
Pfeil 3.9 Algorithmen in Collections
Pfeil 3.9.1 Die Bedeutung von Ordnung mit Comparator und Comparable
Pfeil 3.9.2 Sortieren
Pfeil 3.9.3 Den größten und kleinsten Wert einer Collection finden
Pfeil 3.9.4 Nicht-änderbare Datenstrukturen, immutable oder nur-lesen?
Pfeil 3.9.5 Null Object Pattern und leere Sammlungen/Iteratoren zurückgeben
Pfeil 3.9.6 Mit der Halbierungssuche nach Elementen fahnden
Pfeil 3.9.7 Ersetzen, Kopieren, Füllen, Umdrehen, Rotieren *
Pfeil 3.9.8 Listen durchwürfeln *
Pfeil 3.9.9 Häufigkeit eines Elements *
Pfeil 3.9.10 Singletons *
Pfeil 3.9.11 nCopies() *
Pfeil 3.10 Spezielle thread-sichere Datenstrukturen
Pfeil 3.10.1 Wait-free-Algorithmen
Pfeil 3.10.2 Nebenläufiger Assoziativspeicher und die Schnittstelle ConcurrentMap
Pfeil 3.10.3 ConcurrentLinkedQueue
Pfeil 3.10.4 CopyOnWriteArrayList und CopyOnWriteArraySet
Pfeil 3.10.5 Wrapper zur Synchronisation
Pfeil 3.10.6 Blockierende Warteschlangen
Pfeil 3.10.7 ArrayBlockingQueue und LinkedBlockingQueue
Pfeil 3.10.8 PriorityBlockingQueue
Pfeil 3.11 Google Guava (aka Google Collections Library)
Pfeil 3.11.1 Beispiel Multi-Set und Multi-Map
Pfeil 3.11.2 Datenstrukturen aus Guava
Pfeil 3.11.3 Utility-Klassen von Guava
Pfeil 3.11.4 Prädikate
Pfeil 3.11.5 Transformationen
Pfeil 3.12 Die Klasse BitSet für Bitmengen *
Pfeil 3.12.1 Ein BitSet anlegen, füllen und erfragen
Pfeil 3.12.2 Mengenorientierte Operationen
Pfeil 3.12.3 Methodenübersicht
Pfeil 3.12.4 Primzahlen in einem BitSet verwalten
Pfeil 3.13 Zum Weiterlesen

Rheinwerk Computing - Zum Seitenanfang

3.3 Mengen (Sets)Zur nächsten Überschrift

Eine Menge ist eine (erst einmal) ungeordnete Sammlung von Elementen. Jedes Element darf nur einmal vorkommen. Für Mengen sieht die Java-Bibliothek die Schnittstelle java.util.Set vor. Beliebte implementierende Klassen sind:

  • HashSet: Schnelle Mengenimplementierung durch Hashing-Verfahren (dahinter steckt die HashMap)
  • TreeSet: Mengen werden durch balancierte Binärbäume realisiert, die eine Sortierung ermöglichen.
  • LinkedHashSet: Schnelle Mengenimplementierung unter Beibehaltung der Einfügereihenfolge
  • EnumSet: Eine spezielle Menge ausschließlich für Enum-Objekte
  • CopyOnWriteArraySet: Schnelle Datenstruktur für viele lesende Operationen

Abbildung

Abbildung 3.6: UML-Diagramm der Schnittstelle List


Rheinwerk Computing - Zum Seitenanfang

3.3.1 Ein erstes Mengen-BeispielZur nächsten ÜberschriftZur vorigen Überschrift

Das folgende Programm analysiert einen Text und erkennt Städte, die vorher in eine Datenstruktur eingetragen wurden. Alle Städte, die im Text vorkommen, werden gesammelt und später ausgegeben.

Listing 3.7: com/tutego/insel/util/set/WhereHaveYouBeen

package com.tutego.insel.util.set;

import java.text.BreakIterator;
import java.util.*;

public class WhereHaveYouBeen
{
public static String join( Iterable<?> iterable )
{
StringBuilder result = new StringBuilder();
for ( Object o : iterable )
{
if ( result.length() != 0 )
result.append( ", " );
result.append( o.toString() );
}
return result.toString();
}

public static void main( String[] args )
{
// Menge mit Städten aufbauen

Set<String> allCities = new HashSet<String>();
allCities.add( "Sonsbeck" );
allCities.add( "Düsseldorf" );
allCities.add( "Manila" );
allCities.add( "Seol" );
allCities.add( "Siquijor" );

// Menge für besuchte Städte aufbauen


Set<String> visitedCities = new TreeSet<String>();

// Satz parsen und in Wörter zerlegen. Alle gefundenen Städte
// in neue Datenstruktur aufnehmen
String sentence = "Von Sonsbeck fahre ich nach Düsseldorf und fliege nach Manila.";

BreakIterator iter = BreakIterator.getWordInstance();
iter.setText( sentence );

for ( int first = iter.first(), last = iter.next();
last != BreakIterator.DONE;
first = last, last = iter.next() )
{
String word = sentence.subSequence( first, last ).toString();
if ( allCities.contains( word ) )
visitedCities.add( word );
}

// Kleine Statistik

System.out.println( "Anzahl besuchter Städte: " + visitedCities.size() );
System.out.println( "Anzahl nicht besuchter Städte: " +
(allCities.size() visitedCities.size()) );
System.out.println( "Besuchte Städte: " + join( visitedCities ) );
Set<String> unvisitedCities = new TreeSet<String>( allCities );
unvisitedCities.removeAll( visitedCities );
System.out.println( "Unbesuchte Städte: " + join( unvisitedCities ) );
}
}

Insgesamt kommen drei Mengen im Programm vor:

  • allCities speichert alle möglichen Städte. Die Wahl fällt auf den Typ HashSet, da die Menge nicht sortiert sein muss, Nebenläufigkeit kein Thema ist und HashSet eine gute Zugriffszeit bietet.
  • Ein TreeSet visiteCities merkt sich die besuchten Städte. Auch dieses Set ist schnell, aber hat den Vorteil, dass es die Elemente sortiert hält. Das ist später hübsch in der Ausgabe.
  • Um alle nicht besuchten Städte herauszufinden, berechnet das Programm die Differenzmenge zwischen allen Städte und besuchten Städten. Es gibt in der Schnittstelle Set keine Methode, die das direkt macht, genau genommen gibt es keine Operation in Set, die den Rückgabetyp Set oder Collection hat. Also können wir nur mit einer Methode wie removeAll() arbeiten, die aus der Menge aller Städte die besuchten entfernt, um zu denen zu kommen, die noch nicht besucht wurden. Das »Problem« der removeAll()-Methode ist aber ihre zerstörerische Art – die Elemente werden genau aus der Menge gelöscht. Da die Originalmenge jedoch nicht verändert werden soll, kopieren wir alle Städte in einen Zwischenspeicher (unvisitedCities) und löschen aus diesem Zwischenspeicher, was die Originalmenge unangetastet lässt.

Rheinwerk Computing - Zum Seitenanfang

3.3.2 Methoden der Schnittstelle SetZur nächsten ÜberschriftZur vorigen Überschrift

Eine Mengenklasse deklariert neben Operationen für die Anfrage und das Einfügen von Elementen auch Methoden für Schnitt und Vereinigung von Mengen.

interface java.util.Set<E>
extends Collection<E>
  • boolean add(E o)
    Setzt o in die Menge, falls es dort noch nicht vorliegt. Liefert true bei erfolgreichem Einfügen.
  • boolean addAll(Collection<? extends E> c)
    Fügt alle Elemente von c in das Set ein und liefert true bei erfolgreichem Einfügen. Ist c ein anderes Set, so steht addAll() für die Mengenvereinigung.
  • void clear()
    Löscht das Set.
  • boolean contains(Object o)
    Ist das Element o in der Menge?
  • boolean containsAll(Collection<?> c)
    Ist c eine Teilmenge von Set?
  • boolean isEmpty()
    Ist das Set leer?
  • Iterator<E> iterator()
    Gibt einen Iterator für das Set zurück.
  • boolean remove(Object o)
    Löscht o aus dem Set, liefert true bei erfolgreichem Löschen.
  • boolean removeAll(Collection<?> c)
    Löscht alle Elemente der Collection aus dem Set und liefert true bei erfolgreichem Löschen.
  • boolean retainAll(Collection<?> c)
    Bildet die Schnittmenge mit c.
  • int size()
    Gibt die Anzahl der Elemente in der Menge zurück.
  • Object[] toArray()
    Erzeugt zunächst ein neues Feld, in dem alle Elemente der Menge Platz finden, und kopiert anschließend die Elemente in das Feld.
  • <T> T[] toArray(T[] a)
    Ist das übergebene Feld groß genug, dann werden alle Elemente der Menge in das Feld kopiert. Ist das Feld zu klein, wird ein neues Feld vom Typ T angelegt, und alle Elemente werden vom Set in das Array kopiert und zurückgegeben.

In der Schnittstelle Set werden die aus Object stammenden Methoden equals() und hashCode() mit ihrer Funktionalität bei Mengen in der API-Dokumentation präzisiert.

Hinweis

In einem Set gespeicherte Elemente müssen immutable bleiben. Einerseits sind sie nach einer Änderung vielleicht nicht wiederzufinden, und andererseits können Elemente auf diese Weise doppelt in der Menge vorkommen, was der Philosophie der Schnittstelle widerspricht.

Ein Element erneut hinzunehmen

Ist ein Element in der Menge noch nicht vorhanden, fügt add() es ein und liefert als Rückgabe true. Ist es schon vorhanden, macht add() nichts und liefert false (das ist bei einer Map anders, denn dort überschreibt put() den Schlüssel). Ob ein hinzuzufügendes Element mit einem existierenden in der Menge übereinstimmt, bestimmt die equals()-Methode, also die Gleichheit und nicht die Identität:

Listing 3.8: com/tutego/insel/util/set/HashSetDoubleAdd.java, main()

Set<Point> set = new HashSet<Point>();
Point p1 = new Point(), p2 = new Point();
System.out.println( set.add(p1) ); // true
System.out.println( set.add(p1) ); // false
System.out.println( set.add(p2) ); // false
System.out.println( set.contains(p1) ); // true
System.out.println( set.contains(p2) ); // true

Rheinwerk Computing - Zum Seitenanfang

3.3.3 HashSetZur nächsten ÜberschriftZur vorigen Überschrift

Ein java.util.HashSet verwaltet die Elemente in einer schnellen hash-basierten Datenstruktur. Dadurch sind die Elemente schnell einsortiert und schnell zu finden. Falls eine Sortierung vom HashSet nötig ist, müssen die Elemente nachträglich umkopiert und dann sortiert werden.

class java.util.HashSet<E>
extends AbstractSet<E>
implements Set<E>, Cloneable, Serializable
  • HashSet()
    Erzeugt ein leeres HashSet-Objekt.
  • HashSet(Collection<? extends E> c)
    Erzeugt aus der Sammlung c ein neues unsortiertes HashSet.
  • HashSet(int initialCapacity)
  • HashSet(int initialCapacity, float loadFactor)
    Die beiden Konstruktoren sind zur Optimierung gedacht und werden bei der HashMap im Abschnitt »Der Füllfaktor und die Konstruktoren« in Abschnitt 3.6.8 genauer erklärt – HashSet basiert intern auf der HashMap.

Rheinwerk Computing - Zum Seitenanfang

3.3.4 TreeSet – die sortierte MengeZur nächsten ÜberschriftZur vorigen Überschrift

Die Klasse java.util.TreeSet implementiert ebenfalls wie HashSet die Set-Schnittstelle, verfolgt aber eine andere Implementierungsstrategie. Ein TreeSet verwaltet die Elemente immer sortiert (intern werden die Elemente in einem balancierten Binärbaum gehalten). Speichert TreeSet ein neues Element, so fügt TreeSet das Element automatisch sortiert in die Datenstruktur ein. Das kostet zwar etwas mehr Zeit als ein HashSet, doch ist diese Sortierung dauerhaft. Daher ist es auch nicht zeitaufwändig, alle Elemente geordnet auszugeben. Die Suche nach einem einzigen Element ist aber etwas langsamer als im HashSet. Der Begriff »langsamer« muss jedoch relativiert werden: Die Suche ist logarithmisch und daher nicht wirklich »langsam«. Beim Einfügen und Löschen muss bei bestimmten Konstellationen eine Reorganisation des Baumes in Kauf genommen werden, was die Einfüge-/Löschzeit verschlechtert. Doch auch beim Re-Hashing gibt es diese Kosten, die sich dort jedoch durch die passende Startgröße vermeiden lassen.

class java.util.TreeSet<E>
extends AbstractSet<E>
implements NavigableSet<E>, Cloneable, Serializable
  • TreeSet()
    Erzeugt ein neues, leeres TreeSet.
  • TreeSet(Collection<? extends E> c)
    Erzeugt ein neues TreeSet aus der gegebenen Collection.
  • TreeSet(Comparator<? super E> c)
    Erzeugt ein leeres TreeSet mit einem gegebenen Comparator, der für die Sortierung der internen Datenstruktur die Vergleiche übernimmt.
  • TreeSet(SortedSet<E> s)
    Erzeugt ein neues TreeSet und übernimmt alle Elemente von s und auch die Sortierung von s. (Einen Konstruktor mit NavigableSet gibt es nicht.)

Durch die interne sortierte Speicherung gibt es zwei ganz wichtige Bedingungen:

  • Die Elemente müssen sich vergleichen lassen. Kommen zum Beispiel Player-Objekte in das TreeSet, aber implementiert Player nicht die Schnittstelle Comparable, löst TreeSet eine Ausnahme aus, da TreeSet nicht weiß, in welcher Reihenfolge die Spieler stehen.
  • Die Elemente müssen vom gleichen Typ sein. Wie sollte sich ein Kirchen-Objekt mit einem Staubsauger-Objekt vergleichen lassen?
Beispiel

Sortiere Strings in eine Menge ein, wobei die Groß-/Kleinschreibung und vorangestellter bzw. nachfolgender Weißraum keine Rolle spielt. Anders gesagt: Wörter sollen auch dann als gleich angesehen werden, wenn sie sich in der Groß-/Kleinschreibweise unterscheiden oder etwa Leerzeichen am Anfang und Ende besitzen:

Set<String> set = new TreeSet<String>( new Comparator<String>() {
@Override public int compare( String s1, String s2 ) {
return String.CASE_INSENSITIVE_ORDER.compare( s1.trim(), s2.trim() );
}
}
);

Collections.addAll( set, "xxx ", " XXX", "tang", " xXx", " QUEEF " );
System.out.println( set ); // [ QUEEF , tang, xxx ]

Die Methode equals() und die Vergleichsmethoden

Die Methode equals() spielt für Datenstrukturen eine große Rolle. Beim TreeSet ist das anders, denn es nutzt zur Einordnung einen externen Comparator bzw. die compareTo()-Eigenschaft, wenn die Elemente Comparable sind. Gibt die Vergleichsmethode 0 zurück, so sind die Elemente gleich, und gleiche Elemente sind in der Menge nicht erlaubt – equals() wird dabei nicht gefragt!

Nehmen wir als Beispiel den Comparator aus dem vorangehenden Beispiel für String-Objekte, der unabhängig von der Groß-/Kleinschreibung und Weißraum vergleicht. Dann sind laut equals() von die Strings "xxx " und " XXX" sicherlich nicht gleich, der Comparator würde aber Gleichheit anzeigen. Dies führt dazu, dass tatsächlich nur eines der beiden Objekte in das TreeSet kommt, und eine Anfrage nach einem Comparator-gleichem Objekt daher das Element liefert:

Set<String> set = new TreeSet<String>( new Comparator<String>() { ... } );
Collections.addAll( set, "xxx ", " XXX", "tang", " xXx", " QUEEF " );
System.out.println( set.contains( " XXX " ) ); // true

Rheinwerk Computing - Zum Seitenanfang

3.3.5 Die Schnittstellen NavigableSet und SortedSetZur nächsten ÜberschriftZur vorigen Überschrift

TreeSet implementiert die Schnittstelle NavigableSet und bietet darüber Methoden, um insbesondere zu einem gegebenen Element das nächsthöhere/-kleinere zu liefern. Somit sind auf Mengen nicht nur die üblichen Anfragen über Mengenzugehörigkeit denkbar, sondern auch Anfragen wie »Gib mir das Element, das größer oder gleich einem gegebenen Element ist«.

Folgendes Beispiel reiht in ein TreeSet drei Calendar-Objekte ein – die Klasse Calendar implementiert Comparable<Calendar>. Die Methoden lower(), ceiling(), floor() und higher() wählen aus der Menge das angefragte Objekt aus:

Listing 3.9: com/tutego/insel/util/set/SortedSetDemo.java

NavigableSet<Calendar> set = new TreeSet<Calendar>();
set.add( new GregorianCalendar(2007, Calendar.MARCH, 10) );
set.add( new GregorianCalendar(2007, Calendar.MARCH, 12) );
set.add( new GregorianCalendar(2007, Calendar.APRIL, 12) );

Calendar cal1 = set.lower( new GregorianCalendar(2007, Calendar.MARCH, 12) );
System.out.printf( "%tF%n", cal1 ); // 2007-03-10

Calendar cal2 = set.ceiling( new GregorianCalendar(2007, Calendar.MARCH, 12) );
System.out.printf( "%tF%n", cal2 ); // 2007-03-12

Calendar cal3 = set.floor( new GregorianCalendar(2007, Calendar.MARCH, 12) );
System.out.printf( "%tF%n", cal3 ); // 2007-03-12

Calendar cal4 = set.higher( new GregorianCalendar(2007, Calendar.MARCH, 12) );
System.out.printf( "%tF%n", cal4 ); // 2007-04-12

Eine Methode wie tailSet() ist insbesondere bei Datumsobjekten sehr praktisch, da sie alle Zeitpunkte liefern kann, die nach einem Startdatum liegen.

Seit Java 6 implementiert TreeSet statt SortedSet direkt die Schnittstelle NavigableSet, die ihrerseits SortedSet erweitert. Insgesamt bietet NavigableSet 15 Operationen, wobei sie aus SortedSet die Methoden headSet(), tailSet() und subSet() überschreibt, um eine überladene Version der Methoden anzubieten, die die Grenzen exklusiv oder inklusiv erlauben.

interface java.util.NavigableSet<E>
extends SortedSet<E>
  • SortedSet<E> headSet(E toElement)
  • SortedSet<E> tailSet(E fromElement)
    Liefert eine Teilmenge von Elementen, die echt kleiner/größer als toElement/fromElement sind.
  • NavigableSet<E> headSet(E toElement, boolean inclusive)
  • NavigableSet<E> tailSet(E fromElement, boolean inclusive)
    Bestimmt gegenüber den oberen Methoden zusätzlich, ob das Ausgangselement zur Ergebnismenge gehören darf.
  • SortedSet<E> subSet(E fromElement, E toElement)
    Liefert eine Teilmenge im gewünschten Bereich.
  • E pollFirst()
  • E pollLast()
    Holt und entfernt das erste/letzte Element. Die Rückgabe ist null, wenn das Set leer ist.
  • E higher(E e)
  • E lower(E e)
    Liefert das folgende/vorangehende Element im Set, das echt größer/kleiner als E ist, oder null, falls ein solches Element nicht existiert.
  • E ceiling(E e)
  • E floor(E e)
    Liefert das folgende/vorangehende Element im Set, das größer/kleiner oder gleich E ist, oder null, falls ein solches Element nicht existiert.
  • Iterator<E> descendingIterator()
    Liefert die Elemente in umgekehrter Reihenfolge.

Aus der Schnittstelle SortedSet übernimmt NavigableSet drei Operationen:

interface java.util.SortedSet<E>
extends Set<E>
  • E first()
    Liefert das erste Element in der Liste.
  • E last()
    Liefert das größte Element.
  • Comparator<? super E> comparator()
    Liefert den mit der Menge verbundenen Comparator. Die Rückgabe kann null sein, wenn die Objekte sich mit Comparable selbst vergleichen können.

Anders als HashSet liefert der Iterator beim TreeSet die Elemente aufsteigend sortiert. Davon profitieren auch die beiden toArray()-Methoden – implementiert in AbstractCollection –, da sie den Iterator nutzen, um ein sortiertes Feld zurückzugeben.


Rheinwerk Computing - Zum Seitenanfang

3.3.6 LinkedHashSetZur vorigen Überschrift

Ein LinkedHashSet vereint die Reihenfolgentreue einer Liste und die hohe Performance für Mengenoperationen vom HashSet. Dabei bietet die Klasse keine Listen-Methoden wie first() oder get(index), sondern ist eine Implementierung ausschließlich der Set-Schnittstelle, in der der Iterator die Elemente in der Einfüge-Reihenfolge liefert:

Listing 3.10: com/tutego/insel/util/set/LinkedHashSetDemo.java, main()

Set<Integer> set = new LinkedHashSet<Integer>(
Arrays.asList( 9, 8, 7, 6, 9, 8 )
);

for ( Integer i : set )
System.out.print( i + " " ); // 9 8 7 6

System.out.printf( "%n%s", set ); // [9, 8, 7, 6]

Da ein Set nur jedes Element einmal beinhalten kann, bekommen wir als Ergebnis jedes Element nur eimal, aber gleichzeitig geht die Reihenfolge des Einfügens nicht verloren. Der Iterator liefert die Elemente genau in der Einfügereihenfolge.



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
Neuauflage: Java SE 8 Standard-Bibliothek
Neuauflage: Java SE 8 Standard-Bibliothek
Jetzt bestellen


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

 Buchempfehlungen
Zum Katalog: Professionell entwickeln mit Java EE 7






 Professionell
 entwickeln mit
 Java EE 7


Zum Katalog: Java ist auch eine Insel






 Java ist auch
 eine Insel


Zum Katalog: Einstieg in Eclipse






 Einstieg in Eclipse


Zum Katalog: Einstieg in Java






 Einstieg in Java


 Shopping
Versandkostenfrei bestellen in Deutschland und Österreich
InfoInfo




Copyright © Rheinwerk Verlag GmbH 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.


Nutzungsbestimmungen | Datenschutz | Impressum

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