ashraf abu baker baker@gdv.cs.uni-frankfurt.de
Post on 02-Jan-2016
56 Views
Preview:
DESCRIPTION
TRANSCRIPT
Java-Intensivkurs WS07/08Folie 1
Ashraf Abu Bakerbaker@gdv.cs.uni-frankfurt.de
Johann Wolfgang Goethe-UniversitätProfessur für Graphische DatenverarbeitungFachbereich Informatik und MathematikProf. Dr. Detlef Krömker
Java-Intensivkurs WS07/08Folie 2
Generics
class NonGenericBubbleSort{
public void bubbleSort (Integer [] A){
for (int i=0;i<A.length;i++) {for(int j=A.length-1;j>=i+1;j--){
if (A[j].compareTo(A[j-1])<0){//wenn A[j]<A[j-1]swap(A, j, j-1); }}}}
//vertauscht A[i] und A[j] public void swap(Integer []A,int i, int j){ Integer
temp=A[i];A[i]=A[j];A[j]=temp;
}}
vertausche A[j] & A[j]
vertausche A[j] & A[j]
Java-Intensivkurs WS07/08Folie 3
Generics
class BubbleSorter {
public static void main(String[] args) {
Integer[] A=new Integer[]{-1,0,4,2,1,0,3};
NonGenericBubbleSort bubbleSorter=new NonGenericBubbleSort();
bubbleSorter.bubbleSort(A);
for (Integer element : A) System.out.print(element+" ");
}}Ausgabe: -1 0 0 1 2 3 4
Java-Intensivkurs WS07/08Folie 4
Generics
Ein Sortieralgorithmus kann Elemente beliebiger Datentypen sortieren, sofern diese paarweise vergleichbar sind (auf den Elementen ist eine Ordnungsrelation definiert
NonGenericBubbleSort beschränkt sich jedoch nur auf das Sortieren von Integer-Zahlen
Wie muss die Implementierung angepasst werden damit Elemente anderer Datentypen sortiert werden können?
Java-Intensivkurs WS07/08Folie 5
Generics
Anpassung des Algorithmus für die Sortierung von Float Überladung der bubbelSort-Methode
Überladung und Anpassung der swap-Methode
public void bubbleSort (Float [] A){ //1. Anpassen//...}
public void swap(Float []A,int i, int j){
Float temp=A[i]; A[i]=A[j];A[j]=temp;
}Anpassung der temp-Variable
Anpassung der temp-Variable
Java-Intensivkurs WS07/08Folie 6
Generics
Wie oft müssen die Methoden bubbleSort() und swap() überladen werden?
Für die 7 unterschiedlichen primitiven Datentypen (int, long, double, …) müssten die beiden Methoden jeweils 6 Mal überladen werden
Die Klasse enthält 14 Methoden, die sich kaum Unterscheiden - Dies ist kein guter Stil einen einfachen Sortieralgorithmus zu
implementieren
Lösung??
Die Klasse BubbleSort wird als generische Klasse implementiert
Java-Intensivkurs WS07/08Folie 7
Generische Klassen
class GenericBubbleSort<T extends Object & Comparable>{
public void bubbleSort(T [] A){
for (int i=0;i<A.length;i++) {for(int j=A.length-1;j>=i+1;j--){
if (A[j].compareTo(A[j-1])<0){swap(A, j, j-1);
}}
} }public void swap(T []A,int i, int j){
T temp=A[i];A[i]=A[j];A[j]=temp;}}
wenn A[j]<A[j-1]wenn A[j]<A[j-1]
TypparameterTypparameter
Java-Intensivkurs WS07/08Folie 8
Generische Klassen
class BubbleSorter {
public static void main(String[] args) {
GenericBubbleSort<Integer> bubbleSorter= new GenericBubbleSort<Integer>();
bubbleSorter.bubbleSort(new Integer[]{-1,0,4,2,1,0,3});
}}
Java-Intensivkurs WS07/08Folie 9
Generische Klassen
GenericBubbleSort ist eine generische Klasse, die einen nicht näher spezifizierten Datentyps namens T verwendet
Alles was über T bekannt ist, ist dass er eine Unterklasseasse von Object ist, und das Comparable-Interface implementiert
Die Elemente von T sind daher paarweise vergleichbar
Java-Intensivkurs WS07/08Folie 10
Generische Klassen
GenericBubbleSort ist nun eine parametrisierte Klasse
Eine Klasse ist generisch, wenn sie so definiert ist, dass sie bei ihrer Instanziierung nicht primitive Datentypen als Parameter erwartet
class MyClass<TypeArgument1, TypeArgument2, …, TypArgumentn>{//class body}
MyClass<Integer, String, …, StringBuffer> myClassObject=new
MyClass<Integer, String, …, StringBuffer>();
TypeArgument ist eine Abstraktion eines nicht primitiven Datentyps
Java-Intensivkurs WS07/08Folie 11
Generische Klassen
GenericBubbleSort<Integer>bubbleSorter= newGenericBubbleSort<Integer>(); bubbleSorter.bubbleSort(new Integer[]{-1,0,4,2,1,0,3});
GenericBubbleSort<Double> bubbleSorter =new GenericBubbleSort<Double>();bubbleSorter.bubbleSort(new Double[]{-1.2,0.2,-4.01,2.1,1.2,0.5,3.4});
GenericBubbleSort<String> bubbleSorter =new GenericBubbleSort<String>(); bubbleSorter.bubbleSort(new String[]{"is","genrics","neu"});
//Sortierung von Integer-Zahlen
//Sortierung von Integer-Zahlen
//Sortierung von Double-Zahlen
//Sortierung von Double-Zahlen
//Sortierung von Strings
//Sortierung von Strings
Java-Intensivkurs WS07/08Folie 12
Generische Methoden
Auch Methoden können als generisch deklariert werden
Statt die gesamte Klasse BubbleSort als generisch zu deklarieren, könnte man nur die Methoden bubbleSort() und swap() generisch deklarieren
class BubbleSortWithGenericMethods{
public<T extends Object & Comparable<T>> void bubbleSort(T [] A){//gleiche Implementierung wie in GenericBubbleSort
}
//bubbleSort() ist nun generisch
//bubbleSort() ist nun generisch
Java-Intensivkurs WS07/08Folie 13
Generische Methoden
public<T extends Object & Comparable<T>> void swap(T []A,int i, int j){//gleiche Implementierung wie in GenericBubbleSort
}}BubbleSortWithGenericMethods genricBubbleSorter4=new BubbleSortWithGenericMethods();
genricBubbleSorter4.<Integer>bubbleSort(new Integer[]{-1,0,4,2,1,0,3});
genricBubbleSorter4.<Double>bubbleSort(new Double[]{-1.2,0.2,-4.01,2.1,1.2,0.5,3.4});
genricBubbleSorter4. < String >bubbleSort(new String[]{"is","genrics","neu"});
Die Methode swap ist nun generisch
Die Methode swap ist nun generisch
Java-Intensivkurs WS07/08Folie 14
Generics
http://angelikalanger.com/Articles/JavaMagazin/Generics/GenericsPart1.html
http://angelikalanger.com/Articles/JavaMagazin/Generics/GenericsPart2.html
Java-Intensivkurs WS07/08Folie 15
Collections (Sammlungen) Datenstrukturen
Die Effizienz eines Algorithmus hängt sehr eng mit der Wahl der richtigen Datenstruktur zusammen
Collections in Java sind Datenstrukturen, die als Container aufgefasst werden können, in denen Objekte gespeichert, verwaltet und manipuliert werden können
Den Kern des Collections-Frameworks bilden die sechs Interfaces:
Collection, List, Set, SortedSet, Map und SortedMap:
Java-Intensivkurs WS07/08Folie 16
Collections
Alle Collections außer den Maps implementieren das Collection-Interface
Das Interface stellt u. a. Methoden zum Suchen, Einfügen und Entfernen von Elementen
Java-Intensivkurs WS07/08Folie 17
Das Collection-Interface
//Collection-InterfacePublic interface Collection<E> extends Iterable<E> { int size(); boolean isEmpty(); boolean contains(Object o); Iterator<E> iterator(); Object[] toArray(); <T> T[] toArray(T[] a); boolean add(E e); boolean remove(Object o); boolean containsAll(Collection<?> c); boolean addAll(Collection<? extends E> c); boolean removeAll(Collection<?> c); boolean retainAll(Collection<?> c); void clear(); boolean equals(Object o); int hashCode();}
Java-Intensivkurs WS07/08Folie 18
Listen, Mengen & Maps
Aufteilung der Collections in 3 Kategorien:Listen (Lists)
Mengen (Sets)
Tabellen (Maps)
Listen sind Sammlungen, die dynamischen Arrays ähneln
Ihre Elemente sind geordnet und indiziert
Java-Intensivkurs WS07/08Folie 19
Listen, Mengen & Maps
Sets repräsentieren (mathematische) Mengen, die keine Duplikate zulassen
Eine Map ist eine Sammlung von Paaren
Jedes Paar besteht aus einem eindeutigen Schlüssel und einem zugehörigen Objekt (Wert)
Sind vergleichbar mit assoziativen dynamischen Arrays
Werden mithilfe von Hash-Strukturen implementiert
Java-Intensivkurs WS07/08Folie 20
Listen, Mengen & Maps
Es gibt sortierte und unsortierte bzw. geordnete und nicht geordnete Sets und Maps
Mengen- und Map-Elemente sind nicht indiziert
Java-Intensivkurs WS07/08Folie 21
Listen
Listen sind vergleichbar mit dynamisch wachsenden Arrays
Sind geordnet (sie speichert ihre Elemente in der Reihenfolge, in der sie eingefügt wurden)
Jedes Element hat einen Index
Die Indizierung fängt, wie bei Arrays, bei 0 an
Indexbasierter Zugriff auf Listenelemente ist möglich
Das Einfügen und Entfernen von Elementen an beliebiger Stelle in Listen ist möglich
Listen können null-Objekte und Duplikate speichern
Die Länge einer Liste ist theoretisch unbeschränkt
Java-Intensivkurs WS07/08Folie 22
Listen
Beispiele:ArrayList, Vector, Stack, und LinkedList
//List-Interfaceinterface List<E> extends Collection<E> { int size(); boolean isEmpty(); boolean contains(Object o); Iterator<E> iterator(); Object[] toArray(); <T> T[] toArray(T[] a); boolean add(E e); boolean remove(Object o); boolean containsAll(Collection<?> c); boolean addAll(Collection<? extends E> c);... }
Java-Intensivkurs WS07/08Folie 23
Listen
//List-Interfaceinterface List<E> extends Collection<E> { ... boolean removeAll(Collection<?> c); boolean retainAll(Collection<?> c); void clear(); boolean equals(Object o); int hashCode(); E get(int index); E set(int index, E element); void add(int index, E element); E remove(int index); int indexOf(Object o); int lastIndexOf(Object o); ListIterator<E> listIterator(); ListIterator<E> listIterator(int index); List<E> subList(int fromIndex, int toIndex);}
Java-Intensivkurs WS07/08Folie 24
ArrayList & Vector
java.lang.ArrayList und java.lang.Vector
Implementieren das List-Interface
Sie unterscheiden sich jedoch darin, dass die Methoden von Vector synchronisiert sind
- Mehrere Threads auf einen Vector gleichzeitig zugreifen können ohne die Integrität der Daten zu verletzen
Vektoren Thread-sicher (thread-safe)
Aufgrund der Synchronisation sind Vektoren langsamer als ArrayLists und sollten daher nur verwendet werden,
wenn mehrere Threads auf den Vektor konkurrierend zugreifen sollen
Vectors sind keine Vektoren im mathematischen Sinne sondern Listen
Java-Intensivkurs WS07/08Folie 25
ArrayListen & Vector
public class ArrayListSample {ArrayList physicalUnits = new ArrayList();
public ArrayListSample(){physicalUnits.add("Joule");physicalUnits.add("Pascal");physicalUnits.add("Volt");physicalUnits.add("Coulomb");physicalUnits.add(null);
physicalUnits.add("Volt");physicalUnits.add("Ohm");physicalUnits.add("Newton");physicalUnits.add(1,"Celsius");
}
//Listen können null-Referenzen
//Listen können null-Referenzen
//Ein Duplikat//Ein Duplikat//Ein Duplikat//Ein Duplikat
Java-Intensivkurs WS07/08Folie 26
LinkedList
//Das Deque-Interfacepublic interface Deque<E> extends Queue<E> { void addFirst(E e); void addLast(E e); boolean offerFirst(E e); boolean offerLast(E e); E removeFirst(); E removeLast(); E pollFirst(); E pollLast(); E getFirst(); E getLast(); E peekFirst(); E peekLast();
Java-Intensivkurs WS07/08Folie 27
LinkedList
//Das Deque-Interfaceboolean removeFirstOccurrence(Object o); boolean removeLastOccurrence(Object o); boolean add(E e); boolean offer(E e); E remove(); E poll(); E element(); E peek(); void push(E e); E pop(); boolean remove(Object o); boolean contains(Object o); public int size(); Iterator<E> iterator();
Eine LinkedList ist eine doppelt verkettete Liste
Java-Intensivkurs WS07/08Folie 28
LinkedList
boolean add(E e) und boolean offer(E e):Fügen das Element e am Ende der Liste ein
E remove() und E poll():Entfernen das erste Element in der Liste und geben es zurück
E element() und E peek():Liefern das erste Element in der Liste ohne es zu entfernen
Beispiel:
http://www.roseindia.net/java/jdk6/LinkedListExample.shtml
Java-Intensivkurs WS07/08Folie 29
Mengen
Eine Menge ist eine in der Regel ungeordnete Sammlung von Elementen, die keine Duplikate zulässt
Bevor ein Element in eine Menge eingefügt werden kann, wird zunächst überprüft, ob es bereits darin enthalten ist
Erst wenn sichergestellt ist, dass es nicht vorhanden ist, wird es in die eingefügt
Java-Intensivkurs WS07/08Folie 30
Mengen
Im Gegensatz zu Listen ist bei Mengen ein indexbasierter Zugriff auf die Elemente nicht möglich
Es gibt sortierte und unsortierte Mengen
Die wichtigsten Mengen-Collections in Java sind HashSet , TreeSet und LinkedHashSet
Java-Intensivkurs WS07/08Folie 31
HashSet
Speichert die Elemente in einer Hashtabelle und lässt das Einfügen von null-Objekten, jedoch nicht von Duplikaten zu
Die Elemente eines HashSet sind nicht geordnet
Ein HashSet verlässt sich auf die Implementierung der hashCode()-Methode ihrer Objekte
Dies ist die Methode, die HashSet bei der Suche nach Duplikaten aufruft
Java-Intensivkurs WS07/08Folie 32
HashSet
public class HashSetSample {Set hashSet=new HashSet();public HashSetSample() {
for(int i=5;i>=0;i--)hashSet.add(i*i);
hashSet.add(3.5f); hashSet.add(null);
} public static void main(String ... args) {
HashSetSample hashSetSample=new HashSetSample();
System.out.println(hashSetSample.hashSet);}}
Ausgabe:[null, 0, 1, 16, 3.5, 4, 25, 9]
null-Objekte sind erlaubt
null-Objekte sind erlaubt
Java-Intensivkurs WS07/08Folie 33
LinkedHashSet
Hat die gleichen Eigenschaften wie ein HashSet
Unterschied:LinkedHashSet sind geordnet
Java-Intensivkurs WS07/08Folie 34
TreeSet
Speichert seine Elemente in einem Rot-Schwarz-Baum
Lässt weder Duplikate noch null-Objekte zu
Erweitert Set um zahlreiche Methoden für den Umgang mit sortierten Daten:
interface SortedSet<E> extends Set<E> { Comparator<? super E> comparator(); SortedSet<E> subSet(E fromElement, E toElement);
SortedSet<E> headSet(E toElement); SortedSet<E> tailSet(E fromElement); E first(); E last();}
Java-Intensivkurs WS07/08Folie 35
TreeSet
public class TreeSetSample {TreeSet<Integer> sortedSet = new
TreeSet<Integer>();
public TreeSetSample() {sortedSet.add(new Integer(2));sortedSet.add(new Integer(7));sortedSet.add(new Integer(1));
//sortedSet.add(null); sortedSet.add(new Integer(-1));
sortedSet.add(new Integer(0));sortedSet.add(new Integer(-1));sortedSet.add(new Integer(5));sortedSet.add(new Integer(5));
}
null-Objekte sind erlaubt
null-Objekte sind erlaubt
Java-Intensivkurs WS07/08Folie 36
TreeSet
public static void main(String... args) {TreeSetSample treeSetSample = new TreeSetSample();
System.out.print("sortedSet: ");
for (Integer element : treeSetSample.sortedSet) System.out.print(element + " ");
System.out.println();System.out.println("sortedSet.first(): "+
treeSetSample.sortedSet.first());System.out.println("sortedSet.last(): "+
treeSetSample.sortedSet.last());System.out.println("sortedSet.subSet(-1, 5): "+
treeSetSample.sortedSet.subSet(-1, 5));System.out.println("sortedSet.headSet(2): "+
treeSetSample.sortedSet.headSet(2));System.out.println("sortedSet.tailSet(2): "+
treeSetSample.sortedSet.tailSet(2));}
}Ausgabe:sortedSet: -1 0 1 2 5 7 sortedSet.first(): -1sortedSet.last(): 7sortedSet.subSet(-1, 5): [-1, 0, 1, 2]sortedSet.headSet(2): [-1, 0, 1]sortedSet.tailSet(2): [2, 5, 7]
Java-Intensivkurs WS07/08Folie 37
Tabellen (Maps)
Eine Map ist eine Datenstruktur, die Schlüssel/Objekt-Paare speichert
Die Schlüssel einer Map müssen eindeutig sein und sollten die Methode hashCode() implementieren
hashCode() wird aufgerufen, wenn zwei Schlüssel auf Gleichheit überprüft werden sollen
Es gibt sortierte und unsortierte, geordnete und ungeordnete Maps
Java-Intensivkurs WS07/08Folie 38
Tabellen (Maps)
HashMap, HashTable, TreeMap und LinkedHashMap
Sie alle implementieren das Map-Interface
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> m); void clear(); Set<K> keySet(); Collection<V> values(); ...}
Java-Intensivkurs WS07/08Folie 39
Das Map-Interface
public interface Map<K,V> { ...
Set<Map.Entry<K, V>> entrySet(); interface Entry<K,V> {
K getKey(); V getValue(); V setValue(V value); boolean equals(Object o); int hashCode();
} boolean equals(Object o); int hashCode();}
Java-Intensivkurs WS07/08Folie 40
Das Map-Interface
V put(K key, V value):Fügt den Schlüssel key und seinen Wert in die Tabelle ein Falls ein Schlüssel bereits vorhanden ist, wird sein alter Wert durch den neuen Wert ersetztDie Methode gibt dann den alten Wert des Schlüssels zurück
Wenn der Schlüssel nicht vorhanden ist, gibt die Methode null zurück
boolean containsKey(Object key):Gibt true zurück, wenn der Schlüssel in der Tabelle enthalten ist
Java-Intensivkurs WS07/08Folie 41
Das Map-Interface
V get(Object key):Gibt das dem Schlüssel zugeordnete Objekt zurück, oder null, falls der Schlüssel nicht in der Tabelle enthalten ist
Set<K> keySet():Gibt alle Schlüssel der Tabelle als Menge zurück
Collection<V> values():Gibt eine Collection der Objekte in der Map zurück. In der Collection können Duplikate enthalten sein.
Java-Intensivkurs WS07/08Folie 42
HashMap und Hashtable
Beide implementiert auf der Basis einer Hashtabelle
Ihre Arbeitsweisen sind identisch
Die Methoden von HashTable sind allerdings synchronisiert und daher Thread-sicher
HashMap und Hashtable lassen null-Schlüssel und null-Objekte zu
Ihre Elemente sind nicht geordnet
Java-Intensivkurs WS07/08Folie 43
TreeMap
TreeMap implementiert das SortedMap-Interface speichert ihre Elemente sortiert
TreeMaps lassen keine null-Schlüssel zu
Ein Schlüssel kann jedoch mit einem null-Objekt assoziiert sein
Java-Intensivkurs WS07/08Folie 44
TreeMap
public class TreeMapSample {Map<String, String> treeMap=new TreeMap<String,
String>();public TreeMapSample(){
treeMap.put("Energy", "Joule"); treeMap.put("Work", "Joule");
treeMap.put("Pressure", "Pascal");treeMap.put("Voltage", "Volt");treeMap.put("Frequency", "Hertz");treeMap.put("Resistance", "Ohm");
//treeMap.put(null, "Unkown"); treeMap.put("Power", "Watt");
treeMap.put("Temperature", "Celsius");treeMap.put("Conductance", "Siemens"); treeMap.put("Unknown", null); }
null-Schlüssel sind nicht erlaubt
null-Schlüssel sind nicht erlaubt
null-Werte sind erlaubt
null-Werte sind erlaubt
Java-Intensivkurs WS07/08Folie 45
TreeMap
public static void main(String[] args) {System.out.println("Sorted Map:");TreeMapSample treeMapSample = new
TreeMapSample();
for (String key : treeMapSample.treeMap.keySet())System.out.println(key + ":
"+treeMapSample.treeMap.get(key));}}
Ausgabe:Sorted Map: Conductance: SiemensEnergy: Joule Frequency: HertzPower: Watt Pressure: PascalResistance: Ohm Temperature: CelsiusUnknown: null Voltage: VoltWork: Joule
Java-Intensivkurs WS07/08Folie 46
LinkedHashMap
LinkedHashMap merkt sich die Reihenfolge, in der die Schlüssel/Wert-Paare eingefügt werden
public class MapSample {
public java.util.Map<Integer, Integer> linkedMap= new LinkedHashMap<Integer, Integer>();
public java.util.Map<Integer, Integer> treeMap= new TreeMap<Integer, Integer>();
public java.util.Map<String, Integer> hashMap= new HashMap<String, Integer>();
public MapSample() {int key=11;while (key-->0) {
linkedMap.put(key, key*key);treeMap.put(key, key*key);hashMap.put(key+"", key*key);
} }
Java-Intensivkurs WS07/08Folie 47
LinkedHashMap
public static void main(String ... args) {MapSample mapSample=new MapSample();System.out.print("Ordered Map:\t ");
Iterator<Integer> it=mapSample.linkedMap.keySet().iterator();while (it.hasNext()) System.out.print(mapSample.linkedMap.get(it.next())+" ");System.out.println();System.out.print("Sorted Map:\t ");it=mapSample.treeMap.keySet().iterator();while (it.hasNext()) System.out.print(mapSample.treeMap.get(it.next())+" ");System.out.println();System.out.print("Unordered Map:\t ");Iterator<String> it2=mapSample.hashMap.keySet().iterator();while (it2.hasNext()) System.out.print(mapSample.hashMap.get(it2.next())+" ");
}}Ausgabe:Ordered Map: 100 81 64 49 36 25 16 9 4 1 0 Sorted Map: 0 1 4 9 16 25 36 49 64 81 100 Unordered Map: 9 4 1 100 0 49 36 25 16 81 64
Java-Intensivkurs WS07/08Folie 48
Collections-Übersicht
Collection ArryList VectorLinked-
ListHash-Set
Tree-Set
Linked-Hash-
SetHash-Map Hashtable
Tree-Map
Linked-Hash-Map
Geordnet ja ja ja nein nein ja nein nein nein ja
Sortiert nein nein nein nein ja nein nein nein ja nein
null-Schlüssel Ja Ja nein Ja
null-Werte ja ja ja ja nein ja ja ja ja ja
Indexzugriff ja ja ja nein nein nein nein nein nein nein
Implementier-ung von equals() erforderlich nein nein nein nein ja nein nein nein nein nein
Implementierung von hashCode() erforderlich nein nein nein ja nein ja ja ja ja ja
Synchronisiert nein ja nein nein nein nein nein ja nein nein
Java-Intensivkurs WS07/08Folie 49
Generische Collections
Vor JDK 1.5 waren alle Collection-Klassen nicht generisch
Mit der add-Methode einer nicht generischen Liste könnte man z.B. Objekte unterschiedlicher Klassen in die Liste einfügen
Collections waren daher nicht homogen
List list=new ArrayList();list.add(new Integer(5));list.add("String-Object");list.add(new Float(2.3f) );Integer i=(Integer)list.get(0);s=(String)list.get(1);Float f=(Float)list.get(2);
Casting erforderlich
Casting erforderlich
Java-Intensivkurs WS07/08Folie 50
Generische Collections
Seit Version 5 sind alle Collection-Klassen und -Interfaces generisch und somit homogen
Zugriffe auf Elemente erfordern kein Casting mehr:
List<Integer> list2=new ArrayList<Integer>();list2.add(new Integer(5));list2.add(3);list2.add(new Integer(2) );
Integer ii= list2.get(0);Integer ss= list2.get(1);Integer ff= list2.get(2);
Casting ist nicht erforderlich
Casting ist nicht erforderlich
Java-Intensivkurs WS07/08Folie 51
Iteratoren (Iterator)
Ein Iterator ist ein Objekt, das das java.util.Iterator-Interface implementiert
Iteratoren bieten einen abstrakten Mechanismus zur Traversierung von Collections
//Iterator-Interfaceinterface Iterator<E> { boolean hasNext(); E next(); void remove();}
Java-Intensivkurs WS07/08Folie 52
Iteratoren (Iterator)
Ein Iterator hat einen Zeiger
Wenn ein Iterator initialisiert wird, zeigt sein Zeiger auf das erste Element in der Sammlung
boolean hasNext():liefert genau dann true zurück, wenn die Sammlung nicht leer ist und der Zeiger nicht das Ende der Liste erreicht hat
E next(): liefert das Objekt zurück, auf das der Iterator-Zeiger zeigt und bewegt anschließend den Zeiger zum nächsten ElementWenn der Zeiger beim letzten Element angelangt ist, liefern nachfolgende next()-Aufrufe null zurückDer Iterator kann dann nicht mehr verwendet werden
Java-Intensivkurs WS07/08Folie 53
Iteratoren (Iterator)
void remove():ruft next() auf und entfernt ggf. das Element, das next() zurück liefert
Das Collection-Interface verfügt über die Methode Iterator<E> iterator(), die einen Iterator für die Collection zurück liefert
Der Iterator liefert die Elemente seiner Collection in der Reihenfolge zurück, in der sie gespeichert sind
Java-Intensivkurs WS07/08Folie 54
Iteratoren
public class IteratorSample {public List<Integer> list = new ArrayList<Integer>();public Set<Integer> set = new HashSet<Integer>();public Map<Integer, Integer> map = new HashMap<Integer, Integer>();
public IteratorSample(){int ii=0;for(int i=0; i<11; i++){
ii=i*i;list.add(ii);set.add(ii);map.put(i, ii);
}}
Java-Intensivkurs WS07/08Folie 55
Iteratoren
public static void main(String[] args) {IteratorSample is=new IteratorSample();Iterator<Integer> it=is.list.iterator();System.out.print("List: ");while(it.hasNext())
System.out.print(it.next()+" ");System.out.println();
it=is.set.iterator();System.out.print("Set: ");while(it.hasNext())
System.out.print(it.next()+" ");System.out.println();
it=is.map.keySet().iterator();System.out.print("Map: ");while(it.hasNext()){
int key=it.next();System.out.print("("+key+","+is.map.get(key)+") ");}} }
Java-Intensivkurs WS07/08Folie 56
Iteratoren
Zur Traversierung von Collections können auch for-each-Schleifen verwendet werden
top related