Programmieren 2 16 Java Collections und Generizität

Transkript

1 Programmieren 2 16 Java Collections und Generizität Bachelor Medieninformatik Wintersemester 2015 Dipl.-Inform. Ilse Schmiedecke schmiedecke@beuth-hochschule.de 1

2 Faulheit professionell: Fertige Datenbehälter Array ist eine sehr grundlegende Datenstruktur Vorteile: in fast jeder Programmiersprache vorhanden einfach zu handhaben grundsätzlich effizient Nachteile: feste Länge Fehlerpotenzial durch unzulässige Indizes Aktionen in der Mitte (einfügen, löschen) erfordern Programmieraufwand Die Standardbibliothek java.util enthält flexiblere Datenbehälter Das Java-Collections-Framework 2

3 Vorstellung: Statt Array eine "Fertig-Collection" Was ist gemeint: Interface bleibt Implementierung mit einer anderen Datenstruktur: SomeCollection statt Array class StackArray implements LiFo { private Object[] stack = new Object[size]; private int top = 0;... class StackCollection implements LiFo { private SomeCollection stack = new SomeCollection();

4 Das Java Collections Framework Grundlegende Interfaces 4

5 Das Interface List 5

6 6

7 Das Interface List im Kern Interface List extends Collection{ void add(object o); void add(object o, int index); void addall(collection c); void clear(); boolean contains(object o); void remove (Object o); Object remove(int index); int size(); Object[] toarray(); //... und viele weitere Methoden geeignet für alle listenartigen Datenbehälter 7

8 List-Implementierungen Collection AbstractCollection List Abstract List Achtung, Runtime- Exceptions beachten! ArrayList LinkedList Vector 8

9 Verwendung von List als Datenstruktur: LiFo import java.util.*; // die Collections class LifoVariabel implements LiFo{ private List liste = new ArrayList(); // oder Vector oder LinkedList public void add(object obj) { liste.add(obj,0); // vorn einfügen public Object remove() { return liste.remove(0); // vorn wegnehmen 9

10 Verwendung von List als Datenstruktur: FiFo import java.util.*; // die Collections class LifoVariabel implements LiFo{ private List liste = new ArrayList(); // oder Vector oder LinkedList public void add(object obj) { liste.add(obj, liste.add(obj); liste.size()-1); // hinten einfügen // hinten (default) einf. public Object remove() { return liste.remove(0); // vorn wegnehmen public boolean isempty() { return liste.size() == 0; 10

11 Iteratoren Implementierungs-unabhängiges Durchlaufen einer Collection Iterator: ein intelligentes Objekt, das durch die Collection navigieren und an beliebiger Stelle Elemente lesen, entfernen oder einfügen kann Merkt sich seine Position für den nächsten Aufruf Mehrere Iteratoren pro Collection sind möglich Wie Affen an einer Palme Zu erzeugen durch die statische Funktion listiterator(), die einen "Affen" vom Typ ListIterator abliefert und an den Anfang der Collection setzt. 11

12 ListIterator 12

13 Sortiertes Eintragen mit dem ListIterator liste sei eine abwärts sortierte Liste, in die das Element elem einzutragen ist. Iterator-Funktionen: next() "klettert" eine Stufe weiter und liefert den Eintrag nextindex() liefert den Folgeindex, ohne zu "klettern" public void eintragen(list liste, Element elem) { ListIterator affe = liste.listiterator(); while ((Element)(affe.next()).greater(elem)) { */ nur weiterlaufen */ liste.add(elem, affe.nextindex()-1); Ein zweiter "Affe" könnte parallel etwas anderes an der selben Liste machen.. Cast nötig: greater () ist für Object nicht definiert 13

14 Verwendung von LiFoVariabel für String-Elemente public static void main(string[] args) { List stack = new LiFoVariabel(); String[] woerter = {"gestern", "heute", "morgen", "übermorgen" ; for (String (Object wort : woerter) stack.add(wort); while(! stack.isempty()) { System.out.println( (String)(stack.remove()) ); Cast nötig: remove() liefert ein Object 14 14

15 Typsicherheit Antwort moderner Programmiersprachen auf die Fehlinterpretation von Daten 1. Einer Variable dürfen nur Werte ihres Typs zugewiesen werden. 2. Auf einen Wert sind nur die Operationen seines Typs anwendbar. Universelle Transporttypen (Object...) unterlaufen den ersten Aspekt, aber Explizite Typumwandlung wird vom Java-Laufzeitsystem (nachträglich) abgesichert (ClassCastException). 2. Operationssicherheit wird durch die Java-Syntax gewährleistet....trotzdem wären typsichere Datenbehälter besser... 15

16 LiFo speziell für Strings import java.util.*; // die Collections class LifoString { // interface wird nicht implementiert private List liste = new ArrayList(); public void add(string txt) { liste.add(obj,0); // vorn einfügen public String remove() { return (String)(liste.remove(0)); // vorn wegnehmen Cast nötig: remove() liefert ein Object 16 16

17 Element-Typen Die Standard-Datenbehälter arbeiten mit dem allgemeinen Element-Typ Object. Für beliebige Element-Typen verwendbar. Eintragen ist unmittelbar möglich. Man muss jedes entnommene Element "downcasten", ehe man damit arbeiten kann Typsicherheit ist nicht gegeben (aber die Typverwendung ist abgesichert) Für die Übung haben Sie einen String-Stack implementiert. Nach demselben Muster lässt sich ein Fahrzeug-, int- oder Object-Stack programmieren. Vererbung hilft nicht man muss neu programmieren. Die einzelnen Stacks sind typsicher d.h. der Benutzer kann sich darauf verlassen, Elemente des richtigen Typs zu lesen. 17

18 Die Antwort: Typ-Parametrisierung Statt einen Stack für jeden Elementtyp neu zu programmieren - kann man ihn mit dem Element-Typ parametrisieren: class Stack <Elementtyp> {... Bei der Instanziierung legt man den Elementtyp fest: Stack <String> texte = new Stack <String>(); Stack <Konto> konten = new Stack <Konto>(); In Java 8 auch: Stack <String> texte = new Stack <>(); Diamond Operator Stack <Elementtyp> ist eine generische Klasse: eine Klasse definiert mehrere Instanz-Typen. 18

19 Definition generischer Klassen statt Object wird jetzt die Typvariable T verwendet: class StackArray <T> { private T[] stack = new T[size]; private int top = 0; public void add(t elem) throws OverflowExc { if (top == size) throw new OverflowExc(); stack[top] = elem; top++; public T remove() throws UndeflowExc { if (top==0) throw new UndeflowExc(); Instanziierung: new StackArray<String>(), top --; new StackArray<Person>(), etc. return stack[top]; 19

20 Benutzung generischer Klassen new StackArray<String>(): die Typ-Variable T wird überall durch String ersetzt es können nur String -Elemente eingetragen werden (typsicher) stack.add("hallo"); // ok stack.add(new Person()); // Fehler ausgelesene Elemente haben den Typ String (ohne "downcast") String s = stack.remove(0); // ok 20

21 Präzisierung am Beispiel ArrayList Ein Blick in die (Java 5-)Dokumentation zeigt, dass der Typ ArrayList als generische Klasse definiert ist: ArrayList<E> ArrayList<E> heißt generische oder typ-parametrisierte Klasse. E heißt formaler Typ-Parameter (oder auch Typ-Variable) und steht für einen beliebigen Typ (hier als Elementtyp verwendet) E kann in der Schnittstelle von ArrayList<E> als Parameter- und Rückgabetyp vorkommen: void add(int index, E element); E remove(int index); 21

22 Typkompatibilität generischer Klassen generische Klassen sind typsicher: ArrayList<String> liste = new ArrayList<Book>; // Typfehler! ArrayList<Object> liste = new ArrayList<Book>; // Typfehler! warum? der Rückgabetyp von (z.b.) remove ist unterschiedlich, ArrayList<String> hat eine andere Schnittstelle als ArrayList<Book> 22

23 Rohe Typen ArrayList heißt "roher Typ" von ArrayList<E> ArrayList ist die gemeinsame Klasse aller ihrer parametrisierten Typen (wichtig für statische Variablen). Der Typparameter E ist überall ersetzt durch Object Der rohe Typ ist nicht identisch mit ArrayList<Object> new ArrayList(): Instanziierung des rohen Typs. Die Typ-Variable E wird überall durch Object ersetzt So haben wir den Typ bisher benutzt. Generische Typen sind mit ihrem rohen Typ zwar kompatibel, aber von einer Vermischung ist dringend abzuraten! ArrayList list = new ArrayList<String>(); // erlaubt! downcast der gelesenen Werte erforderlich: String s = (String)list.remove(10); 23

24 Rohe und parametrisierte Typen nicht mischen! ArrayList list = new ArrayList<String>(); // erlaubt! Durch Mischen roher und parametrisierter Typen geht die Typsicherheit verloren. list.add(new Auto()); // erlaubt, weil der rohe Typ // mit Object arbeitet! Rohe Typen mit allergrößter Vorsicht als universelle Transporttypen (für Objekte parametrisierter Typen) benutzen! Keine Operationen darauf anwenden, sondern Objekte vorher einer Variable geeigneten Typs zuweisen! Besser: Finger weg! 24

25 Parametrisierte Interfaces Interfaces können genauso parametrisiert sein wie Klassen: interface Container <T> { void add(t elem); T remove(); interface LiFo<T> extends Container<T> { interface FiFo<T> extends Container<T> { class StackArray<T> implements LiFo<T> {... StackArray<String> = new StackArray<String>(); 25

26 Parametrisierung im Java-Collections-Framework Die Klassen des Java-Collection-Framework befinden sich im Paket java.util Alle Klassen, Interfaces und abstrakten Klassen des Java- Collection-Frameworks sind mit dem Elementtyp parametrisiert. Bis Java 1.4 gab es nur die rohen Typen (Elementtyp Object). Das Java-Collection-Interface definiert drei Hierarchien von Datenbehältern: List, Set, Map. Wenn Sie sich mit List gut genug auskennen, erkunden Sie die anderen! 26

27 Das Interface List 27

28 Das Interface Collection 28

29 Alle Klarheiten beseitigt?...ab jetzt schauen Sie bitte ins Collections Famework, ehe Sie sich selbst einen Datenbehälter zimmern! 29 29