java.util. Sebastian Draack Department Informations- und Elektrotechnik Department Informations- und Elektrotechnik JAVA Collection-API

Transkript

1 Sebastian java.util.* Draack JAVA Collection-API 1

2 Collection-API Begriffe Einleitung, Motivation Iterator Comparator Interfaces Abstrakte Klassen Konkrete Klassen Utility-Klassen Beispiele Zusammenfassung Fragen 2

3 Begriffe Collection: Kollektion, Sammlung API: Application Programming Interface (Programmierschnittstelle) 3

4 Speichern von Daten Variablen Arrays Strukturen (C) Objekte Container / Collections int, float, double int[], float[], double[] struct public class? 4

5 Strukturieren von Daten Effektive Algorithmen benötigen strukturierte Daten 5

6 Compare Comparable Comparator Eclipse Beispiel public interface Comparable<T> { int compareto(t o); } public interface Comparator<T> { int compare(t o1, T o2); } 6

7 Iterate Iterable Iterator public interface Iterator<E> { boolean hasnext(); E next(); void remove(); //optional } List<String> list = new LinkedList<String>(); list.add("..."); Iterator<String> it = stringlist.iterator(); while (it.hasnext()) { String str = it.next(); System.out.println("String: "+ str); } public interface ListIterator<E> extends 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 } Eclipse Beispiel 7

8 Collection API - Übersicht Handout + 8 Quelle:

9 Interfaces Collection List Set Map 9

10 Interface Collection Optionale Methoden werfen ggf. OperationNot- SupportedExceptions 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); //o boolean removeall(collection<?> c); //optiona boolean retainall(collection<?> c); //optional void clear(); //optional // Array operations Object[] toarray(); <T> T[] toarray(t[] a); 10 }

11 Interface List Optionale Methoden werfen ggf. OperationNot- SupportedExceptions public interface List<E> extends Collection<E> { // Basic operations 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(); 11

12 Interface Set Optionale Methoden werfen ggf. OperationNot- SupportedExceptions 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); //o boolean removeall(collection<?> c); //optiona boolean retainall(collection<?> c); //optional void clear(); //optional // Array Operations Object[] toarray(); <T> T[] toarray(t[] a); 12 }

13 Interface Map Optionale Methoden werfen ggf. OperationNot- SupportedExceptions 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); } 13 }

14 Interface Queue FIFO-Prinzip public interface Queue<E> extends Collection<E> E element(); boolean offer(e e); E peek(); E poll(); E remove(); } Mit Exception Null statt Exception enqueue add() offer() dequeue element() peek() delete remove() poll() 14

15 Interface Deque FIFO-Prinzip & LIFO-Prinzip Mit Exception Null statt Exception enqueue addfirst/last() offerfirst/last() dequeue getfirst/last() peekfirst/last() delete removefirst/last() pollfirst/last() public interface Queue<E> extends Collection<E> { boolean add(e e); void addfirst(e e); void addlast(e e); boolean contains(object o); Iterator<E> descendingiterator(); E element(); E getfirst(); E getlast(); Iterator<E> iterator(); boolean offer(e e); boolean offerfirst(e e); boolean offerlast(e e); E peek(); E peekfirst(); E peeklast(); E poll(); E pollfirst(); E polllast(); E pop(); E push(); E remove(); int size(); } 15

16 Abstrakte Implementierungen AbstractCollection AbstractSet AbstractList AbstractSequentialList AbstractMap AbstractQueue 16

17 AbstractCollection Implementierung import java.util.iterator; public class ClassName extends public Iterator<E> iterator() { // TODO Auto-generated method stub return null; } public int size() { // TODO Auto-generated method stub return 0; } 17

18 AbstractSet Implementierung import java.util.iterator; public class ClassName extends public Iterator<E> iterator() { // TODO Auto-generated method stub return null; } public int size() { // TODO Auto-generated method stub return 0; } 18

19 AbstractList Implementierung public class ClassName extends java.util.abstractlist<e> public E get(int arg0) { // TODO Auto-generated method stub return null; public int size() { // TODO Auto-generated method stub return 0; } } 19

20 AbstractSequentialList Implementierung import java.util.listiterator; public class ClassName extends public ListIterator<E> listiterator(int index) { // TODO Auto-generated method stub return null; } public int size() { // TODO Auto-generated method stub return 0; } 20

21 AbstractMap Implementierung import java.util.set; public class ClassName extends java.util.abstractmap<k, V>{ public Set<java.util.Map.Entry<K, V>> entryset() { // TODO Auto-generated method stub return null; } 21

22 AbstractQueue Implementierung 22

23 Collection API Classes I Listen (List) Mengen (Set) ArrayList LinkedList HashSet TreeSet LinkedHashSet Implementiert Listen-Funktionalität durch die Abbildung auf ein Feld; implementiert die Schnittstelle List. LinkedList ist eine doppelt verkettete Liste, also eine Liste von Einträgen mit einer Referenz auf den jeweiligen Nachfolger und Vorgänger. Das ist nützlich beim Einfügen und Löschen von Elementen an beliebigen Stellen innerhalb der Liste. Eine Implementierung der Schnittstelle Set durch ein schnelles Hash-Verfahren. Implementierung von Set durch einen Baum, der alle Elemente sortiert hält. Eine schnelle Mengen- Implementierung, die sich parallel auch die Reihenfolge der eingefügten Elemente merkt. 23

28 Collection API Classes II Assoziativspeicher (Map) Schlange (Queue) HashMap TreeMap LinkedHashMap WeakHashMap LinkedList ArrayBlockingQueue PriorityQueue Implementiert einen assoziativen Speicher durch ein Hash-Verfahren. Exemplare dieser Klasse halten ihre Elemente in einem Binärbaum sortiert; implementiert NavigableMap. Ein schneller Assoziativspeicher, der sich parallel auch die Reihenfolge der eingefügten Elemente merkt. Verwaltet Elemente mit schwachen Referenzen, sodass die Laufzeitumgebung bei Speicherknappheit Elemente entfernen kann. Die verkettete Liste implementiert Queue und auch Deque. Eine blockierende Warteschlange. Prioritätswarteschlange. 28

35 Synchronisiert? 35

36 Interfaces & Implementierungen (General-Purpose) Interface Implementierung Array List Tree Hastable Hashtable + LinkedList List ArrayList LinkedList Set TreeSet HashSet LinkedHashSet Map TreeMap HashMap LinkedHashMap Queue LinkedList 36

37 Interfaces & Implementierungen (General-Purpose) Implementierung Vorteile / schnell Nachteile / langsam Anmerkungen ArrayList Lesen [O(1)] Löschen, Einfügen [O(n)] Einfach zu implementieren LinkedList Einfügen, Löschen [O(1)] Lesen [O(n)] Einfach zu implementieren TreeSet Standard-Operationen [O(log n)] TreeMap Standard-Operationen [O(log n)] HashSet Standard-Operationen [O(1)] Keine garantierte Ordnung, dyn. Erweiterung Assoziativ HashMap Standard-Operationen [O(1)] Assoziativ Linked Iterierung über Einfüge- Reihenfolge 37

38 Wie bitte? 38

39 Hashing Balanced Trees 39

40 Legacy Implementations Vector Hashtable 40

41 Legacy Implementations Vector Hashtable Altlasten 41

42 Special Purpose Implementations WeakHashMap IdentityHashMap 42

43 Special Purpose Implementations WeakHashMap (Wenn keine Referenz auf Value: Garbage Collection) IdentityHashMap (Kann enthalten: Mehrere Objekte die equal, aber nicht == sind.) Spezielle Zwecke 43

44 Utility-Klasse Collections Ausschließlich statische Methoden Collections.sort(List<T> list) // Sortieren Collections.shuffle(List<?> list) // Mischen Collectins.binarySearch(List<? extends Comparable<? super T>> list, T key) // Binaere Suche benoetigt Sortierung Collections.reverse(List<T> list) // Umkehren Collections.swap(List<?> list, int i, int j) // Tauschen Collections.frequency(Collection<?> c, Object o) // Zaehlen Collections.disjoint(Collection<?> c1, Collection<?> c2) // Schnittmenge Collections.min(Collection<?> coll), Collectins.max(Collection<?> coll) // Extrema Collections.replaceAll(List<T> list, T oldval, T newval) // Ersetzen 44

45 Utility-Klasse Arrays Ausschließlich statische Methoden Arrays.sort(T[] a, Comparator <? super T> c) // Sortierung mittels Comparator Arrays.asList(T... a); // Konvertierung in Liste

46 Beispiel Threads 46

47 Zusammenfassung 47

48 Fragen 48

49 Quellen Abbildungen Internetquellen: Verfügbarkeit geprüft am um 15:45 Uhr 49

50 Vielen Dank für Ihre Aufmerksamkeit. 50