12.10 Algorithmen in Collections

Um Probleme in der Informatik zu lösen, ist die Wahl einer geeigneten Datenstruktur nur der erste Schritt. Im zweiten Schritt müssen Algorithmen implementiert werden. Da viele Algorithmen immer wiederkehrende (Teil-)Probleme lösen, hilft uns auch hier die Java-Bibliothek mit einigen Standardalgorithmen weiter. Dazu zählen etwa Funktionen zum Sortieren und Suchen in Containern und zum Füllen von Containern. Einige Algorithmen sind Teil der jeweiligen Datenstruktur selbst, andere wiederum befinden sich in der Extraklasse java.util.Collections. Diese Utility-Klasse, die wir nicht mit dem Interface Collection verwechseln dürfen, bietet Funktionen, um zum Beispiel

• Listen zu sortieren, zu mischen, umzudrehen, zu kopieren und zu füllen;

• Elemente nach der Halbierungssuche zu finden;

• die Anzahl equals()-gleicher Elemente zu ermitteln;

• Extremwerte zu bestimmen;

• Elemente in einer Liste zu ersetzen;

• Wrapper um existierende Datenstrukturen zu legen.

Viele Algorithmen sind nur auf List-Objekten definiert, denn der einfache Typ Collection reicht oft nicht aus. Das ist nicht erstaunlich, denn wenn ein Container keine Ordnung definiert, kann er nicht sortiert werden. Auch die binäre Suche erfordert Container mit einer impliziten Reihenfolge der Elemente. Nur Min- und Max-Funktionen arbeiten auf allgemeinen Collection-Objekten. Nutzt die Collections-Klasse keine List-Objekte, arbeitet sie doch nur mit Collection-Objekten und nicht mit Iteratoren.

Alle Funktionen sind statisch, sodass Collections eine Utility-Klasse wie Math ist. Ein Exemplar von Collections lässt sich nicht anlegen – der Konstruktor ist privat.

List<String> v = new ArrayList<String>(); 
Collections.addAll( v, "Bube", "Dame", "König", "Ass" ); 
Collections.shuffle( v ); 
System.out.println( v );  // z.B. [König, Ass, Bube, Dame]

12.10.1 Ersetzen, Kopieren, Füllen, Umdrehen, Rotieren, Durchmischen

Mit replaceAll(List<T> list, T oldVal, T newVal) werden die Elemente einer Liste gesucht und durch einen neuen Wert ersetzt. Die Funktion copy(List<? super T> dest, List<? extends T> src) kopiert alle Elemente von src in die Liste dest und überschreibt dabei solche, die eventuell schon an den entsprechenden Positionen der Zielliste liegen. Die Zielliste muss mindestens so lang wie die Quellliste sein, andernfalls wird eine IndexOutOfBoundsException ausgelöst. Hat das Ziel weitere Elemente, ist das egal, weil copy() diese nicht antastet.

Die Funktion fill(List<? super T> list, T obj) belegt eine Liste in linearer Zeit mit lauter identischen Elementen. Das heißt aber, dass es immer das gleiche Objekt ist, das an allen Positionen sitzt. Es ist die Frage, ob dies immer so sinnvoll und nützlich ist. Die Funktion reverse(List<?> list) dreht die Reihenfolge der Elemente in einer Liste um. Die Laufzeit ist linear zur Anzahl der Elemente. Und rotate(List<?> list, int distance) bewegt die Elemente um distance Positionen.

List<String> list = new ArrayList<String>( 
  Arrays.asList( new DateFormatSymbols().getShortMonths() ) ); 
System.out.println( list );  // [Jan, Feb, Mrz, Apr, Mai, Jun, Jul, Aug, Sep,  
                             // Okt, Nov, Dez, ] 
Collections.rotate( list, 2 ); 
System.out.println( list );  // [Dez, , Jan, Feb, Mrz, Apr, Mai, Jun, Jul, Aug,  
                             // Sep, Okt, Nov] 
Collections.rotate( list, –2 ); 
System.out.println( list );  // [Jan, Feb, Mrz, Apr, Mai, Jun, Jul, Aug, Sep,  
                             // Okt, Nov, Dez, ]

• static <T> void copy( List<? super T> dest, List<? extends T> src )
  Kopiert alle Elemente von src nach dest. Ist dest zu klein, gibt es eine IndexOutOfBoundsException. Ist die Zielliste größer als die Quellliste, lässt copy() die letzten Elemente von dest unangetastet.

• static <T> void fill( List<? super T> list, T obj )
  Füllt die Liste list mit dem Element obj. Vorhandene Elemente werden mit obj überschrieben.

• static boolean replaceAll( List<T> list, T oldVal, T newVal )
  Sucht nach dem Auftreten von oldVal über equals() in der Liste und ersetzt die gefundenen Elemente durch newVal. Die Größe der Liste ändert das nicht. Die Rückgabe ist true, wenn mindestens ein Element ersetzt wurde.

• static void reverse( List<?> list )
  Kehrt die Reihenfolge der Elemente in der Liste um.

• static void rotate( List<?> list, int distance )
  Bewegt die Elemente der Liste um distance Positionen.

• static void shuffle( List<?> list )
  Würfelt die Elemente der Liste durcheinander. Dafür wird ein Standard-Generator für Zufallszahlen verwendet.

• static void shuffle( List<?> list, Random rnd )
  Würfelt die Elemente der Liste durcheinander und benutzt dafür den Random-Generator rnd.

12.10.2 Mit der Halbierungssuche nach Elementen fahnden

Die Collection-Klassen enthalten mit contains(Object) eine Methode, die entweder true oder false zurückgibt, wenn ein Element gefunden wurde oder nicht. Die Position eines Elements in einer List liefert die Objektfunktion indexOf(Object). Ist die Liste sortiert, lässt sich eine Suche schneller durch das Halbierungsverfahren durchführen, was Java durch die Funktion binarySearch() in den Klassen Arrays und Collections bietet.

Der Halbierungssuche (auch binäre Suche, engl. binary search) liegt eine einfache Idee zugrunde: Wir beginnen die Suche nach einem Objekt in der Mitte der Liste. Ist das gesuchte Objekt kleiner als das mittlere Listenelement, dann muss es sich links von der Mitte befinden, andernfalls rechts. Die Liste wird also in zwei gleich große Abschnitte unterteilt, von denen nur einer weiter durchsucht werden muss. Diesen Vorgang wiederholen wir so oft, bis das Element gefunden wurde. Auf diese Weise ist die Suche sehr schnell und benötigt höchstens log(n) Listenhalbierungen bei einer Liste mit n Elementen. Es ist jedoch gut möglich, dass das gesuchte Element in der Liste nicht vorkommt. Dieser Fall wird erkannt, wenn durch das wiederholte Halbieren der Liste ein Listenabschnitt mit nur einem Element entstanden ist. Stimmt dieses eine Element nicht mit dem gesuchten Objekt überein, ist das Ergebnis der Suche ein »Nicht gefunden«. Die Suche nach einem nicht vorhandenen Element ist geringfügig aufwändiger als eine erfolgreiche Suche, benötigt aber ebenfalls nur logarithmisch viele Halbierungsschritte. Enthält die Liste mehrere gleiche Elemente, dann ist nicht gesichert, welches davon bei der Suche gefunden wird. Besteht die Liste etwa aus zehn Zahlen mit dem Wert 22, dann liefert der Algorithmus das fünfte Element.

Die statische Methode binarySearch() nimmt ein Feld oder eine Liste als Argument und liefert folgende Rückgabe:

• Ist das Element in der Liste, so liefert binarySearch() die Position des Objekts.

• Gibt es ein Element mehrmals in der Liste, wird irgendein Index zurückgegeben.

• Wurde kein passendes Element gefunden, ist das Ergebnis eine negative Zahl und beschreibt recht trickreich die Stelle, an der der Algorithmus den letzten Vergleich durchgeführt hat.

• Ist die Liste nicht sortiert, kann die Halbierungssuche nicht richtig funktionieren, da sie möglicherweise in die falsche Richtung läuft und das Element sich in der anderen Hälfte der unterteilten Liste befindet. Eine nicht sortierte Liste lässt sich mit sort() sortieren. Es ist aber immer noch schneller, in einer unsortierten Liste zu suchen – Laufzeit O(n) –, als erst die Liste zu sortieren – Laufzeit O(n log(n)) – und darin mit der Halbierungssuche zu suchen – Laufzeit O(log(n)). Wenn ausreichend viele Suchvorgänge nacheinander in der gleichen Liste durchzuführen sind, lohnt sich das vorherige Sortieren der Liste natürlich.

Ist das gesuchte Element nicht in der Liste, so ist der Rückgabewert (–Einfügepunkt –1), und der Einfügepunkt ist die Position in der Liste, an die der Wert gemäß Sortierung eingesetzt werden kann. Wir können folgende Programmzeilen verwenden, um einen nicht gefundenen Wert gleich passend einzufügen:

int pos = Collections.binarySearch( l, key ); 
if ( pos < 0 ) 
  l.add( -pos – 1, key );

Von binarySearch() gibt es zwei Varianten: Die erste Funktion nimmt an, dass die Werte in ihrer natürlichen Form sortiert sind. Die zweite arbeitet wieder mit einem Comparator-Objekt zusammen.

• static <T extends Object & Comparable<? super T>> int binarySearch( List<? extends T> list, T key ) Sucht ein Element in der Liste. Gibt die Position zurück oder einen Wert kleiner 0, falls kein passendes Element in der Liste ist.

• static <T> int binarySearch( List<? extends T> list, T key, Comparator<? super T> c ) Sucht ein Element mit Hilfe des Comparator-Objekts in der Liste. Gibt die Position oder einen Wert kleiner 0 zurück, falls kein passendes Element in der Liste ist.

12.10.3 Nicht-änderbare Datenstrukturen

Diverse Collections.unmodifiableXXX()-Funktionen legen eine Hülle um eine Datenstruktur und lassen nur die Lese-Methoden zum Container durch, blockieren aber Modifizierungsbefehle wie add() durch eine UnsupportedOperationException.

12.10.4 Häufigkeit eines Elements

Collections.frequency(Collection<?>, Object) gibt die Anzahl der Elemente zurück, die zu einem Suchobjekt equals()-gleich sind.

String s = "Hallo :-) Suppi :-)"; 
int i = Collections.frequency( Arrays.asList(s.split("\\s")), ":-)" ); 
System.out.println( i );    // 2

• static int frequency( Collection<?> c, Object o )
  Liefert die Anzahl der Elemente, die mit o gleich sind. Genauer gesagt muss für alle Elemente e aus der Collection c gelten: o == null ? e == null : o.equals(e). Ist c null, folgt eine NullPointerException.

12.10.5 nCopies()

Die statische Funktion nCopies() erzeugt eine Liste mit der gewünschten Anzahl von Elementen aus einem Objekt.

• static <T> List<T> nCopies( int n, T o )
  Erzeugt eine unveränderbare Liste mit n Elementen von o.

Die Liste besteht nicht aus einer Anzahl Kopien des Elements (mit clone()), sondern aus einer Liste, die ein Element immer wiederholt. Daher sind auch nur Leseoperationen wie get() oder contains() erlaubt, doch keine Veränderungen. Infolgedessen ist der Einsatzbereich der Liste beschränkt, jener der Funktion aber nicht. Denn die Elemente der Liste können als Ausgang für eine modifizierbare Datenstruktur gelten, der sich eine Liste übergeben lässt. Das gilt zum Beispiel für eine ArrayList, die im Konstruktor eine andere Liste akzeptiert, der sie die Werte entnimmt.

List<String> list = new ArrayList<String>( Collections.nCopies(10, "") ); 
list.addAll( Collections.nCopies(2, ".") ); 
System.out.println( list );   // [, , , , , , , , , , ., .]

Ein Collections.nCopies(1, value) entspricht einem Singleton, für das Java aber eine eigene Funktion bereithält.

12.10.6 Singletons

Singletons sind Objekte, die genau ein Exemplar realisieren. Die Klasse Collections bietet drei Funktionen, die ein gegebenes Element in eine immutable Menge, Liste oder einen Assoziativspeicher setzt:

• static <T> Set<T> singleton( T o )

• static <T> List<T> singletonList( T o )

• static <K,V> Map<K,V> singletonMap( K key, V value )

Auf den ersten Blick erscheinen die Funktionen ziemlich unnütz. Sie sind jedoch immer dann nützlich, wenn Methoden vorhanden sind, die zwar Sammlungen annehmen – auch wenn sie nur aus einem Element bestehen –, aber mit einzelnen Elementen nicht viel anfangen können.

Löschen von Elementen in einer Sammlung

Die Collection-Klassen bieten bisher keine Lösung zum Löschen aller Vorkommen eines Elements. Zwar gibt es die Collection-Methode remove(Object), doch löscht diese nur das erste Vorkommen. Um alle Vorkommen zu löschen, ist entweder eine Schleife zu schreiben oder singleton() zu nutzen. Uns hilft beim Löschen aller Elemente die Methode removeAll(Collection), doch erwartet sie als Argument eine Collection, die wir ja gerade durch singleton() bekommen, da ein Set eine Erweiterung von Collection ist. Auf diese Weise entfernt unsere Funktion removeAll(Collection c, Object o) jedes Vorkommen eines Objekts aus der Datenstruktur.

Listing 12.29 com/tutego/insel/util/SingletonDemo.java, removeAll()

public static void removeAll( Collection<?> c, Object o ) 
{ 
  c.removeAll( Collections.singleton(o) ); 
}

Ihr Kommentar