Programmieren in Java

Transkript

1 Datenstrukturen

2 2 Was bisher geschah Bisher wurden zur Gruppierung von Daten immer Arrays genutzt Bis auf die Index-Funktion gibt es allerdings keinerlei logischer Operationen, mit denen der Array manipuliert werden könnte Wenn die zu organisierende Menge dynamisch ist, machen Arrays einem das Leben daher schwer: Arrays sind statisch: Länge einmal festgelegt, nicht mehr änderbar Mal eben ein Element hinzufügen oder entfernen ist aufwändig Zumeist muss der Array-Inhalt kopiert werden Große Arrays großer Kopieraufwand Datentypen, die eine Menge an Daten gruppieren und auf dieser Gruppierung eine gewisse Logik bereitstellen werden Datenstrukturen genannt Datenstrukturen & Algorithmen meist eine eigene Vorlesung!

3 3 Lauf- und Zugriffszeit Wichtige Punkte bei der Auswahl einer Datenstruktur sind Laufzeit: Die Anzahl der Schritte, um ein bestimmtes Element zu finden Zugriffszeit: Schritte, um auf ein bestimmtes Element zuzugreifen Beispiel Array: Zugriffszeit: Array liegt aneinander gereiht im Speicher Zugriff: Adresse des 1. Elementes + (Position*Speichergröße(Typ)) Zugriff in einem Schritt (Notation: Ɵ(1), konstante Zugriffszeit ) Laufzeit: Im schlechtesten Fall ist das Element nicht vorhanden Um dies festzustellen muss es mit allen Elementen verglichen werden Ɵ(n), n ist die Anzahl der Elemente ( lineare Laufzeit )

4 4 Collection-API Java bietet mit der Collection-API einen Basissatz an Datenstrukturen All diese Strukturen sind dynamisch und damit flexibler als Arrays Jede der Strukturen basiert auf einem der folgenden Interfaces Collection: Interface für Listen bzw. Mengen Map: Interface für eine Gruppe assoziativ angeordneter Elemente Sowohl Collection als auch Map sind generisch, d.h. der Datentyp der Inhalte kann generisch spezifiziert werden: Collection<String> list = new LinkedList<String>(); dice("dies ist ein String der durcheinander gewürfelt wird", list); [ein, ist, gewürfelt, String, Dies, wird, der, durcheinander] LinkedList ist eine Implementierung von Collection Angenommen: dice fühlt die List in zufälliger Reihenfolge mit String- Fragmenten getrennt nach dem Leerzeichen aus dem übergebenen String

5 5 Das Interface Collection public interface Collection<E> extends Iterable<E> { boolean add(e e); boolean addall(collection<? extends E> c); boolean remove(object o); boolean removeall(collection<?> c); boolean retainall(collection<?> c); boolean contains(object o); boolean containsall(collection<?> c); int size(); boolean isempty(); void clear(); Object[] toarray(); <T> T[] toarray(t[] a); Iterator<E> iterator();

6 6 Das Interface Collection Jede Implementierung des Collection-Interfaces unterstützt das Hinzufügen und Entfernen von Elementen (einzeln oder massenhaft) Überprüfen ob gewisse Inhalte vorhanden sind Abfragen der Größe Umwandeln in einen Array Desweiteren erweitert Collection das Interface Iterable Dies schreibt die Methode iterator() vor Alle Klassen, die dieses Interface implementieren können in der foreach-schleife genutzt werden: Collection<String> list = new LinkedList<String>(); dice("dies ist ein String der durcheinander wird", list); for (String element : list) { System.out.println(element);

7 7 Listen Listen sind Collections mit einer Ordnungshierarchie Auf einen bestimmten Inhalte innerhalb der Liste kann über seinen Index (~ Position) zugegriffen werden List<String> list = new LinkedList<String>(); String fragment = list.get(3); List ist ein Interface mit verschiedenen bereits vorhandenen Implementierungen: ArrayList: das dynamische Pendant zum Array Vector: siehe ArrayList // füllen mit dice LinkedList: Die Elemente sind miteinander verkettet (nächste Folie) Sowohl ArrayList als auch Vector greifen intern auf Arrays zurück Die Unterschiede liegen in der Thread-Sicherheit (Vector) und der Art und Weise wie der interne Array verwaltet wird

8 8 LinkedList Jedes Element in der LinkedList wird in einem Node gespeichert Jeder Node kennt seinen Vorgänger und seinen Nachfolger Der erste und letzte Node sind in der Liste verlinkt Node first last data

9 9 LinkedList (Code, beispielhaft) Node-Klasse LinkedListNode public class LinkedListNode<DATA> { protected LinkedListNode<DATA> prev; protected LinkedListNode<DATA> next; protected DATA data; protected LinkedListNode( LinkedListNode<DATA> prev, LinkedListNode<DATA> next, DATA data) { this.prev = prev; this.next = next; this.data = data; Man beachte: Der Konstruktor ist protected Instanzen nur innerhalb des eigenen Paketes erzeugbar Keine Getter/Setter, da auch die Attribute protected

10 10 LinkedList (Code II, beispielhaft) public class LinkedList<DATA> /* */ { private LinkedListNode<DATA> first = null; private LinkedListNode<DATA> last = null; public LinkedList() { protected LinkedListNode<DATA> getnode(int index) { LinkedListNode<DATA> node = first; int i = 0; while (i!= index && node!= null) { node = node.next; i++; return node; public DATA get(int index) { LinkedListNode<DATA> node = getnode(index); return node == null? null : node.data;

11 11 Lauf- und Zugriffzeit (ArrayList, LinkedList) ArrayList/Vector: Intern werden die Elemente in einem Array gespeichert Zugriffszeit: Ɵ(1) Laufzeit: Ɵ(n) LinkedList Elemente sind verkettet Kein direkter Zugriff Um das n-te Element zu erreichen, muss die Kette vom ersten bis zum n-1 Element durchlaufen werden Zugriffszeit: Ɵ(n) Im schlechtesten Fall ist ein gesuchtes Element nicht vorhanden Es muss die gesamte Kette durchlaufen werden, um dies festzustellen Laufzeit: Ɵ(n)

12 12 LinkedList Suche eines Elements in einer LinkedList ist vergleichsweise langsam Das Löschen und Hinzufügen jedoch ist schneller als bei ArrayList/Vector Da jeder Node seinen Vorgänger und Nachfolger kennt, lassen sich beide Operationen durch umbiegen der Verlinkung in einem Schritt durchführen ArrayList/Vector müssen die richtige Stelle zum Löschen finden, den Array unter Umständen kopieren und neufüllen Löschen first last Hinzufügen first last

13 13 LinkedList (Code III. beispielhaft) public boolean add(int index, DATA data) { if (index < 0 index > size()) throw new IndexOutOfBoundsException(); if (first == null) { first = new LinkedListNode<>(null, null, data); last = first; return true ; if (index == size()) { last.next = new LinkedListNode<>(last, null, data); last = last.next; return true; LinkedListNode<DATA> temp = getnode(index); LinkedListNode<DATA> node = new LinkedListNode<DATA>(temp.prev, temp, data); if (temp == first) first = node; if (temp.prev!= null) temp.prev.next = node; temp.prev = node; return true;

14 14 LinkedList (Code IV) public boolean remove(int index) { if (index < 0 index >= size()) throw new IndexOutOfBoundsException(); LinkedListNode node = getnode(index); if (node.prev!= null) node.prev.next = node.next; if (node.next!= null) node.next.prev = node.prev; if (node == first) first = node.next; if (node == last) last = node.prev; return true; public int size() { LinkedListNode node = first; int size = 0; while (node!= null) { size++; node = node.next; return size;

15 15 Stack Ein Stack ist bereits im Kapitel Speichermanagement aufgetaucht Der Stack-Speicher baute sich Frame für Frame auf einer Seite des Speichers auf Nach jedem Methodenende wird der Stack auf genau der Seite wieder abgebaut Die Stack-Datenstruktur ist analog aufgebaut Auch LIFO (Last-In-Firs t-out) genannt boolean empty(); E peek (); E pop(); E push(e o); int search(object o); peek() pop() push(object) Zugriff: Ɵ(1) (es ist immer nur das letzte Element zugreifbar!) Laufzeit: Ɵ(n) (es müssen alle Elemente verglichen werden)

16 16 Queue Ähnlich dem Stack Eine Queue (Warteschlange) wird hinten auf- und vorne abgebaut Daher: FIFO (First-In-First-Out) E element(); boolean offer(e o); E peek(); E poll(); E remove(); element()/peek() offer(object) poll()/remove() Zugriff: Ɵ(1), Laufzeit: Ɵ(n) (beides, analog zum Stack)

17 17 Set Spezielle Collection mit der Einschränkung: Jedes Element in der Menge ist eindeutig, d.h. es gibt keine zwei Element e1 und e2 für die gilt e1.equals(e2) == true Sets müssen nicht zwangsläufig geordnet sein Zugriffs- und Laufzeit variieren wie schon bei der Liste je nach Implementierung

18 18 Map Der Datentyp Map wird auch als assoziativer Speicher bezeichnet Jedes Element in der Map ist eindeutig über einen Schlüssel assoziiert Eine Map enthält demnach Schlüssel-Wert Paare Key 1 Value 1 Key 2 Value 2 Key 3 Value 3 Key 4 Value 4 Key n Value n public interface Map<K,V> { int size(); boolean isempty(); boolean containskey(object key); boolean containsvalue(object value); V get(object key); V put(k key, V value); V remove(object key); void putall(map<? extends K,? extends V> map); void clear(); Set<K> keyset(); Collection<V> values(); Set<Map.Entry<K, V>> entryset;

19 19 HashMap Intern verwaltet als Array Eine Hashfunktion weißt jedem Schlüssel einen eindeutigen Index zu Eingabe der Hashfunktion ist der Hashwert (hashcode()) eines Objektes Schwierigkeit: Hashfunktion sollte injektiv sein, damit nicht zwei verschiedenen Schlüsseln der gleiche Index zugewiesen wird Eine HashMap ist unsortiert In der Regel keine Rückwärtsassoziation zwischen Wert und Schlüssel Zugriffszeit: Schlüssel wird über die Hashfunktion zu Index des internen Arrays Ɵ(1) Laufzeit: Suche nach Schlüssel: Schlüssel Hashfunktion Index Array[Index] Ɵ(1) Suche nach Wert: Ɵ(n)

20 20 TreeMap Schlüssel und Wert in einem Knoten gespeichert (vgl. LinkedList ) Jeder Knoten hat zwei Kindknoten Links: Schlüssel ist kleiner als der eigene Schlüssel Rechts: Schlüssel ist größer als der eigene Schlüssel Neue Elemente werden an den Blattknoten eingefügt (evtl. Umsortieren) Beispiel: Suche nach Pampelmuse H < M Schlüssel Mandarine data Daten T > M Himbeere data Traube data Ananas Kiwi Pampelmuse Zwetschge data data data data Lauf/Zugriffszeit: Ɵ(log(n)) (ohne Beweis)

21 21 Immutable/Hash/Equals Objekte werden als immutable bezeichnet, wenn sie nach ihrer Erzeugung nicht mehr geändert werden können Beispiel: Strings Solange ein Objekt sich nicht ändert, muss seine hashcode-methode immer den gleichen Wert liefern Wenn zwei Objekte unter equals gleich sind, müssen Ihre Hash-Werte übereinstimmen Die equals-methode wird daher häufig in Abhängigkeit zu Attributwerten definiert Hier ist vor allem im Hinblick auf HashMaps und Sets Vorsicht geboten: Da die Eindeutigkeitsforderung auf Basis von equals überprüft wird, sollten Sets nur unveränderbare Werte enthalten In Hashes werden die Werte über den Hash-Wert eines Schlüssel assoziiert, auch hier sollte der Hash-Wert und damit der Schlüssel nicht veränderbar sein

22 22 Iterator Zu Anfang wurde erwähnt, das Collections das Iterable-Interface implementieren So sind Collections für die foreach-schleife einsetzbar Jede Collection bietet mit iterator() allerdings die Möglichkeit direkt auf einen Iterator zuzugreifen: Iterator<String> iterator = list.iterator(); String string; while (iterator.hasnext()) { string = iterator.next(); iterator.remove(); Vorteil: Die meisten Iterator bieten die Möglichkeit während der Iteration Einträge aus der Collection zu löschen In einer foreach-schleife nicht möglich: ConcurrentModificationException

23 23 Comparator Ein Comparator vergleich zwei Elemente gleichen Typs per compare( ) Falls beide Elemente gleich sind (equals) liefert er 0 Falls das erste Argument kleiner ist als das zweite eine Zahl < 0 Ansonsten > 0 Es muss dabei immer gelten: sign( compare( x, y)) 1* sign( compare( y, x)) compare( x, y) 0 compare( y, z) 0 compare( x, z) 0 Mit Hilfe von Comparatoren und der Hilfs-Klasse Collections können Listen relative einfach sortiert werden: List<String> list = new LinkedList<String>(); dice( Dies ist ein String der durcheinander gewürfelt wird", list); Collections.sort(list, new StringComparator());

24 24 String-Comparator public static class StringComparator implements Comparator<String> { public int compare(string string1, String string2) { int len1 = string1.length(); int len2 = string2.length(); int lim = Math.min(len1, len2); char v1[] = string1.tochararray(); char v2[] = string2.tochararray(); int k = 0; while (k < lim) { char c1 = v1[k]; char c2 = v2[k]; if (c1!= c2) return c1 - c2; k++; return len1 - len2;

25 25 Generics/Wildcards Zurück zur Definition des Collection-Interfaces public interface Collection<E> extends Iterable<E> { boolean addall(collection<? extends E> c); Mit extends konnten generische Datentypen eingeschränkt werden Hier wird extends dazu genutzt um eine Wildcard einzuschränken Die Methode addall akzeptiert also alle Collections, die mindestens Daten vom Typ E enthalten Aber warum genügt nicht: boolean addall(collection<e> c);

26 26 Generics/Wildcards Angenommen: List<Comparable> list1 = new ArrayList<>(); List<String> list2 = new ArrayList<>(); public static void sort(list<comparable> list) {Collections.sort(list); Die Signatur von String: public final class String implements Comparable<String>, Es gilt also: String ist vom Typ Comparable Invarianz: List<Comparable> nicht durch List<String> ersetzbar Die sort-methode ist daher auf List<Comparable> eingeschränkt Während diese Einschränkung zu restriktiv ist, würde eine einfache Wildcard nicht garantieren, dass nur Comparable Objekte in der Liste sind Daher besteht die Möglichkeit auch Wildcards einzuschränken: public static void sort(list<? extends Comparable> list) {Collections.sort(list);

27 27 Generics/Wildcards Angenommen: public static void extract( Comparable data, List<? extends Comparable> src, List<? extends Comparable> dest ) extract soll alle Daten aus src nach dest kopieren, die gleich data sind Der Versuch Daten aus src nach dest zu kopieren, wird zum Compiler- Fehler führen Beispiel: List<String> src = new ArrayList<>(); List<Integer> dest = new ArrayList<>(); String und Integer sind beide vom Typ Comparable Integer ist allerdings nicht vom Typ String Ein String-Objekt kann nicht ein eine Integer-Liste einfügt werden Compiler kann nicht sicherstellen, dass src und dest kompatibel sind

28 28 Generics/Wildcards Mit super können Wildcards nach unten beschränkt werden: public static void extract( Comparable data, List<? extends Comparable> src, List<? super Comparable> dest ) Nach unter heißt: Comparable oder alle Superklassen Der Compiler weiß nun, dass die Typsicherheit auf jeden Fall nicht durchbrochen werden kann: Objekte aus src sind Comparable und dest enthält maximal Comparable List<String> src = new ArrayList<>(); List<Object> dest = new ArrayList<>(); Faustregel: Zum lesenden Zugriff: extends Zum schreibenden Zugriff: super