Java Collections Framework (JCF)

Java Collections Framework (JCF)
Algorithmen & Datenstrukturen
Bachelor Medieninformatik
Fachbereich DCSM
FH Wiesbaden – University of Applied Sciences
Thomas Frenken
[email protected]
Java Collections Framework (JCF)
Inhaltsverzeichnis
1. Das Java Collections Framework
Definition und Abgrenzung
2. Interfaces des JCF
Von Collections, Sets, Lists, Queues und Maps
3. Implementierung und Algorithmen
Klassen und ihr praktischer Einsatz
4. Weiterführende Themen
Um sich erinnern zu können
5. Zusammenfassung
Thomas Frenken
2 / 23
Java Collections Framework (JCF)
Das Java Collections Framework
... ist ein Collections Framwork (ach ne ;o), in C++ nennt sich das CF Standard
●
Template Library (STL)
Collections:
●
Gruppiert gleichartige Objekte (Container)
●
(Collection) Framework:
●
●
Bietet einheitliche Struktur für Speicherung und Manipulation an
●
Besteht aus:
●
Interfaces ≙ Abstrakte Datentypen (Schnittstelle unabhängig von
Implementierung)
●
Implementierungen ≙ Konkrete Datentypen (implementieren Interfaces)
●
Algorithmen: Sinnvolle Operationen, polymorph in ihrer Vererbungshierarchie
Thomas Frenken
3 / 23
Java Collections Framework (JCF)
Das Java Collections Framework
Warum Framework verwenden, wenn man es selber machen kann?
●
●
Weniger Arbeitsaufwand: Sobald man versteht, was man tut, darf man Arbeit
sparen
●
Effektivere Programme: Von Experten geschrieben (fehlerlos) und auf die
Sprache Java optimiert (schnell und ressourcenschonend)
●
Erleichtert Umstieg: Andere Programmier- / Skriptsprachen haben ähnliche
Frameworks (Implementierung anders, Schnittstellen ähnlich)
●
Erleichtert Austauschbarkeit: Alle verwenden diesen Standard, verbindet
verschiedene Bibliotheken
●
Erleichtert Entwicklung neuer Collections
Thomas Frenken
4 / 23
Java Collections Framework (JCF)
Interfaces des JCF
●
Zwei Vererbungshierarchien
(alle Interfaces generisch)
●
Collection: Allgemeinste Form eines
Containers, schreibt die grundlegenden
Operationen vor (i.d.R. nicht implementieren, sondern Subklasse)
●
Set: Ansammlung von eindeutigen (keine Duplikate), zunächst ungeordneten
Elementen
●
List: Ansammlung geordneter, nicht eindeutiger Elemente (Sequenz), Index-Zugriff
●
Queue: Warteschlagen (auf semantischer Ebene unterschieden)
●
Map: Ordnet Werte einem Schlüssel zu, Schlüssel eindeutig, Werte nicht, keine
garantierte Reihenfolge
Thomas Frenken
5 / 23
Java Collections Framework (JCF)
Interfaces des JCF - Collection
●
Interface-Definition
public interface Collection<E> extends Iterable<E> {
// Basic operations
int size();
boolean isEmpty();
boolean contains(Object element);
boolean add(E element);
//optional
boolean remove(Object element); //optional
Iterator<E> iterator();
// Bulk operations
boolean containsAll(Collection<?> c);
boolean addAll(Collection<? extends E> c); //optional
boolean removeAll(Collection<?> c);
//optional
boolean retainAll(Collection<?> c);
//optional
void clear();
//optional
// Array operations
Object[] toArray();
<T> T[] toArray(T[] a);
Umgekehrt: List<T> Arrays.asList(T[] a)
}
●
Optionale Methoden müssen, falls sie nicht ausimplementiert werden, eine
OperationNotSupported-Exception werfen
Thomas Frenken
6 / 23
Java Collections Framework (JCF)
Interfaces des JCF - Collection
●
Über Collections iterieren
●
Der Iterator ist verwendbar auf allen Klassen, die das Interface Iterable
implementieren, also auf ALLEN Klassen der Collection- und auch der Map-Hierarchie
List<String> stringList = new LinkedList<String>();
stringList.add("...");
Iterator<String> it = stringList.iterator();
while (it.hasNext())
{
String student = it.next();
System.out.println("Name: "+student);
}
●
Während des Iterierens nur im Notfall Elemente
entfernen und auch nur, falls die optionale
Methode remove implementiert ist
Thomas Frenken
//oder mit foreach
for (String student: stringList)
{
...
}
public interface Iterator<E> {
boolean hasNext();
E next();
void remove(); //optional
}
7 / 23
Java Collections Framework (JCF)
Interfaces des JCF - Set
●
Interface-Definition (gleich zu Collection), fügt Konvention keiner doppelten Elemente
hinzu
●
Sub-Interface SortedSet
erlaubt es, Werte zu
ordnen
public interface Set<E> extends Collection<E> {
// Basic operations
int size();
boolean isEmpty();
boolean contains(Object element);
boolean add(E element);
//optional
boolean remove(Object element); //optional
Iterator<E> iterator();
// Bulk operations
boolean containsAll(Collection<?> c);
boolean addAll(Collection<? extends E> c); //optional
boolean removeAll(Collection<?> c);
//optional
boolean retainAll(Collection<?> c);
//optional
void clear();
//optional
// Array Operations
Object[] toArray();
<T> T[] toArray(T[] a);
}
Thomas Frenken
8 / 23
Java Collections Framework (JCF)
Interfaces des JCF - List
●
Interface-Definition, fügt im Wesentlichen Zugriff via Index und Ordnung hinzu
public interface List<E> extends Collection<E> {
// Positional access
E get(int index);
E set(int index, E element);
//optional
boolean add(E element);
//optional
void add(int index, E element); //optional
E remove(int index);
//optional
boolean addAll(int index,
Collection<? extends E> c); //optional
// Search
int indexOf(Object o);
int lastIndexOf(Object o);
// Iteration
ListIterator<E> listIterator();
ListIterator<E> listIterator(int index);
// Range-view
List<E> subList(int from, int to);
}
Thomas Frenken
9 / 23
Java Collections Framework (JCF)
Interfaces des JCF - List
●
ListIterator, trägt Ordnung in Liste Rechnung (≙ doppelt verkettete Liste)
public interface ListIterator<E> extends Iterator<E> {
boolean hasNext();
E next();
boolean hasPrevious();
E previous();
int nextIndex();
int previousIndex();
void remove(); //optional
void set(E e); //optional
void add(E e); //optional
}
ListIterator<String> it = stringList.listIterator();
//Vorwärts ausgeben
while (it.hasNext())
System.out.println("Vorwärts: "+it.nextIndex()+" -> "+it.next());
//Rückwärts ausgeben
while (it.hasPrevious())
System.out.println("Rückwärts: "+it.previousIndex()+" -> "+it.previous());
Thomas Frenken
10 / 23
Java Collections Framework (JCF)
Interfaces des JCF - Queue
●
Interface-Definition
public interface Queue<E> extends Collection<E> {
E element();
boolean offer(E e);
E peek();
E poll();
E remove();
}
●
Standard-Ordnung FIFO (kann aber über Comparator-Interface verändert werden)
●
Jede Methode zweimal, eine Variante wirft Fehler, andere liefert Standard-Wert
Thomas Frenken
11 / 23
Java Collections Framework (JCF)
Interfaces des JCF - Map
●
Interface-Definition
●
Sub-Interface SortedMap erlaubt,
public interface Map<K,V> {
// Basic operations
V put(K key, V value);
V get(Object key);
V remove(Object key);
boolean containsKey(Object key);
boolean containsValue(Object value);
int size();
boolean isEmpty();
Schlüssel oder Elemente zu
ordnen
// Bulk operations
void putAll(Map<? extends K, ? extends V> m);
void clear();
// Collection Views
public Set<K> keySet();
public Collection<V> values();
public Set<Map.Entry<K,V>> entrySet();
// Interface for entrySet elements
public interface Entry {
K getKey();
V getValue();
V setValue(V value);
}
}
Thomas Frenken
12 / 23
Java Collections Framework (JCF)
Implementierung und Algorithmen
JCF bietet eine Reihe von Implementierung für verschiedene Zwecke
●
●
General-Purpose: Implementierung für den alltäglichen Gebrauch (nicht
synchronized, also nicht thread-safe)
●
Special-Purpose: Implementierung getrimmt auf bestimmte Fähigkeiten (werden
selten gebraucht)
●
Concurrent: Synchronized, daher thread-safe, aber single-thread Performance
niedriger (noch seltener gebraucht)
●
Wrapper: Zusatzfunktionalität nach dem Decorator-Pattern (manchmal nützlich)
●
...
●
Abstract: Abstrakte
Klassen für Eigenimplementierungen
Thomas Frenken
13 / 23
Java Collections Framework (JCF)
Implementierung und Algorithmen – Interface vs. Implementierung
Wann immer möglich gegen Interfaces implementieren (so allgemein wie möglich, so
●
spezifisch wie möglich)
Warum?
●
●
Einheitliche Schnittstelle, erlaubt Austauschbarkeit
●
Kapselung und Geheimnisprinzip
●
Erleichtert Arbeit im Team
ArrayList<String> meineListe = new ArrayList<String>();
//Elemente ans Ende einfügen O(1)
meineListe.add("Student1");
meineListe.add("Student2");
meineListe.add("Student3");
//teuer, weil Aufschieben O(n)
meineListe.set(0, "Student4");
List<String> meineListe = new LinkedList<String>();
//Elemente ans Ende anfügen O(1), mehr Speicher
meineListe.add("Student1");
...
//optimiert, daher O(1)
meineListe.set(0, "Student4");
//und nu? Geloost!
BOO! BOO! BOO!
Thomas Frenken
YEAH! YEAH! YEAH!
14 / 23
Java Collections Framework (JCF)
Implementierung und Algorithmen - Set
Drei General-Purpose Implementierung:
●
●
HashSet: Eine dynamische Hashtabelle, O(1) für Standard-Operationen, StandardKapazität 16, erweiterbar sich selbstständig (Achtung teuer), je nach load factor,
keine garantierte Ordnung (meist entsprechend Object.hashCode())
●
LinkedHashSet: Wie HashSet, aber alle Einträge über eine LinkedList verbunden,
daher Iterierung in Einfügereihenfolge (sofern nicht verändert) möglich
●
TreeSet: Ein Baum, garantiert Ordnung und O(log n) für die meisten
Operationen, implementiert auf Basis von Rot-Schwarz-Bäumen
●
Zwei Special-Purpose Implementierung: EnumSet und CopyOnWriteArraySet
Thomas Frenken
15 / 23
Java Collections Framework (JCF)
Implementierung und Algorithmen - List
Zwei General-Purpose Implementierung:
●
●
ArrayList: Ein Array mit Listenfunktionalität, schneller Index-Zugriff (O(1)), Löschen
und Einfügen an Index dafür O(n)
●
LinkedList: Schnell beim Einfügen und Löschen (O(1)), dafür langsamer IndexZugriff (O(n)) (implementiert auch Queue-Interface), Speicherverbrauch
●
Eine Special-Purpose Implementierungen: CopyOnWriteArrayList
Thomas Frenken
16 / 23
Java Collections Framework (JCF)
Implementierung und Algorithmen - Map
Drei General-Purpose Implementierung:
●
●
HashMap: Dynamische, assoziative Hashtabelle (ähnlich HashSet), meist O(1)
Map<Integer, String> platzierungen = new HashMap<Integer, String>();
platzierungen.put(1, "Schnellster");
platzierungen.put(2, "Weniger Schneller");
●
LinkedHashMap: Wie HashMap, aber alle Einträge über eine LinkedList verbunden,
daher Iterierung in Einfügereihenfolge (sofern nicht verändert) möglich (ähnlich
LinkedHashSet)
●
TreeMap: Ein assoziativer Baum, garantiert Ordnung und O(log n) für die meisten
Operationen (implementiert als Rot-Schwarz-Baum)
●
Drei Special-Purpose Implementierungen: EnumMap, WeakHashMap und
IdentityHashMap
Thomas Frenken
17 / 23
Java Collections Framework (JCF)
Implementierung und Algorithmen - Algorithmen
●
Eine Reihe von Standard-Aufgaben sind bereits in der Klasse java.util.Collections
vorimplementiert, funktionieren auf vielen Klassen der Collection-Hierarchie (wo es
Sinn macht)
●
Sortieren: Collections.sort(List<T> list) verwendet modifizierte Variante von
mergeSort (garantiert O(n log n))
List<String> list = Arrays.asList(args);
Collections.sort(list);
●
Mischen: Collections.shuffle(List<?> list)
●
Suchen: Collectins.binarySearch(List<? extends Comparable<? super T>>
list, T key)verwendet binäre Suche (vorher sortieren)
Thomas Frenken
18 / 23
Java Collections Framework (JCF)
Implementierung und Algorithmen - Algorithmen
●
Umkehren: Collections.reverse(List<T> list)
●
Vertauschen: Collections.swap(List<?> list, int i, int j)
●
Zählen: Collections.frequency(Collection<?> c, Object o)
●
Schnittmenge: Collections.disjoint(Collection<?> c1, Collection<?> c2)
●
Extreme: Collections.min(Collection<?> coll),
Collectins.max(Collection<?> coll)
●
Ersetzen: Collections.replaceAll(List<T> list, T oldVal, T newVal)
●
...
Thomas Frenken
19 / 23
Java Collections Framework (JCF)
Weiterführende Themen - Wrapper
Fügen nach dem Decorator-Pattern extra Funktionalität zu einem Interface hinzu /
●
nehmen Funktionalität weg (via Factory)
Zwei wichtige Wrapper:
●
●
Synchronized Wrappers: Ermöglichen Thread-Safety, z.B. für List
public static <T> List<T> synchronizedList(List<T> list);
List<Type> list = Collections.synchronizedList(new ArrayList<Type>());
●
Unmodifiable Wrappers: Verhindert Veränderung nach Erstellen einer Collection,
indem alle Operationen eine UnsupportedOperationException werfen, z.B. für List
public static <T> List<T>
unmodifiableList(List<? extends T> list);
List<Type> list = Collections.unmodifiableList(new ArrayList<Type>());
Thomas Frenken
20 / 23
Java Collections Framework (JCF)
Weiterführende Themen – Custom Implementations
Selten notwendig, eigene Collections zu schreiben:
●
●
●
Zusätzliche Funktionalität
●
Optimierung für spezielle Umgebung
●
Persistenz
Spezielle abstrakte Klassen vorgesehen (erleichtert Arbeit), verwenden, weil
Wiederverwendbarkeit erhöht wird (man kann auch direkt die Interfaces verwenden)
AbstractCollection
AbstractSet
AbstractList
AbstractSequentialList
AbstractQueue
AbstractMap
Thomas Frenken
21 / 23
Java Collections Framework (JCF)
Zusammenfassung
JCF ist das Collections Framework der Sprache Java
●
●
Abstrakte Datentypen (Interfaces)
●
Konkrete Datentypen (Implementierungen) für verschiedene Zwecke
●
Algorithmen
Verwenden weil
●
●
Optimiert für Java
●
Weniger Arbeit, akzeptiert und leicht austauschbar
Vier wichtige Hierarchien
●
●
Set (HashSet)
●
List (ArrayList)
●
Map (HashMap)
●
Queue (LinkedList)
Thomas Frenken
TROTZDEM wichtig zu wissen, welche
Datenstruktur welche Vorteile hat –
deshalb sitzen Sie hier!
22 / 23
Java Collections Framework (JCF)
Siehe auch...
SUN JCF Tutorial
●
●
●
http://java.sun.com/docs/books/tutorial/collections/TOC.html
●
http://java.sun.com/developer/onlineTraining/collections/Collection.html#Introduction
Java Collections Framework Tutorial unter http://ibm.com/developerWorks
(Registrierungspflichtig)
Thomas Frenken
23 / 23