CS1005 Objektorientierte Programmierung Bachelor of Science (Informatik)

Transkript

1 CS1005 Objektorientierte Programmierung Bachelor of Science (Informatik) Klassenbibliothek Kollektionen Anforderungen der Kollektionen an ihre Elemente Iteratoren Seite 1

2 Klassenbibliothek Seite 2

3 Java = Sprache + Bibliothek Java = Sprachkern + Klassenbibliothek Klassenbibliothek Sammlung von vordefinierten Klassen für allgemeine wiederkehrende Aufgaben Java Klassenbibliothek definiert als <Java Versionsbezeichnung> API Specification z.b. Java Platform Standard Edition 6.0 API Specification siehe java.sun.com/docs, realisiert in den Java-Distributionen z.b. JDK (Java Development Kit 1.6.0) organisiert in Pakete java.applet... viele viele weitere Pakete mit vielen Klassen... org.xml.sax.helpers Seite 3

4 Klassenbibliothek Klassenbibliothek Organisiert in Pakete Beispiel-Pakete jeweils mit einer Beispiel-Klasse und einer Beispiel-Methode javax.swing JOptionsPane JOptionsPane.showMessageDialog java.lang Integer Integer. parseint java.util Arrays Arrays.sort Seite 4

5 Klassenbibliothek wichtige Pakete der Klassenbibliothek java.lang enthält Dinge von fundamentaler Bedeutung, z.b.: Integer Math Object... java.util allgemein verwendbare Hilfsklassen (Utilities) speziell für die Arbeit mit Feldern und anderen Kollektionen, z.b.: Arrays Collections ArrayList HashSet... java.awt, javax.swing enthält Nützliches zur Konstruktion graphischer Oberflächen Seite 5

6 Klassenbibliothek: API Doku immer bereit halten! Seite 6

7 Kollektionen Seite 7

8 Kollektionen Kollektionen (Collection): Abstrakte Datentypen zur Verwaltung von Elementen in Java nicht als vordefinierte Sprachelemente verfügbar, sondern als Bestandteil der Standard-Bibliothek Beispiele: Mengen, Listen, Abbildungen Java-Klassenbibliothek Paket java.util enthält Schnittstellen und Klassen zum Umgang mit Kollektionen Collection Framework: Zusammenhängendes System aus Klassen- und Schnittstellendefinitionen in der Klassenbibliothek Kollektionstypen der Java-Klassenbibliothek gibt es in drei Grund-Varianten List Set Map Listen Mengen Abbildungen Seite 8

9 Kollektionen: Liste ArrayList (java.util.arraylist) Als Typ einer Variablen oder eines Parameters möglichst ein Interface verwenden! Eine Klasse die den ADT Liste auf Basis von Arrays implementiert import java.util.arraylist; import java.util.list; jede Art Integer-Liste ist willkommen public final class Test { public static void lister(list<integer> l){ for (Integer i : l) System.out.println(i); jede Art Integer-Liste ist als Wert erlaubt public static void main(string[] args) { List<Integer> l = new ArrayList<Integer>(); l.add(5); lister(l); eine Array-basierte Implementierung von ArrayList als List-Implementierung Seite 9 Liste erzeugen

10 Kollektionen: Liste import import import import import java.io.file; java.util.arraylist; java.util.collections; java.util.list; javax.swing.jfilechooser; Beispiel: MP3-Dateien in einem Verzeichnis sortiert auflisten public final class MusicCollection { private MusicCollection() { private static File choosefile(string msg) { JFileChooser fc = new JFileChooser(); fc.setfileselectionmode(jfilechooser.directories_only); int returnval = fc.showdialog(n ull, msg); if (returnval == JFileChooser.APPROVE_OPTION) { ret urn fc.getselectedfile(); else { retur n n ull; public static void main(string[] args) { File directory = choosefile("verzeichnis mit Musik"); Liste erzeugen: Größe nach Bedarf! Element zu Liste hinzu fügen List<String> songs = new ArrayList<String>(); for (String filename : directory.list()) { if (filename.endswith(".mp3")) { songs.add(filename.trim()); Collections. sort (songs); Liste sortieren for (String song : songs) { String[] splited = song.split("\\s+-\\s+"); Liste durchlaufen if (splited.length >= 2) { System.out.println("Interpret : "+splited[0]+"\n\ttitel: "+ splited[1]); else { System.out.println(song); Seite 10

11 <<interface>> Kollektionen: Liste List java.util.list, java.util.arraylist, ArrayList java.util.linkedlist LinkedList... List<Integer> l = new Liste(); List<Integer>();... ein Interface hat keine Objekte!... List<Integer> l = null; l = new ArrayList<Integer>(); l = new LinkedList<Integer>();... eine Variable mit Interface-Typ kann mit allen passenden Implementierungen belegt werden public void m(list<integer> l){... l. listmethode m( new ArrayList<Integer>() );... m( new LinkedList<Integer>() );... eine Methode mit Parameter mit InterfaceTyp kann mit allen passenden ParameterImplementierungen umgehen Seite 11

12 <<interface>> Kollektionen: Liste List java.util.list<e> ArrayList generischer ADT Liste Verwendung LinkedList Datentyp mit Listeneigenschaft-Eigenschaft: linear sortierte Folge mit Sortierung unter der Kontrolle der Anwendung Liste: Konzept / ADT-Sicht 1) 2) 3) 4) 5) 6) A B C D K L java.util Interface List<E> Liste: Benutzer-kontrollierte Folge von Elementen: Die Position von x in einem List-Typ hängt davon ab, wohin die Anwendung es positioniert. Seite 12

13 <<interface>> Kollektionen: Liste List java.util.arraylist<e> ArrayList ist die Array-Implementierung (Datenstruktur Feld/Array) eines generischen ADT Liste LinkedList Verwendung Datentyp mit Listeneigenschaft-Eigenschaft: linear sortierte Folge mit Sortierung unter der Kontrolle der Anwendung Datenstruktur Array: schnelles indiziertes Zugreifen, kompakte Speicherung Einfügen nicht häufig 1) 2) 3) 4) Liste Konzept / 5) ADT-Sicht 6) A B C D K L Liste Datenstruktur-Sicht: Array-Implementierung Seite 13 java.util Class ArrayList<E> LinkedList wenn oft indiziert zugegriffen und selten eingefügt / entfernt wird. A B C D K L

14 <<interface>> Kollektionen: Liste List java.util.linkedlist<e> ArrayList ist die Zeiger-Implementierung (Datenstruktur verkettete Liste) eines generischen ADT Liste LinkedList Verwendung Datentyp mit Listeneigenschaft-Eigenschaft: linear sortierte Folge mit Sortierung unter der Kontrolle der Anwendung Datenstruktur verkettete Liste: schnelles Einfügen / Entfernen an beliebigen Positionen 1) 2) 3) 4) Liste 5) Konzept / ADT-Sicht 6) A B C D K L java.util Class LinkedList<E> LinkedList wenn oft eingefügt / entfernt und selten indiziert zugegriffen wird. A B C D K L Liste Datenstruktur-Sicht: Implementierung als verkettete Liste Seite 14

15 Kollektionen: List, ArrayList und LinkerdList ArrayList Array-basierte Listenimplementierung schneller Zugriff / weniger Speicherbedarf aufwendiges Einfügen / Entnehmen (Umkopieren, eventuell neu anlegen) List-Interface ArrayList LinkedList Durch Referenzen verkettete Elemente Zugriff langsam / mehr Speicherplatz Einfügen / Entnehmen schnell List-Interface LinkedList Seite 15

16 Kollektionen: Abbildung (Map) <<interface>> Map java.util.map<k,v> TreeMap generischer ADT Abbildung HashMap Beispiel: HashMap<String, Integer> map = new HashMap<String, Integer>(); //Werte eintragen map.put("peter", 4711); map.put("inge", 8150); map.put("klaus", 2222); java.util Interface Map<K,V> //Wert zu eine Schluessel System.out.println( "Klaus hat die Nr: " + map.get("klaus") ); Seite 16

17 Kollektionen: Abbildung (Map) File directory = choosefile("verzeichnis mit Musik"); Map<String, List<String>> songdirectory = new HashMap<String, List<String>>(); for (String filename : directory.list()) { if (filename.endswith(".mp3")) { int idot = filename.lastindexof('.'); filename = filename.substring(0, idot); Abb: Interpret ~> Liste der Titel String[] splited = filename.trim().split("\\s+-\\s+"); String interpret = null; String titel = null; if (splited.length >= 2) { interpret = splited[0]; titel = splited[1]; for (int i = 2; i < splited.length; i++) { titel = splited[1] + splited[i]; else { interpret = "Unbekannt"; titel = filename.trim(); List<String> songs = songdirectory.get(interpret); if (songs == null) { songs = new LinkedList<String>(); Liste der Titel von interpret songdirectory.put(interpret, songs); songs.add(titel); songdirectory.put(interpret, songs); for (String i : songdirectory.keyset()) { System.out.println("Interpret : " + i); for (String t : songdirectory.get(i)) { System.out.println("\t" + t); Menge der Schlüssel der Abb. (die Interpreten) Beispiel: MP3-Dateien in einem Verzeichnis sortiert nach Interpret ausgeben Seite 17

18 Kollektionen: Abbildung (Map) <<interface>> Map java.util.treemap<k,v> TreeMap ist die Baum-Implementierung (Datenstruktur Baum) eines generischen ADT Abbildung HashMap Verwendung Datentyp mit Abbildungstyp-Eigenschaft: Abbildung von K-Objekten auf V-Objekte (Key, Value) z.b. Name (String) Telefonnummer (Integer) Datenstruktur Baum: schnelles Einfügen und Suchen sortierte Steicherung Abbildung: Konzept / ADT-Sicht A B C D K L X Y Z U V W java.util Class TreeMap<K,V> C Z K V A X Abbildung, Datenstruktur-Sicht: BaumImplementierung Seite 18 B Y D U L W

19 Kollektionen: Abbildung (Map) <<interface>> Map java.util.hashmap<k,v> TreeMap ist die Hash-Implementierung (Datenstruktur Hash-Tabelle) eines generischen ADT Abbildung Verwendung Datentyp mit Abbildungstyp-Eigenschaft: HashMap Abbildung von K-Objekten auf V-Objekte (Key, Value) z.b. Name (String) Telefonnummer (Integer) java.util Class HashMap<K,V> Datenstruktur Hash-Tabelle: schnelles Einfügen und Suchen Abbildung: Konzept / ADT-Sicht A B C D K L X Y Z U V W HashCode der Keys Abbildung, datsnstrutur-sicht: Hash-TabellenImplementierung Seite 19 D U C Z K V A X B Y L W

20 Kollektionen: Menge (Set) <<interface>> Set java.util.set<e> TreeSet generischer ADT Menge (keine Duplikate, Verzicht auf Benutzer-gesteuerte Reihenfolge der Elemente) HashSet Beispiel: Set<Integer> primzahlen = new TreeSet<Integer>(); Scanner scan = new Scanner(System.in); java.util Interface Set<E> for (int i = 0; i < 10; i++) { Integer z = scan.nextint(); if (prim(z)) { primzahlen.add(z); A C K D L B Sets nimmt man nicht nur, wenn man Mengen benötigt, sondern auch, wenn Dinge sortiert aufbewahrt werden sollen, ihre Sortierung aber rein intern sein kann. D.h. wenn für die Anwendung die Art (Reihenfolge) der Speicherung nicht interessant ist und die Implementierung darum nach eigenen Vorstellungen speichern darf. Das macht eventuell ein sehr effizientes (weil von der Bibliothek implementiertes) Suchen und Einfügen möglich. Seite 20 Menge: Konzept / ADT-Sicht

21 Kollektionen: Menge (Set) <<interface>> Set java.util.treeset<e> TreeSet ist die Baum-Implementierung (Datenstruktur Baum) eines generischen ADT Menge (~ BaumMenge von oben) HashSet Verwendung Datentyp mit Mengen-Eigenschaft (keine Duplikate) Verwendung einer Menge statt Liste: java.util mit interner Sortierung Class TreeSet<E> schnelles Suchen C K A Menge: Konzept / ADT-Sicht A C K D L B Menge, Datenstruktur-Sicht: BaumImplementierung Seite 21 B D L

22 Kollektionen: Menge (Set) <<interface>> Set java.util.hashset<e> ist die Hash-Implementierung (Datenstruktur Hash-Tabelle) eines generischen ADT Menge Verwendung Datentyp mit Mengen-Eigenschaft Datenstruktur Hash-Tabelle: schnelles Einfügen, Entfernen und Suchen keine interne Sortierung HashCode der Elemente Menge: Konzept / ADT-Sicht A C K D L B Menge Datenstruktur-Sicht: Hash-TabellenImplementierung Seite 22 TreeSet HashSet java.util Class HashSet<E> D C K A L B

23 Helferklasse Collections Collections Helfer-Klasse aus java.util arbeitet auf Kollektionen (z.b. ArrayList) vergleichbar mit der Klasse Arrays für Felder List<Integer> l = new ArrayList<Integer>();... l fuellen... // l sortieren: Collections.sort(l); // l ausgeben: System.out.println(a.toString()); Seite 23

24 Helferklasse Arrays Arrays Helfer-Klasse aus java.util mit statischen Methoden ist kein Array! Collections Helfer-Klasse aus java.util mit statischen Methoden ist keine Kollektion! Collection Basis-Interface für List und Set Kollektion, Kollektions-Typen Kollektion, Collection: Sammelbegriff für vordefinierte Klassen der Bibliothek Alternativen zu array definiert im Paket java.util Beispiel einner Kollektionsklasse: ArrayList Seite 24

25 Collections Framework: Übersicht Framework (Rahmen): System vorgegebener Definitionen in die eigene Implementierungen eingepasst werden. aus Die Interfaces Set / List / Map /... beschreiben Funktionalitäten, die auf unterschiedliche Art in Klassen implementiert sind. Collection Set... Map List ArrayList LinkedList Seite LinkedHashMap...

26 Collections Framework: Namenskonvention Namenskonvention: Implementierungs-Art Implementiertes Interface Beispiele: ArrayList LinkedList HashMap TreeMap HashSet TreeSet Seite 26

27 Collections: Referenz-Semantik In einer Kollektion werden stets nur Referenzen gespeichert ArrayList<Integer> l = new ArrayList<Integer>(); l.add( 128 ); l.add( 128 ); l if ( l.get(0) == l.get(1) ) System.out.println( l.get(0)+" = "+l.get(1) ); else System.out.println( l.get(0)+"!= "+l.get(1) ); if ( l.get(0).equals(l.get(1)) ) System.out.println( l.get(0)+" equals "+l.get(1) ); else System.out.println( l.get(0)+"!equals "+l.get(1) ); Ausgabe: Seite 27 null != equals 128

28 Generische und nicht generische Kollektionen generische Kollektion keine primitiven Typen hier! (ab Java 5) Kollektion mit festgelegtem ElementTyp. Element-Typ nicht primitiv! nicht generische Kollektion Element-Typ wird nicht explizit angegeben Kollektion kann Elemente unterschiedlichen Typs aufnehmen. Keine primitiven Typen in Kollektionen! ArrayList<Integer> l = new ArrayList<Integer>(); l.add(1); l.add("hallo"); ArrayList l = new ArrayList(); l.add(1); //l.add(new Integer(1)); l.add("hallo"); Autoboxing: automatische Konversion int => Integer Im Normalfall (kein Typenmix) generische Kollektionen verwenden! Seite 28

29 Nun, wer hat denn brav sein equals implementiert? Kollektionen: Anforderungen an die Elemente Seite 29

30 Hashing Hashing: Methode zur Speicherung von Zuordnungen: Schlüssel Wert Das Hashverfahren beruht auf einer Schlüsseltransformation. Dem Schlüssel (beliebiges Objekt) wird dabei eine Schlüsselwert (int-wert) zugeordnet Die Speicheradresse eines Datensatzes wird ohne zusätzliche Hilfsstrukturen aus dem Schlüsselwert berechnet. (Beispielsweise als Index in einem Array, der Hashtabelle.) Die Beziehung zwischen Schlüsselwert und Speicheradresse wird durch eine Hashfunktion hergestellt. Die Anwendung dieser Funktion auf den Schlüsselwert ergibt die Speicheradresse Seite 30 java.util Class HashMap<K,V> java.util Class HashSet<E> ''Hallo'' => hash(''hallo'') = 4711 => hashtable[4711] -> ''Hallo''

31 Hashing: Anforderungen an die Element-Typen java.util.hashset<e> java.util.hashmap<k,v> E bzw. K sollten die Methode equals implementieren E bzw. K sollten die Methode hashcode implementieren beide Methoden sollten verträglich sein: x.equals(y) => x.hashcode() == y.hashcode() gleiche Elemente haben den gleichen Hash-Code java.util Class HashMap<K,V> java.util Class HashSet<E> siehe API-Doku zu java.lang Interface Comparable<T>: It is strongly recommended (though not required) that natural orderings be consistent with equals. This is so because sorted sets (and sorted maps) without explicit comparators behave "strangely" when they are used with elements (or keys) whose natural ordering is inconsistent with equals. In particular, such a sorted set (or sorted map) violates the general contract for set (or map), which is defined in terms of the equals method. Seite 31

32 Hashing: Anforderungen an die Element-Typen Definition einer hashcode-methode Der Hashcode eines Objekts darf nur von den für equals relevanten Objektvariablen beeinflusst werden Objekte die gleich sind (entspr. equals) müssen den gleichen hash-code liefern Der Hashcode eines Objekts kann beispielsweise wie folgt berechnet werden: Berechne den Hashcode jeder relevanten Objektvariablen f wie folgt: boolean f => (f? 1 : 0) byte f, int f, short f => (int) f long f => f^(f>>>32)) float f => Float.floatToBits(f) double f => Double.doubleToLongBits(f)^(Double.doubleToLongBits(f)>>>32) AClass f => (f == 0? 0 : f.hashcode()) Atype[] f => Verfahre mit den Elementen wie mit Objektvariablen Berechne den Hashcode des Objekts aus dem seiner Felder mit int res = 1 für jeden Hashcode c eines Felds res = 31 * res + c Seite 32

33 equals / hashcode Wer equals sagt, der muss auch hashcode sagen! public class Person { private String vorname; private String nachname; public Person(String vorname, String nachname){ this.vorname = vorname; this.nachname = nachname; public String tostring(){ return vorname+" "+nachname; public boolean equals(object o){ if (!(o instanceof Person) ) return false; Person p = (Person)o; if (vorname.equals(p.vorname) && nachname.equals(p.nachname)) return true; else return false; public int hashcode(){ return 31*vorName.hashCode() +nachname.hashcode(); Seite 33 Selbst definierte Klassen, die als Schlüssel (Key) einer HashMap oder Element eines HashSet auftreten, sollen equals und hashcode konsistent definieren. Vordefinierte Klassen von Java erfüllen diese Anforderung.

34 Trees: Anforderungen an die Element-Typen java.util.treeset<e> java.util.treemap<k,v> E bzw. K sollte die Schnittstelle Comparable implementieren damit ein sortierter Suchbaum aufgebaut werden kann die Methode equals von E bzw. K sollte dazu passen x.equals(y) <=> x.compareto(y) == 0 was gleich ist, sollte die gleiche Ordnungsposition haben und umgekehrt Seite 34 java.util Class TreeSet<E> java.util Class TreeMap<K,E>

35 Vergleichbarkeit java.lang interface Comparable<T> int compareto(t o) allgemeine Vergleichbarkeit x.compareto(y) < 0 x.compareto(y) = 0 x.compareto(y) > 0 x < y x == y x > y <, >, == ist nur auf wenigen primitiven Typen definiert. Instanzen von Klassen werden mit compareto verglichen. Diese Methode ist auf Klassen Standard-Klassen wie Integer, String,... vordefiniert. Eine Klasse erklärt, dass ihre Objekte vergleichbar, sind sie also compareto zur Verfügung stellt, indem sie die Schnittstelle Comparable implementiert. z.b: class C implements Comparable<C> {... int compareto(c c) { Seite 35

36 Übersicht: Anforderungen an die Element-Typen java.util.arraylist<e> E sollte die Methode equals implementieren java.util.linkedlist<e> E sollte die Methode equals implementieren java.util.treeset<e> E sollte die Schnittstelle Comparable implementieren die Methode equals sollte dazu passen java.util.hashset<e> E sollte die Methoden equals und dazu passend hashcode implementieren java.util.treemap<k,v> K sollte die Schnittstelle Comparable implementieren die Methode equals sollte dazu passen java.util.hashmap<k,v> K sollte die Methoden equals und dazu passend hashcode implementieren Seite 36

37 equals / compareto : Beispiel 1 public class Person implements Comparable<Person> { private String vorname; private String nachname; public Person(String vorname, String nachname) { this.vorname = vorname; this.nachname = nachname; public String tostring() {return vorname + " " + nachname; public boolean equals(object o) { if (!(o instanceof Person)) return false; Person p = (Person) o; if (vorname.equals(p.vorname) && nachname.equals(p.nachname)) return true; else return false; public int compareto(person p) { return nachname.compareto(p.nachname)!= 0? nachname.compareto(p.nachname) : vorname.compareto(p.vorname); public static void main(string[] args) { TreeSet<Person> s = new TreeSet<Person>(); s.add(new Person("Minni", "Maus")); s.add(new Person("Peter", "Pan")); s.add(new Person("Micky", "Maus")); s.add(new Person("Charly", "Brown")); for ( Person p : s) System.out.println(p); Seite 37 Selbst definierte Klassen, die als Element einer sortierten Menge (TreeSet) oder als Schlüssel einer sortierten Abbildung (TreeMap) auftreten, sollen equals und compareto konsistent definieren. Vordefinierte Klassen von Java erfüllen diese Anforderung. Selbst geschriebene Klassen sollten sie auch erfüllen! 36

38 equals / compareto / hashcode : Beispiel 2 (1) /** * Zweidimensionale Vektoren. * Ein Objekt dieser Klasse realisiert einen Vektor in der Ebene in karthesischer Darstellung. * * Achtung: Diese Klasse hat eine natuerliche Ordung die nicht konsistent ist mit equals! * Note: This class has a natural ordering that is inconsistent with equals! */ final class VektorK_A implements Comparable<VektorK_A> { private double x; private double y; public VektorK_A(double x, double y) { this.x = x; this.y = y; public double length() { return Math.sqrt(x*x + y*y); // tostring wird eigentlich immer definiert! public String tostring(){ return "<" + this.x + ", " + this.y + public int compareto(vektork_a v) { return (int) (this.length() - v.length()); public boolean equals(vektork_a v) { return x == v.x && y == v.y; public boolean equals(object o) { if (o instanceof VektorK_A) { return this.equals((vektork_a) o); else { return false; equals und compareto sollten consistent sein. Sie müssen aber nicht. Seite 38

39 equals / compareto / hashcode :Beispiel 2 (2) /* * (non-javadoc) java.lang.object#hashcode() * Einfaches Muster fuer hashcode: * Verarbeite den Hashcode jedes Feldes (= Objektvariale), das bei * Gleichheit eine Rolle spielt * (und NUR DIESE! Gleiches muss den gleichen Hashcode liefern). * Handelt es sich um einen primitiven Typ, dann nimm eine * Hilfsroutine wie Double.doubleToLongBits public int hashcode() { final int prime = 31; long hash = 1; hash = hash * prime + Double.doubleToLongBits(x) % Integer.MAX_VALUE; hash = hash * prime + Double.doubleToLongBits(y) % Integer.MAX_VALUE; return (int) hash;... Seite 39

40 Kollektion Iterator Iteratoren Seite 40

41 Iterator Iterator Mechanismus zum Durchlaufen einer Kollektion explizite Nutzung implizite Nutzung mit foreach-schleife ArrayList<Integer> l = new ArrayList<Integer>(); l.add(1); l.add(2); l.add(3); iterierbare Kollektion oder Feld for ( int i : l ) System.out.println(i); implizite Nutzung eines Iterators Iterator<Integer> iter = l.iterator(); while ( iter.hasnext() ) { System.out.println( iter.next() ); explizite Nutzung eines Iterators Seite 41

42 Iteratoren und das Collections-Framwork Java Kollektionen sind iterierbar sie können Iteratoren erzeugen mit dem man sie durchlaufen kann public interface Collection<E> extends Iterable<E>{... public interface List<E> extends Collection<E>{... public class ArrayList<E>extends AbstractList<E> implements List<E>,RandomAccess, Cloneable, Serializable {... Iterable Iterable Collection iterator():iterator iterator():iterator Iterator Iterator next():object next():object hasnext():boolean hasnext():boolean... Map List Set <<use>> ArrayList iterierbar Seite 42 LinkedList... LinkedHashMap nicht iterierbar

43 Iteratoren und das Collections-Framwork Java Kollektionen sind iterierbar Iterable : sie können Iteratoren erzeugen: Methode iterator ~> Iterator Iterator : mit dem man sie durchlaufen kann hasnext / next ArrayList<Integer> l = Iterator Iterator new ArrayList<Integer>(); next():object next():object hasnext():boolean hasnext():boolean l.add(1); l.add(2); l.add(3); Iterator<Integer> iter = l.iterator(); <<use>> Iterable Iterable Collection iterator():iterator iterator():iterator List while ( iter.hasnext() ) { System.out.println( iter.next() ); automatische Umwandlung durch den Compiler for ( int i : l ) System.out.println(i); ArrayList Seite 43

44 Iteratoren und das Collections-Framwork Listen java.util.arraylist<e> java.util.linkedlist<e> iterierbar mit Iterator Iterator<E> iterator() iterierbar mit Listen-Iterator (Durchlauf in beide Richtungen) ListIterator<E> listiterator() Mengen java.util.treeset<e> java.util.hashset<e> iterierbar mit Iterator Iterator<E> iterator() Abbildungen java.util.treemap<k,v> java.util.hashmap<k,v> nicht iterierbar aber Set<K> keyset() liefert die (iterierbare) Menge der Schlüssel Seite 44

45 Collections-Framwork verwenden Schnittstelle auswählen Implementierungsvariante (Datenstruktur) auswählen Anforderungen an Elementtypen prüfen / erfüllen Seite 45