Java Collections Framework (JCF)

Transkript

1 Algorithmen & Datenstrukturen Bachelor Medieninformatik Fachbereich DCSM FH Wiesbaden University of Applied Sciences Thomas Frenken

2 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

3 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

4 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

5 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

6 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); Optionale Methoden müssen, falls sie nicht ausimplementiert werden, eine OperationNotSupported-Exception werfen Umgekehrt: List<T> Arrays.asList(T[] a) Thomas Frenken 6 / 23

7 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 //oder mit foreach for (String student: stringlist) {... } public interface Iterator<E> { boolean hasnext(); E next(); void remove(); //optional } Thomas Frenken 7 / 23

8 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

9 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

10 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

11 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

12 Interfaces des JCF - Map Interface-Definition Sub-Interface SortedMap erlaubt, Schlüssel oder Elemente zu ordnen 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(); // 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

13 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

14 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"); //und nu? Geloost! BOO! BOO! BOO! 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"); YEAH! YEAH! YEAH! Thomas Frenken 14 / 23

15 Implementierung und Algorithmen - Set Drei General-Purpose Implementierung: HashSet: Eine dynamische Hashtabelle, O(1) für Standard-Operationen, Standard- Kapazitä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

16 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 Index- Zugriff (O(n)) (implementiert auch Queue-Interface), Speicherverbrauch Eine Special-Purpose Implementierungen: CopyOnWriteArrayList Thomas Frenken 16 / 23

17 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

18 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

19 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

20 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

21 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

22 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) TROTZDEM wichtig zu wissen, welche Datenstruktur welche Vorteile hat deshalb sitzen Sie hier! Thomas Frenken 22 / 23

23 Siehe auch... SUN JCF Tutorial Java Collections Framework Tutorial unter (Registrierungspflichtig) Thomas Frenken 23 / 23