Containerklassen. Containerklassen. 1 von 67

Transkript

1 1 von 67

2 Abstraktionsstufen im Überblick 2 von 67

3 Low-Level-Container In Java Arrays verkettete Listen auf Basis von Next-Referenzen Bäume auf Basis von Knoten mit Kind-Referenzen Charakteristiken Implementierungsdetails liegen offen Verwendung aufwändig und oft nicht problemadäquat 3 von 67

4 Kapselung des Speichermodells in Klassen Lösungen im JDK 1.0 Allgemeine (wiederverwendbare) Container mit Inhaltstyp Object Die Klassen: Vector Hashtable Defizite der beiden Klassen Implementierung ist festgelegt Keine saubere Zuordnung zu ADTs (abstrakten Datentypen) Typsicherheit? 4 von 67

5 Realisierung des ADT-Konzepts Zur Erinnerung: Trennung zwischen Modell und Implementierung, Festlegung des Funktionsumfangs über abstrakte Operationen Im JDK 1.2 Einführung des Collection-Frameworks. Abstrakter Teil von ADTs wird über möglichst präzise Interfaces abgedeckt. Die Verwendung sieht nur das Interface, nicht die Implementierung. Implementierungen sind austauschbar. Allgemeinheit Über Elementtyp Object realisiert. Verbleibender Kritikpunkt: unzureichende Typsicherheit. 5 von 67

6 Collections mit Generics Prinzip Typparametrisierung von Klassen und Methoden (s. o.) Besonders geeignet für und darauf operierende Algorithmen. Einführung: Mit Java 5 Bestehendes Collection-Framework konnte rückwärtskompatibel umgestellt werden. 6 von 67

7 Collections im Concurrent-API Absicht Berücksichtigung von zunehmenden Nebenläufigkeitsanforderungen (Stichwort Multicores) Effiziente thread-sichere Klassen (insbesondere nonblocking). Einführung: Mit Java 6 (+ Erweiterungen in Java 7 und Java 8). Meist Implementierungen, aber auch einige neue Interfaces. 7 von 67

8 Aggregatfunktionen mit Lambdas Prinzip Interne Iterierung mit Vorgabe einer Operation pro Element. Operation wird als Lambda spezifiziert Somit funktionale Sicht auf Collections. Einführung: Mit Java 8 Integration nur möglich wg. Implementierung von Interface-Evolution durch Default-Implementierungen in Interfaces. 8 von 67

9 Die Klassen Vector und Hashtable 9 von 67

10 Der Einfluss der Historie Die Klassen Vector und Hashtable sind die "Vorläufer" des Frameworks für Container-Klassen, das erst mit dem jdk1.2 eingeführt wurde. Sie sind deshalb (mit dem Interface Enumeration) als "Hilfsstrukturen" in vielen APIs enthalten. Vgl. auch Java Mobile Sie wurden aber in das Collection-Framework mit integriert. 10 von 67

11 Intention der Klasse Vector Die Klasse java.util.vector wurde konzipiert als relativ allgemeiner geordneter Container mit Random-Access-Zugriff auf die Elemente (vom Typ Object). Es können beliebige Objekte abgelegt werden (inhomogener Container). Implementierungsbasis ist ein Array. Die Größe des Containers kann dynamisch verändert werden (mit automatischer Anpassung). 11 von 67

12 1. Beispiel: Verwendung Vector (1) Direktzugriff auf die Elemente über Index public class ShapeTestFrame extends Frame { public void paint(graphics g) { Vector v = new Vector(3); // mit Kapazitaet 3 v.setsize(3); // Groesse festlegen, vorher 0 Circle c = new DrawableCircle(0,0,50); v.setelementat(c,0); v.setelementat(new DrawableCircle(60,50,20), 1); v.setelementat(new DrawableRectangle(100,100,80,40),2); // Abholen eines Elements c = new DrawableCircle(((Rectangle)v.elementAt(2)).toCircle(); // ein Element bei der Festlegung der Kapazitaet vergessen // macht nichts, Kapazitaet (gleich ziemlich) erhoehen! v.ensurecapacity(10); v.setsize(4); v.setelementat(new DrawableRectangle(70,70,80,40),3); 12 von 67

13 1. Beispiel: Verwendung Vector (2) // Damit wird die Groesse des Vektors implizit um 1 erhöht das neue // Element wird als 2. Komponente eingeschoben, die bisherige 2. wird 3. v.insertelementat(c,2); // Doch keine weiteren Elemente mehr dazu, keinen Speicherplatz vergeuden v.trimtosize(); // Iterieren ueber den Inhalt des Containers for (int i=0; i<v.size(); i++) ((Drawable) v.elementat(i)).draw(g); //cast ist notwendig 13 von 67

14 2. Beispiel: Verwendung Vector Vermeidung des Zugriffs auf die Elemente über Index public class ShapeTestFrame extends Frame { public void paint(graphics g) { // mit Kapazitaet 3 and Kapazitaetszunahme 5 Vector v = new Vector(3,5); v.addelement(new DrawableCircle(0,0,50)); v.addelement(new DrawableCircle(60,50,20)); Rectangle r = new DrawableRectangle(100,100,80,40); // falls nicht sicher, ob schon enthalten, besser abfragen if (!v.contains(r)) v.addelement(r); // Kapazitaet hier erschoepft, wird beim naechsten add um 5 erhoeht v.addelement(new DrawableCircle(r.toCircle())); v.trimtosize(); // Kapazitaet soll gleich Groesse werden Enumeration e = v.elements(); while (e.hasmoreelements()) ((Drawable) e.nextelement()).draw(g); 14 von 67

15 Erläuterungen Klasse Vector 1. Vector kapselt ein Array von Object (Indexbereich von 0 bis size-1) mit dynamisch veränderbarer Größe size. 2. Zu unterscheiden sind (aktuelle) Kapazität (capacity) und Größe (size). Die Größe legt fest, innerhalb welchen Bereichs auf Komponenten über den Index zugegriffen werden darf (gegebenenfalls wird eine ArrayIndexOutOfBoundsException geworfen). Die Kapazität drückt den verfügbaren Speicher im gekapselten Array aus. 3. Bei Bedarf können Kapazität und Größe "manuell" unabhängig voneinander verändert werden. (Methoden capacity(), ensurecapacity(int), size() und setsize(int)). Beim Hinzufügen von Elementen werden gegebenenfalls die Größe (um die Zahl der hinzugefügten Elemente) und die Kapazität (um einen Kapazitätszunahmewert: capacityincrement) automatisch erhöht. 4. Die Veränderung der Kapazität bedeutet Neuallokierung und Umkopieren. 5. Es gibt neben dem Default-Konstruktor einen mit einer vorgegebener Anfangskapazität und einen mit vorgegebenen Werten für Anfangskapazität und Kapazitätszunahme. Der Default für die Anfangskapazität ist 10, der Default bei der Kapazitätszunahme ist: jeweils verdoppeln. 6. Beim Abholen von Komponenten aus dem Vektor muss gecastet werden - wenn keine Generics benutzt werden. 7. Die Methode contains(object) benutzt die Methode equals(object) für die zu prüfenden Elemente.(Erinnerung: von Object geerbt oder geeignet überschrieben!) 8. Die Methode elements() liefert eine Implementierung des Interface Enumeration Dieses hat nur die Methoden hasmoreelements() und nextelement(), realisiert also einen einfachen Iterator. 9. Die Klasse Vector ist thread-safe. 15 von 67

16 Weitere "Uralt"-Container Stacks Die Klasse java.util.stack ist von Vector abgeleitetet. Sie besitzt zusätzlich die für Stacks "üblichen" Methoden. Aus heutiger Sicht "unmöglich"! Bitfelder Die Klasse java.util.bitset verwaltet eine Folge von indizierten logischen Bitwerten, auf denen die üblichen bitweisen logischen Operationen ausgeführt werden können. 16 von 67

17 Klasse Hashtable: Funktion und Einbettung Die ursprüngliche Einordnung in der Vererbungshierarchie Hashtable leitet sich von der Klasse Dictionary ab. Diese abstrakte Klasse ist ein Relikt aus dem JDK1.1 und sollte nun vermieden werden. Sie beinhaltet die abstrakten Methoden, die ein ADT Dictionary besitzen sollte Neuere Form der Einbindung Hashtable implementiert seit JDK1.2 das Interface java.util.map (s. u.) Aufgabe ist das effiziente Wiederfinden von Daten, die durch einen eindeutigen Schlüssel charakterisiert sind. Datum und Schlüssel sind Objekte (bzw. über Generics spezifizierbar), die getrennt voneinander vorliegen können. 17 von 67

18 Beispiel Hashtable: Einfügen, Suchen, Löschen public class HashtableTest { public static void main(string[] args) { // Mit Festlegung der Anfangsgröße und des Load Factors Hashtable htab = new Hashtable(10,1.0f); String str = "first"; Integer one = new Integer(1); htab.put(str, one); htab.put("second", new Double(2.0)); htab.put("third", new Vector()); // htab.put(new Integer(4), new Vector()); // geht das? //str = "fourth"; // was ändert sich dadurch? System.out.println("contains key " + str + ":" + htab.containskey(str)); System.out.println(" has value:" + htab.get(str)); System.out.println("contains value " + one + ":" + htab.contains(one)); System.out.println("htab:"+htab); htab.remove("third"); System.out.println("htab:"+htab); htab.put(new String("first"), new Double(1.0)); // was passiert? System.out.println("htab:"+htab); 18 von 67

19 Beispiel Hashtable: Eigene Schlüssel-Klasse Ein erster Versuch class HashKey { private String str; public HashKey(String str) { this.str = str; public String tostring() { return str; public class KeyTest { public static void main(string[] args) { Hashtable htab = new Hashtable(10,1.0f); htab.put(new HashKey("first"), new Integer(1)); htab.put(new HashKey("second"), new Double(2.0)); System.out.println("htab:"+htab); htab.put(new HashKey("first"), new Double(1.0)); // was passiert? System.out.println("htab:"+htab); Was muss verbessert werden? 19 von 67

20 Erläuterungen zur Klasse Hashtable 1. Die Klasse Hashtable realisiert Hashing mit listenbasierten Buckets. 2. Einträge sind durch einen Schlüssel und einen Wert charakterisiert. Dies sind separate Objekte (jeweils vom Typ Object, falls keine Generics verwendet werden). Schlüssel und Werte können somit bezüglich des Typs sehr heterogen sein, aber meist unerwünscht (vgl. Generics). 3. Die Zahl der Buckets kann im Konstruktor vorgegeben werden (capacity). 4. Sie wird dynamisch vergrößert, wenn ein gewisser Schwellenwert für das Verhältnis zwischen Zahl der gespeicherten Elemente und Zahl der Buckets überschritten wird (loadfactor). 5. Dieser Schwellwert kann im Konstruktor festgelegt werden (Default: 0.75). 6. Der Hashwert wird ermittelt durch die Methode hashcode(): Diese ist in der Klasse Object vorhanden (Der Hashwert wird aus der Speicheradresse berechnet). Sinnvoll überschrieben ist die Methode z. B. in den Klassen String, Float,... Für eine benutzerdefinierte Klasse als Key sollte sie geeignet überschrieben werden! 7. Die Methode put(object key, Object value) überschreibt einen bereits vorhandenen Eintrag mit demselben Hashcode wie key nur dann, wenn die Methode equals() Gleichheit der Schlüssel ermittelt. Es können also mehrere Einträge mit demselben Hashcode in einer Tabelle vorhanden sein. Für eine benutzerdefinierte Klasse, die als Key in einer Hashtabelle eingesetzt wird, sollte sie also auch die Methode equals() geeignet überschrieben werden. 8. Verwendung einer mutable Klasse für Keys kann "tückisch" sein. 9. Man beachte dabei den Performance-Unterschied für die Methoden containskey(object key) und contains(object element)! 10. Die Klasse Hashtable ist Thread-safe! 20 von 67

21 Das Collection-Framework 21 von 67

22 Zweck und Historie Seit JDK 1.2. Gedacht alt erweiterbares Rahmenwerk. Bestandteile: Interfaces, Implementierungen, einige Algorithmen, Muster Die bereits vorher existierenden Container-Klassen Vector und Hashtable wurden nachträglich in dieses Framework mit eingebunden. Erweiterungen im J2SDK_1.5 : "Generics", "foreach", "(un)boxing". Concurrent-API ab Java 6 (wird in dieser Vorl. nicht behandelt) 22 von 67

23 Interface Collection und seine Ableitungen (1) 23 von 67

24 Interface Collection und seine Ableitungen (2) Erläuterungen: Collection steht für den allgemeinsten Container, der eine ungeordnete Ansammlung von Elementen mit evtl. Duplikaten ("Bag") beinhaltet. Diese Interface wird häufig benutzt als Typ von in Methoden zu übergebenden Container-Objekten. Mit dem Iterator kann über die Elemente einer Collection gelaufen werden und gegebenenfalls das letzte besuchte Element gelöscht werden. Einfüge- und Löschmethoden geben einen Boolean-Wert zurück, der angibt, ob der Containerinhalt durch den Methodenaufruf geändert wurde. Das Interface Iterable dient als Markierung für die Anwendung der For-Each-Schleife. Das Interface Set repräsentiert Mengen-Container ohne Duplikate (Die Gleichheit wird dabei mit der equals()-methode bestimmt). Das Interface List repräsentiert geordnete Container (ADT Folge). Der Zugriff auf einzelne Elemente ist über einen Integer-Index möglich. 24 von 67

25 Interface Collection und seine Ableitungen (3) Beispiel: Typsichere Schleifen mit Iterator static void visitelements(collection<string> c) { Iterator<String> iterator = c.iterator(); while (iterator.hasnext()) { String s = iterator.next();... Beispiel: Typsichere Schleifen mit "foreach" static void visitelements(collection<string> c) { for (String s : c ) {... Beispiel: Polymorphes Filtern eines Containerinhalts static boolean dontlike(object o) {... static void filter(collection<?> c) { Iterator<?> it = c.iterator(); while (it.hasnext()) if (dontlike(it.next())) it.remove(); 25 von 67

26 Interface Collection und seine Ableitungen (4) Beispiel: Ersetzen eines bestimmten Wertes in einer Liste durch einen neuen Wert. public static <T> void replace(list<t> list, T value, T newvalue) { ListIterator<T> it = list.listiterator(); while (it.hasnext()) { if (value == null? it.next() == null : value.equals(it.next())) it.set(newvalue); Beispiel: Durchschnitt zweier Mengen set1.retainall(set2); Beispiel: Index eines Elements in einem Teilbereich einer Liste List<String> list =... List<String> sublist = list.sublist(fromindex, toindex); //Ausschnitt der Liste int i = sublist.indexof(s); // index in der Teilliste!! Beispiel: Löschen eines Bereiches einer Liste list.sublist(fromindex, toindex).clear(); 26 von 67

27 Interface Map und seine Ableitungen (1) 27 von 67

28 Interface Map und seine Ableitungen (2) Eigenschaften Das Interface Map repräsentiert Schlüssel-Wert-Paare (key-value pairs): ADT Mapping. Das Interface Map.Entry ein einzelnes Schlüssel-Wert-Paar mit unveränderlichem Schlüssel. Es gibt keinen direkten Iterator für Map. Dafür Collection-Factories für die Schlüssel, die Werte und die Paare (Entries). Beispiel: Iterieren über den Inhalt einer Map Map<String, Integer> map =...; Iterator<Map.Entry<String, Integer>> it = map.entryset().iterator(); while (it.hasnext()) { Map.Entry<String, Integer> entry = it.next(); String key = entry.getkey(); int value = entry.getvalue();... // Alternative mit foreach for (Map.Entry<String, Integer> entry : map.entryset()) { von 67

29 Interfaces für sortierte Container (1) Die Interfaces zur Vorgabe einer Ordnung "Natürliche" Ordnung auf Instanzen einer Klasse per Implementierung von public interface Comparable<T> { int compareto(t o); "Externe" Ordnung auf Elementen per: public interface Comparator<T> { int compare(t o1, T o2); 29 von 67

30 Interfaces für sortierte Container (2) java.util.sortedset Die Elemente müssen per Impl. von Comparable oder durch einen Comparator einer Ordnung unterliegen. Einfügen mit add() erfolgt in sortierter Form. Der Iterator liefert die Elemente dann in aufsteigender Ordnung. Die zusätzlichen Methoden beziehen sich auf diese Ordnung. Ein subset bezieht sich hierbei auf den Bereich zwischen zwei Objekten (nicht zwischen zwei Indizes o. ä.). public interface SortedSet<E> extends Set<E> { SortedSet<E> subset(e fromelement, E toelement); SortedSet<E> headset(e toelement); SortedSet<E> tailset(e fromelement); E first(); E last(); Comparator<? super E> comparator(); 30 von 67

31 Interfaces für sortierte Container (3) java.util.sortedmap Die vorausgesetzte Ordnung bezieht sich auf die Schlüsselobjekte. public interface SortedMap<K,V> extends Map<K,V> { SortedMap<K,V> submap(object fromkey, Object tokey); SortedMap<K,V> headmap(object tokey); SortedMap<K,V> tailmap(object fromkey); K firstkey(); K lastkey(); Comparator<? super K> comparator(); 31 von 67

32 Implementierungen der Collection-Interfaces Informelle Anforderungen 1. Es sollt jeweils mindestens ein Standardkonstruktor (ohne Argumente) und ein "Copy-Konstruktor" implementiert werden. 2. Manche Operationen sind in den Interfaces als optional angegeben. Werden Sie nicht entsprechend der Spezifikation implementiert, sollten sie UnsupportedOperationException werfen. 3. Iteratoren sollen so implementiert sein, dass sie bei zwischenzeitlicher Änderung des Containers eine ConcurrentModificationException werfen (fail-fast-iterators). Dies kann durch einen Zähler modcount für Strukturänderungen in der zugehörigen Containerklasse realisiert werden. Im Gegensatz dazu sind Enumerations (z. B. für Vector) nicht "fail-fast". 32 von 67

33 Abstrakte Collection-Klassen Es sind partielle Implementierungen obiger Interfaces unabhängig von einem Speichermodell im API vorhanden. Konseqenz: Bestimmte Methoden müssen abstrakt bleiben ("Hooks"), andere können unter Verwendung der abstrakten Methoden und Iteratoren implementiert werden. Jedoch kann es aus Performancegründen notwendig sein, in echten Implementierungen manche bereits implementierte Methode trotzdem zu überschreiben. vorhandene abstrakte Klassen: AbstractCollection, AbstractSet, AbstractQueue, AbstractList (für List-Implementierungen mit random-access-speicher), AbstractSequentialList (für List-Implementierungen mit sequentiell organisiertem Speicher), AbstractMap. 33 von 67

34 Allg. Collection-Implem. im JDK (1) Die Einbindung in das Framework am Beispiel ArrayList<E> Beispiel: Instanziierung der Impl.-Klasse und Referenzierung per Interface List<String> list = new ArrayList<String>(); list.add("suse"); von 67

35 Allg. Collection-Implem. im JDK (2) Spezielle Concurrent-Container werden hier nicht aufgezählt. Implementierungen von List ArrayList: dynamisch erweiterbares Array (nicht thread-safe) Vector: dynamisch erweiterbares Array (thread-safe) LinkedList: doppelt verkettete Liste (insbes. für Queues und Deques) Implementierungen von Queue und (oder) Deque LinkedList: doppelt verkettete Liste ArrayDeque: basiert auf Array PriorityQueue: basiert auf Heap Implementierung von Set HashSet: basiert auf Hashtabelle! EnumSet: speziell optimiert für Enum-Elemente. 35 von 67

36 Allg. Collection-Implem. im JDK (3) Implementierung von SortedSet TreeSet: basierend auf TreeMap. Implementierungen von Map Hashtable (thread-safe) HashMap (nicht thread-safe) WeakHashMap: nur anderweitig referenzierte Keys bleiben enthalten IdentityHashMap: Identität der Keys auf Basis von ==, und nicht equals() Implementierung von SortedMap TreeMap: basierend auf einem binären ausgeglichenen Baum (red black tree). 36 von 67

37 Hüllen-Implementierungen (1) Einschub: Decorator Pattern Intention Einem Objekt sollen dynamisch zusätzliche Verantwortlichkeiten übertragen werden. vgl. Hinzufügen von Funktionalität zu einer Klasse in einer abgeleiteten Klasse. typisches Beispiel Hinzufügen eines Randes oder Scroll-Balkens zu einem Graphik-Fenster (Scroll-Decorator oder/und Border-Decorator). Allgemeine Struktur 37 von 67

38 Hüllen-Implementierungen (2) Grundprinzip Die Hüllenimplementierungen folgen dem Decorator Pattern. Sie basieren auf anonymen Implementierungen. Sie werden instanziert durch Factory-Methoden in der Klasse Collections. Hüllen für Schreibschutz Diese verhindern einen Schreibzugriff auf die dahinterliegenden Container-Objekte. Die Lesezugriffe gehen auf den ummantelten Container. public static Collection<T> unmodifiablecollection(collection<t> collection); public static Set<T> unmodifiableset(set<t> set);... Die Klassen Decorator und ConcreteDecorator sind hier jeweils zu einer anonymen Klasse verschmolzen, die durch eine Factory-Methode instanziiert wird. 38 von 67

39 Hüllen-Implementierungen (3) Hüllen zur Synchronisation public static Collection<T> synchronizedcollection(collection<t> collection); public static Set<T> synchronizedset(set<t> set);... Man beachte Die Verwendung eines zugehörigen Iterators muss explizit "mitsynchronisiert" werden. Beispiel Collection<String> mycollection =... Collection<String> collection = Collections.synchronizedCollection(myCollection); synchronized(collection) { Iterator<String> iterator = collection.iterator(); // Must be in the synchronized block! while (iterator.hasnext()) foo(iterator.next()); 39 von 67

40 Sonstige nützliche Implementierungen List-View eines Arrays Methode static List<T> aslist(t... a) in Klasse java.util.arrays. Erläuterungen 1. Die List-Methoden greifen auf das gekapselte Array durch. 2. Die Größe der Liste kann nicht geändert werden. 3. Also Arrays.asList(new Object[size]) liefert eine effiziente Liste mit konstanter Länge size. Unveränderbare Liste mit gleichartigen Kopien als Listeneinträge Methode static List<T> ncopies(int n, T o)in Klasse java.util.collections. Unveränderbare einelementige Menge Methode static Set<T> singleton(t o) in Klasse java.util.collections. Konstanten für leere Menge und leere Liste In der Klasse java.util.collections gibt es: public static final List EMPTY_LIST public static final Set EMPTY_SET 40 von 67

41 Algorithmen für Collections Überblick An Algorithmen auf Collection-Klassen sind implementiert: Sortieren, binäre Suche, Minimum (bzw. Maximum) bestimmen. Entsprechende Algorithmen sind auch für Arrays implementiert (siehe Klasse java.util.arrays). Voraussetzung: Die Klassen der im Container enthaltenen Elemente müssen entweder: einer natürlichen Ordnung unterliegen, d. h. java.util.comparable implementieren oder : per expliziter java.util.comparator-impl. geordnet sein. Comparable wird z. B. implementiert von String, Byte, Character, Short, Integer, Long, Float, Double, BigInteger, BigDecimal, File, URL, Date. Man beachte: Die Vergleichsoperationen müssen mit den equals()-methoden konsistent sein. D. h. die compare()- (bzw. compareto())-methode muss für zwei Objekte genau dann den Wert 0 zurückliefern, wenn die equals()- Methode für die zwei Objekte true zurückliefert. 41 von 67

42 Sortieren (1) Sortiermethoden (def. in der Klasse Collections): static <T extends Comparable<? super T>> void sort(list<t> list) static <T> void sort(list<t> list, Comparator<? super T> c) Beispiel: Sortieren von Argumenten public class SortTest { public static void main(string args[]) { List<String> l = Arrays.asList(args); Collections.sort(l); System.out.println(l); 42 von 67

43 Sortieren (2) Beispiel: zweiteiliger Name mit zugehörigem Comparator public class NameComparator implements Comparator<Name> { public int compare(name n1, Name n2) { int lastcmp = n1.lastname().compareto(n2.lastname()); return (lastcmp!= 0? lastcmp : n1.firstname().compareto(n2.firstname())); public class Name { private String firstname, lastname; public Name(String firstname, String lastname) {... public String firstname() { return firstname; public String lastname() { return lastname; public boolean equals(object other) { if (!(other instanceof Name)) return false; Name name = (Name)other; return name.firstname.equals(firstname) && name.lastname.equals(lastname); public int hashcode() { return 31*firstName.hashCode() + lastname.hashcode(); public String tostring() {return firstname + " " + lastname; 43 von 67

44 Sortieren (3) public class NameSort { public static void main(string args[]) { Name n[] = { new Name("Charly", "Chaplin"), new Name("Karl", "Marx"), new Name("Groucho", "Marx"), new Name("Karl", "Valentin") ; List<Name> l = Arrays.asList(n); Collections.sort(l, new NameComparator()); System.out.println(l); 44 von 67

45 Suchen Suchmethoden (def. in der Klasse Collections) static <T> int binarysearch(list<? extends Comparable<? super T>> list, T key) static <T> int binarysearch(list<? extends T> list, T key, Comparator<? super T> comp) Rückgabewert Index des gefundenen Objekts bzw., falls nicht vorhanden, ein Hinweis auf die richtige Einfügeposition (als negative Zahl). Bei von AbstractSequentialList abgeleiteten wird sequentiell gesucht. 45 von 67

46 Min, Max und Co Max-Methoden (def. in der Klasse Collections) static <T extends Object & Comparable<? super T>> T max(collection<? extends T> coll) static <T> T max(collection<? extends T> coll, T key, Comparator<? super T> comp) Analog min() Sonstige Algorithmen (def. in der Klasse Collections static void shuffle(list<?> list, Random rnd) // permute randomly static void shuffle(list<?> list) static void reverse(list<?> l) //reverse the order in the list static <T> void fill(list<? super T> list, T o) // fill whole list with one value static <T> void copy(list<? super T> dest, List<? extends T> src) und weitere. 46 von 67

47 Lambdas 47 von 67

48 Hintergrund Historie Churchs Lambda-Kalkül aus den 1930er Jahren Berechnungsmodell gleichmächtig wie die Turing-Maschine (vgl. Theoretische Informatik) Ausdrücke der Form λx.2x Viele populäre Sprachen besitzen Lambdas bzw. Closures ursprünglich die klassischen funktionalen Sprachen (Lisp, Scheme) mittlerweile auch als funktionale Anteile in imperativen bzw. objektorientierten Sprachen (Python, Ruby, Scala, JavaScript, C#, C++). Seit Java 5 angjährige Diskussion bei Sun über Integration von Lambdas in Java (ursprünglich 3 Vorschläge ohne Konvergenz). Erkenntnis: Java soll nicht zum neuen Cobol werden. Einführung mit dem Java 8. Vorteile Einfachere Syntax und effizientere Implementierung als anonyme Funktionen. Funktionen als Objekte. "Code as Data" Funktionaler Programmierstil hilft bei der Ausnutzung von Multicores. Insbesondere können parallele Arrays und Collections dadurch einfach bereitgestellt werden. 48 von 67

49 Motivation: Execute-Around-Method-Pattern Die Situation Vorbereitung (allgemein) Ausführen einer Aktion (spezifisch) Aufräumen (allgemein) Beispiele acquire resource use resource release resource acquire lock critical section release lock Iterator it = coll.iterator(); while (it.hasnext() element = it.next() visit(element); try { some action catch(...) {... catch(...) {... finally {... Lösung Implementierung der speziellen Teile in jeweils einer Funktion und Aufruf im allgemeinen Rahmen. Funktionsübergabe an den Rahmen-Code. 49 von 67

50 Beispiel (1) Rahmen für interne Iteration class IntArrayUtils { public static void foreach(int[] array, IntConsumer consumer) { for (int i: array) { consumer.accept(i); Das zugehörige Interface (aus dem Java-API) interface Consumer<T> { void accept(t t); 50 von 67

51 Beispiel (2) Aufruf mit anonymer Klasse int[] array = {1,2,3; IntArrayUtils.forEach(array, new public void accept(int value) { System.out.println(value); ); Aufrufe mit Lambdas IntArrayUtils.forEach(array, i -> System.out.println(i)); IntArrayUtils.forEach(array, i -> { if (i%2 == 0) System.out.println(i);); IntConsumer printifodd = i -> { if (i%2!= 0) System.out.println(i);; IntArrayUtils.forEach(array,printIfOdd); 51 von 67

52 Beispiel (3) Eine Methode mit zwei Funktionsparametern class IntArrayUtils {... public static void foreachif(int[] array, IntPredicate predicate, IntConsumer consumer) { for (int value: array) { if (predicate.test(value)) consumer.accept(value); Ein zugehöriger Aufruf IntArrayUtils.forEachIf(array, i -> i%2 == 0, i -> System.out.println(i) ); 52 von 67

53 Syntax von Lambdas Aufbau Lambdas bestehen aus einer Parameterliste und einem Body (getrennt durch ->). Parameter können explizit typisiert sein oder vom Compiler mit einem Typ versehen werden. Der Body kann einem einzelnen Ausdruck, einer Anweisung oder einem Block bestehen. Beispiele x -> 1+ Math.sqrt(x) (Integer x) -> x (x,y) -> x + y typeless param typed param two params () -> 32 no param x -> { double r = x; return r; block as body 53 von 67

54 Lambdas und Typisierung Für Lambdas wurde das Typsystem nicht über die herkömmlichen Typen (primitive Datentypen, Arrays, Klassen,...) hinaus durch eigene Typen erweitert (vgl. z. B. typisierter Lambda-Kalkül). Stattdessen wurde eine Menge von Interfaces mit einer einzelnen abstrakten Methode eingeführt (bzw. bestehende markiert), genannt Functional Interface Types oder SAM (Single Abstract Method). Diese Interfaces in java.util.function sind annotiert. Jedes Lambda muss vom Compiler einem dieser Interfaces zugeordnet werden können. Dies erfolgt über den Kontext des Lambdas. Lamdas sind nur an folgenden Stellen zulässig: rechte Seite einer Zuweisung, aktueller Übergabeparameter, Rückgabewert, hinter einem Cast, u. ä. Dabei werden ggf. die Typen der Lambda-Parameter und des -Ergebnisses deduziert (Deduktionskontext). 54 von 67

55 Beispiel: Typendeduktion import java.util.function.bifunction; import java.util.function.function; import java.util.function.supplier; public class FunctionExecutor { private int value; public FunctionExecutor(int value) { this.value = value; public Double exec(function<integer,double> lambda) { return lambda.apply(value); public Double exec(bifunction<integer,integer, Double> lambda, Integer v2) { return lambda.apply(value,v2); public static void main(string[] args) { FunctionExecutor executor = new FunctionExecutor(12); double res1 = executor.exec(x -> 1+ Math.sqrt(x)); double res2 = executor.exec((integer x) -> x); double res3 = executor.exec((x,y) -> x + y, 3); Supplier lambda = () -> 32; // no param int res4 = lambda.get(); 55 von 67

56 Functional Interfaces (1) Vor Java 8 existierende Typvorlagen public interface Runnable { public void run(); public interface Callable<V> { V call() throws Exception; public interface Comparator<T> { int compare(t o1, T o2); public interface ActionListener extends EventListener { public void actionperformed(actionevent e); Beispiel für Anwendung: new Thread(() -> {... ).start(); 56 von 67

57 Functional Interfaces (2) Mit Java 8 eingeführte zentrale SATs public interface Predicate<T> { boolean test(t t); public interface Function<T,R> { R apply(t t); public interface BinaryOperator<T> { T apply(t left, T right); public interface Consumer<T> { void accept(t t); public interface Supplier<T> { T get(); 57 von 67

58 Variable-Binding Der Mechanismus Im Lambda-Body hat man selbstverständlich Zugriff auf die Parameter und lokale Variable. Zudem können Variablen aus dem umgebenden Kontext einer Lambda-Definition dort mit verwendet werden (lokale Var., Attribute). Lokale gebundene Variable aus dem umgebenden Kontext müssen final bzw. effectiv final sein. Das wird durch den Compiler überprüft. Ein Beispiel public class FunctionExecutor { private int value; public Double exec(function<integer,double> lambda) { return lambda.apply(value); public static void main(string[] args) {... double factor = 3.14; Function<Integer,Double> lambdawithvarbinding = x -> factor * x; double res6 = executor.exec(lambdawithvarbinding); 58 von 67

59 Methoden- und Konstruktorreferenzen Das Konstrukt Statt expliziter Lambda-Definitionen können für SAMs auch Referenzen auf bestehende Objekt-, Klassenmethoden und Konstruktoren eingesetzt werden. Compiler macht auch hier eine Typdeduktion auf Basis des Kontexts. Syntax: receiver::methodname, wobei receiver eine Klasse oder ein Objekt sein kann. Beispiele class IntArrayUtils { public static void foreach(int[] array, IntConsumer consumer) {... public static void main(string[] args) {... IntArrayUtils.forEach(array, System.out::println); public class FunctionExecutor { public Double exec(function<integer,double> lambda) {... public static void main(string[] args) {... double res = executor.exec(math::sqrt); Function<String,StringBuilder> lambda = StringBuilder::new; StringBuilder sb = lambda.apply("hallo").append(" Welt"); 59 von 67

60 Collections und Lambdas 60 von 67

61 Einstieg Ein einfaches Beispiel List<Integer> list = Arrays.asList( 8, 13, 1, 35, 4 ); list.foreach( i -> System.out.print(" " + i)); System.out.println(); list.sort((i,j) -> i.compareto(j)); list.foreach( i -> System.out.print(" " + i)); List<Integer> list2 = new ArrayList<Integer>(list); list2.removeif(i -> i%2 == 0); Erklärung default void foreach(consumer<? super T> action) wurde mit Java 8 in das Interface Iterable<T> aufgenommen. sort(comparator<? super E>) hat als Parameter ein Functional-Interface. default boolean removeif(predicate<? super E> filter) ist neu im Interface Collection<E>. 61 von 67

62 Aggregatoperationen (1) Charakteristiken Auf einer Ansammlung von Elementen soll eine Operation ausgeführt werden. Typische Vertreter: Operationen rein mit Seiteneffekt (z. B. Ausgabe) Filtern Abbildung pro Element ausführen (Mapper) Konsolidierung auf einen oder mehrere Werte (Reducer) Bestandteile: Quelle (Array, Collection, I/O-Channel, Generatorfunktion,...) und die eigentliche Operation. Iteration erfolgt intern: Nicht wie iteriert wird, muss spezifiziert werden, sondern nur, was auf jedem Element zu passieren hat. Operationen sollten verkettet werden können: Pipelining. 62 von 67

63 Aggregatoperationen (2) Aggregatoperationen für Collections ab Java 8 Die Operationen werden als Lamdas formuliert. Die Ausführung erfolgt nicht auf den Collections selbst sondern davon abgeholten Streams (Folge von Elementen). Die Klasse java.util.stream.stream (und die Pendants für primitive Datentypen (IntStream, LongStream, DoubleStream) haben folgende Gruppen von Aggregat-Funktionen (mit Functional-Interfaces als Parameter): Zwischenfunktionen (filter(), map(),...), die wieder einen Stream zurückliefern Abschlussoperationen (foreach(), count(), collect(),...), die Seiteneffekt oder Ergebnis produzieren. Streams sind träge: D. h. Berechnungen an der Quelle und Abholen der Elemente erfolgt erst bei Bedarf 63 von 67

64 Beispiele (1) Die Ausgangsdaten List<Integer> integerlist = Arrays.asList( 8, 13, 1, 2, 35, 4 ); int[] intarray = { 9, 17, 1, 2, 36, 3 ; List<String> stringlist = Arrays.asList( "hello world", "good bye" ); String string = "to be or not to be is the question to be answered"; Einfache Zwischen- und Abschlussfunktionen // intermediate function filter and terminal function count long count = integerlist.stream().filter(n -> (n > 1) && ((n==2) (n % 2)!= 0)).filter(n -> isprime(n)).count(); // sort and map integerlist.stream().sorted() // type Stream<Integer>.map(n -> n + ":" + isprime(n)) // type Stream<String>.forEach(s -> System.out.println(s)); // result of type Optional Optional<Integer> primeoptional = integerlist.stream().filter(n -> isprime(n)).findany(); if (primeoptional.ispresent()) System.out.println("found prime: " + primeoptional.get()); else System.out.println("no prime in list"); 64 von 67

65 Beispiele (2) Streams direkt auf Arrays Arrays.stream(intArray) // is of type IntStream.sorted().mapToObj(n -> n + ":" + isprime(n)) // type Stream<String>.forEach(s -> System.out.println(s)); Map-Reduce // map reduce pattern int sumofsquares = integerlist.stream().map(i -> i * i).reduce(0, (i,j) -> i + j); int charcount = stringlist.stream().maptoint(s -> s.length()).reduce(0, (i,j) -> i+j); // alt. by specialized reduction function charcount = stringlist.stream().maptoint(s -> s.length()).sum(); String uppercasetext = stringlist.stream().map(s -> s.touppercase()).reduce("", (s,t) -> s + " " + t); 65 von 67

66 Beispiele (3) Collect Im Unterschied zu reduce wird nicht bei jedem Schritt ein neuer Wert erzeugt. // collect as mutable reduction Map<String,Integer> wordcountmap = Arrays.asList(string.split(" ")).stream().collect(hashmap::new, (HashMap map,string s) -> { Integer i = map.get(s); if (i == null) map.put(s,1); else map.put(s,i+1);, (map1,map2) -> map1.putall(map2)); Map<String,List<String>> groupedwords = Arrays.asList(string.split(" ")).stream().collect(collectors.groupingby(c -> c)); Map<String,Integer> wordcountmap2 = Arrays.asList(string.split(" ")).stream().collect(collectors.groupingby( c -> c, Collectors.reducing(0, i -> 1, Integer::sum))); double average = integerlist.stream().collect(collectors.averagingint((integer i) -> i)); 66 von 67

67 Beispiele (4) Flat-Map // map versus flatmap stringlist.stream().map(s -> Arrays.asList(s.split(" "))).foreach(s -> System.out.println(s)); stringlist.stream().flatmap(s -> Arrays.asList(s.split(" ")).stream()).foreach(s -> System.out.println(s)); stringlist.stream().map(s -> s.chars()).foreach(s -> System.out.println(s)); stringlist.stream().flatmaptoint(s -> s.chars()).foreach(s -> System.out.println((char)s)); Parallele Streams // parallel stream integerlist.parallelstream().sorted().map(n -> n + ":" + Thread.currentThread()).forEach(s -> System.out.println(s)); 67 von 67