Download Samlingar av objekt + Generics (parametrisk polymorfism) – 2015

Samlingar av objekt
+ Generics (parametrisk polymorfism)
[email protected] – 2015
2
Enligt TDDD73:
Listan är en mycket användbar sammansatt datatyp.
I många andra språk kallar man listor för arrayer.
Men många språk har både listor och arrayer!
Exakta definitioner varierar…
Listor (i Java):
Implementerade som klasser
Finns många varianter (olika lagring)
Kan växa och krympa
Arrayer (i Java):
"Inbyggda" i språket
En enda variant
Fixerad storlek
jonkv@ida
Listor och arrayer

4
För varje typ T kan Java dynamiskt skapa en associerad arraytyp T[]
 Exempel: Object[], String[], Circle[]
 Subklass till Object
  Arrayer är objekt, med metoder och fält och element
Object
Object[]
String[]
Circle[]
Circle[][]
jonkv@ida
Arrayer 1: Arraytyper
5
numbers
Circle[] circles = new Circle[10];
int[] numbers = new int[rnd()];
Arrayer skapas med new
Storlekar är fasta, men sätts vid körning
int second = numbers[1];
Element hämtas ut med index (första = 0)
for (int i = 0; i < numbers.length; i++) {
System.out.println(numbers[i]);
}
Index: 0…length-1
Arrayer känner till sin egen längd
int val = numbers[42000];
Indexkontroll: Ger
ArrayIndexOutOfBoundsException
Object
header:
length
[0]
[1]
[41]
(data)
42
0
0
0
Element
initialiseras:
0, 0.0, null,
eller false
jonkv@ida
Arrayer 2: Användning

6
Objektarrayer innehåller pekare:
 Circle[ ] circles = new Circle[10];
circles
Object
header:
length
[0]
[1]
(data)
10
[9]
Kan peka på vilken Circle
som helst, inklusive
subklasser (GraphicCircle)
Element initialiseras till null
Inga nya Circle-objekt skapas!
jonkv@ida
Arrayer 3: Pekar-arrayer

Att initialisera en array
7
Antal element: Implicit
▪ public static void main(String[ ] args) {
int[ ] numbers = new int[ ] { 1, 2, 4, 8, 16 };
print(numbers);
print(new int[ ] { 44, getRandomInt() });
}
Kompileras till kod!
Motsvarar:
int[ ] temp = new int[2];
temp[0] = 44;
temp[1] = getRandomInt();
print(temp);
Kompileras till kod!
Motsvarar:
int[ ] numbers = new int[5];
numbers[0] = 1;
numbers[1] = 2;
numbers[2] = 4;
numbers[3] = 8;
numbers[4] = 16;
jonkv@ida
Arrayer 4: Ange element

Arrayer av arrayer:
 Square[ ][ ] board
 Square[ ] row
 Square pos
board
row
= new Square[20][10];
= board[19];
= board[1][0];
Object
header:
length
[0]
[1]
(data)
20
8
Object
header:
length
[0]
…
[9]
Object
header:
length
[0]
…
[9]
(data)
10
(data)
10
[18]
[19]
Object
header:
length
[0]
…
[9]
(data)
10
jonkv@ida
Arrayer 5: Flerdimensionella arrayer

9
Arrayer ärver metoder från Object
 Av historiska anledningar: Bara default-implementationerna
Default-implementationer…
equals() testar identitet
int[ ] ar1 = new int[3]; // 0, 0, 0
int[ ] ar2 = new int[3]; // 0, 0, 0
System.out.println(ar1.equals(ar2));
// false
Kan inte ändras:
Bakåtkompatibilitet!
Vad vi oftast vill
Hjälpmetoder i java.util.Arrays
int[ ] ar1 = new int[3]; // 0, 0, 0
int[ ] ar2 = new int[3]; // 0, 0, 0
System.out.println(Arrays.equals(ar1,ar2));
// true
Också i java.util.Arrays: sort(),
binarySearch(), copyOfRange(),
deepToString(), hashCode(), fill(), …
jonkv@ida
Arrayer 6: Tillgängliga metoder

Styrka: Effektiv användning av minne
10
numbers
 Liten konstant "startkostnad",
12–20 bytes
 Plus elementens "verkliga" kostnad

Styrka: Snabbt
 Element 40:
Minnesadress = [arraystart+12] + 40 * 4

Svaghet: Kan inte ändra längd när den har skapats!
 Saknar metoder som add(), append(), remove(), …
Object
header:
length
[0]
[1]
[41]
(data)
42
0
0
0
jonkv@ida
Arrayer 7: Styrkor och svagheter

Listor:
 Variabel storlek  bekvämt att använda!
 Inget stöd i språket, men i klassbiblioteken

För att förstå listor bättre:
 Vi visar en möjlig implementation
 Använder en array internt
 Måste byta ut arrayen när element läggs till
12
jonkv@ida
Listor 1: Intro
13
public class StringList {
private String[] elements;
private int
size;
Använder en array för lagring!
public MyList() {
this.elements = new String[8];
this.size = 0;
}
Allokerar fler platser än nödvändigt
Hur många av platserna är använda?
StringList strings = new StringList();
strings
Object
header:
elements
size
(data)
0
Object
header:
length
[0]
[1]
[7]
(data)
8
jonkv@ida
Listor 2: En listklass
14
public void add(String element) {
elements[size] = element;
size++;
}
StringList strings = new StringList();
strings.add("Hello");
strings
Object
header:
elements
size
(data)
1
Object
header:
length
[0]
[1]
(data)
8
[7]
Vad händer när arrayen blir full?
"Hello"
jonkv@ida
Listor 3: En listklass (forts.)
public void add(String element) {
if (size == elements.length) {
int newsize = 2*size;
String[] arr2 = new String[newsize];
System.arraycopy(…);
this.elements = arr2;
}
elements[size] = element;
size++;
}
15
Är interna lagringen full?
Skapa större array,
kopiera innehållet,
kasta bort gamla arrayen!
jonkv@ida
Listor 4: En listklass (forts.)
public String get(int index) {
if (index < 0 || index >= size) {
throw new
IndexOutOfBoundsException();
} else {
return elements[index];
}
}
16
Kolla index:
Tillåt inte get(4) när size==2!
jonkv@ida
Listor 5: En listklass (forts.)

17
Effektiv representation – för de flesta operationer…
public void add(int index, E element) {
if (size == elements.length) { … allocate more memory … }
}
System.arraycopy(elements, index, elements, index + 1, size - index);
elements[index] = element;
size++;
A B C D E F G H
list.add(2, "X");
A B C C D E F G H
Kopiera – tar tid!
A B X C D E F G H
Stoppa in
jonkv@ida
Listor 6: Stoppa in element

Vår listklass lagrar bara strängar!
public class StringList {
private String[] elements;
private int
size;
…
}
Behöver vi en listklass för varje elementtyp?
19
jonkv@ida
Elementtyper 1: Typspecifika listor?
20
public class ObjectList {
Array av Object-pekare,
private Object[] elements;
kan peka på objekt av godtycklig klass
private int size;
public ObjectList() {
this.elements = new Object[8];
this.size = 0;
}
public Object get(int index) {
if (index >= 0 && index <size) { return elements[index]; }
else /* Signal error */
}
public void add(Object element) {
if (size == elements.length) { /* Create a new array; copy old element */ }
elements[size] = element;
size++;
}
}
jonkv@ida
Elementtyper 2: Godtyckliga objekt

21
Nu får vi nya problem!
 1: Ingen typsäkerhet när vi adderar element!
▪ Vill ha en lista där vi stoppar in strängar:
ObjectList greetings = new ObjectList();
▪ Kan lägga in strängar:
greetings.add("hello");
▪ Kan råka lägga in cirklar också – inget fel vid kompilering eller körning!
greetings.add(new Circle(1, 1, 3));
public class ObjectList {
public ObjectList() { … }
public Object get(int index) { … }
public void add(Object element) { … }
}
jonkv@ida
Elementtyper 3: Problem
22
 Problem 2: Ingen typinformation när vi hämtar element!
ObjectList greetings = new ObjectList();
greetings.add("hello");
greetings.add(new Circle(1, 1, 3));
…
String str = greetings.get(0);
// Kompileringsfel
String str = (String) greetings.get(0);
// OK
Vi måste tala om för kompilatorn:
"Jag vet att jag la en sträng på position 0 – jag lovar!"
Krävs en cast – extra arbete för oss
public class ObjectList {
public ObjectList() { … }
public Object get(int index) { … }
public void add(Object element) { … }
}
jonkv@ida
Elementtyper 4: Problem
 Problem 3: Tänk om vi har fel!
ObjectList greetings = new ObjectList();
greetings.add("hello");
greetings.add(new Circle(1, 1, 3));
for (int i = 0; i < greetings.size(); i++) {
String str = (String) greetings.get(i);
// Runtime error for i=1 – it’s a Circle!
}
Upptäcks inte när programmet kompileras
23
jonkv@ida
Elementtyper 5: Problem
void printMult3() {
for (int i = 1; i <= 13; i++) {
System.out.println(3 * i);
}
}
void printMult5() {
for (int i = 1; i <= 13; i++) {
System.out.println(5 * i);
}
}
void printMult(int num) {
for (int i = 1; i <= 13; i++) {
System.out.println(num * i);
}
}
void printMult4() {
for (int i = 1; i <= 13; i++) {
System.out.println(4 * i);
}
}
25
num är en
heltalsvariabel
Kan ha värdet
3, 4, 5, 8, …
void printMult8() {
for (int i = 1; i <= 13; i++) {
System.out.println(8 * i);
}
}
jonkv@ida
Vanliga parametrar till metoder
class ListOfString {
String[] elements;
int
length;
{…}
String get(int index)
void add(String element) { … }
}
class List<E> {
E[]
elements;
int
length;
E
get(int index)
void add(E element)
}
class ListOfCircle {
Circle[] elements;
int
length;
{…}
Circle get(int index)
void add(Circle element) { … }
}
26
class ListOfShape {
Shape[] elements;
int
length;
{…}
Shape get(int index)
void add(Shape element) { … }
}
E är en
typvariabel
{…}
{…}
Kan ha värdet
String, Shape, …
class ListOfButton {
Button[] elements;
int
length;
{…}
Button get(int index)
void add(Button element) { … }
}
jonkv@ida
Typparametrar till klasser

27
Generiska typer med typparametrar
class MyList<E> {
E[]
elements;
int
length;
E
get(int index)
void add(E element)
}
En array där elementen har typ E
– verkliga typen är inte angiven än
{ return elements[index]; }
{ … } // Takes a parameter of type E
 Kan "instansieras" med olika typer som parameter
MyList<String> – nästan exakt som:
class MyList<String> {
String[] elements;
int
length;
{…}
String get(int index)
void add(String element) { … }
}
MyList<Shape> – nästan exakt som:
class MyList<Shape> {
Shape[] elements;
int
length;
{…}
Shape get(int index)
void add(Shape element) { … }
}
jonkv@ida
Generics 1: Intro
class MyList<E> {
E[] elements;
int length;
E get(int index)
void add(E element)
}
28
{ return elements[index]; }
{…}
 En lista där E=String:
MyList<String> greetings = new MyList<String>();
greetings.add("hello");
// OK
greetings.add(new Circle(1, 1, 3));
// Compile-time error: add(String)
String str = greetings.get(0);
// No cast needed: String get(int index)
 En lista där E=MyList<String>  en lista av listor!
MyList<MyList<String>> lists = new MyList<MyList<String>>();
lists.add(greetings);
jonkv@ida
Generics 2: Användningsexempel
class MyList<E> {
E[] elements;
int length;
E get(int index)
void add(E element)
}
{ return elements[index]; }
{…}
 Mycket repetition:
MyList<MyList<String>> listor = new MyList<MyList<String>>();
 Syntaktiskt socker: Diamant-operatorn (betyder "samma som förut")
MyList<MyList<String>> listor = new MyList<>();
DRY-principen: Don’t RepeatYourself!
Regelbrott är WET: Write Everything Twice…
29
jonkv@ida
Generics 3: Att skriva mindre
class MyList<E> {
E[] elements;
int length;
E get(int index)
void add(E element)
}
{ return elements[index]; }
{…}
 Man kan använda en generisk typ utan att ange typparametrar:
MyList listor = new MyList(); // Defaults to "List of Object"
 Enbart för kompatibilitet med gammal kod!
▪ Generics kom i Java 1.5 (2004)
▪ Gammal kod borde fortfarande gå genom kompilatorn, men med varningar
▪ Gör inte detta i ny kod!
30
jonkv@ida
Generics 4: "Råa" typer

Kallas generisk programmering, ger oss parametrisk polymorfism
 Samma namn (MyList)
 Olika beteende (beroende på typparameter)

Jämför med subtypspolymorfism
 Samma metodnamn, flera implementationer inom en typhierarki
 Olika implementation väljs dynamiskt, beroende på verklig objekttyp

31
Jämför med ad-hoc-polymorfism (overloading)
 Samma metodnamn, flera implementationer i samma klass
 Olika implementation väljs statiskt, beroende på statiska parametertyper
jonkv@ida
Parametrisk polymorfism
En typparameter
måste ange en objekttyp!
class List<E> {
E[]
elements;
int
length;
E
get(int index)
void add(E element)
}
{…}
{…}
List<String> strings; // OK
List<Button> buttons; // OK
List<int> numbers; // Does not work!
33
…för egentligen
skapas bara en klass!
class List {
Object[] elements;
int
length;
{…}
Object get(int index)
void
add(Object element) { … }
}
Kompilatorn
tar hand om resten
Sparar minne,
men int är inget Object!
jonkv@ida
Typparametrar och objekttyper

34
Hur skapar vi en listklass som accepterar heltal?
Implementera om strukturerna?
class IntArrayList {
private int[] elements;
private int length;
public int get(int index) {
return elements[index];
}
void add(int element) { … }
}
Repetera för 8 primitiva typer
och för varje datastruktur
Kan göras – finns färdiga bibliotek
på nätet (GNU Trove, …)
Använd wrappers!
public class Integer {
private final int value;
public Integer(int value) {
this.value = value;
}
public int intValue() {
return value;
}
}
Repetera för 8 primitiva typer
 klart
jonkv@ida
Wrappers 1: Intro

Det finns en wrapper-klass för varje primitiv datatyp
35
jonkv@ida
Wrappers 2: Wrapper-objekt

36
För att skapa wrapper-objekt:
 Kan använda vanlig konstruktor
Number ten = new Integer(10);
Number pi = new Double(3.14);
 Bättre: Använd statiska fabriksmetoden valueOf()
Number ten = Integer.valueOf(10);
Number pi = Double.valueOf(3.14);
Sparar tid och minne: Återanvänder objekt för vanliga värden!
public class Integer {
public static Integer valueOf(int i) {
if (i >= IntegerCache.low && i <= IntegerCache.high)
return IntegerCache.cache[i + (-IntegerCache.low)];
return new Integer(i);
Fungerar för att wrappers är immutable:
}
Värden kan inte ändras
}
jonkv@ida
Wrappers 3: Skapa

Resulterar i objekt  kan lagras i listor, objektpekare, …
List<Number> numbers = new ArrayList<>();
numbers.add(Integer.valueOf(10));
numbers.add(Double.valueOf(3.14));

För att hämta ut värdet: Anropa typeValue()
Number intobj
int val0
= numbers.get(0);
= intobj.intValue();
double val1
= numbers.get(1).doubleValue();
37
jonkv@ida
Wrappers 4: Användning

Kan använda automatisk boxing och unboxing
 ("Paketinslagning")
List<Number> numbers = new ArrayList<>();
numbers.add(10);
numbers.add(3.14);
double val1 = numbers.get(1);

VARNING: Osynlig ineffektivitet!
 Kan skapa nya objekt
 Tar (lite) extra tid att plocka ut värden ur objekt
 Vissa rekommenderar explicit boxing / unboxing istället
38
jonkv@ida
Wrappers 5: Användning
int[] numbers = new int[]
{ 12, 14 ,16, 18, 20 }
List<Integer> list = new ArrayList<>();
list.add(12); list.add(14); list.add(16); list.add(18); list.add(20);
Array
Object
header:
length
[0]
[1]
[4]
(data)
5
12
14
20
Mindre andel overhead
för mer komplexa
strukturer…
39
jonkv@ida
Wrappers 6: Använder mer minne
ArrayList
Object
header:
size
arr
Object
header:
length
[0]
[1]
[4]
5
Object
header:
value
(data)
Object
header:
value
(data)
(data)
12
(data)
14
5
Object
header:
value
(data)
20
Java Collections Framework
[email protected] – 2015

41
Collections Framework: Många sammansatta datastrukturer
 1) Uppsättning gränssnitt för listor, köer, mängder, mappningar
Kom ihåg: Gränssnitt ger oss frihet att välja implementation!
jonkv@ida
Collections Framework 1: Intro
 2) En uppsättning implementationer
42
jonkv@ida
Collections Framework 2: Intro
 3) Några hjälpklasser
43
jonkv@ida
Collections Framework 3: Intro

Collection<E>: Generell samling av objekt
 Vissa samlingar är ordnade
▪ Listor har ett första element –
inte mängder
 Vissa tillåter dubblerade element
▪ Listor kan innehålla två identiska element –
inte mängder
45
jonkv@ida
Collection 1: Intro
46
 Lägga till element:
▪ c.add(E)
▪ c.addAll(Collection)
 Testa innehåll:
▪ c.isEmpty(), c.size()
▪ c.contains(Object obj)
▪ c1.equals(Collection c2)
▪ c1.containsAll(Collection c2)
 Hämta alla element:
▪ c.toArray()
 Ta bort element:
▪ c.clear()
▪ c.remove(Object)
– innehåller samma element, i ngn ordning?
– alla element i c2 finns i c1?
– En Object[ ] som innehåller samma element
– tar bort alla element
jonkv@ida
Collection 2: Grundläggande funktionalitet

47
List<E> extends Collection<E>
 Alltid ordnad: Element har index
 Implementeras av
▪ ArrayList
– Mycket vanlig, implementation liknar våra tidigare exempel
▪ LinkedList
– Ganska vanlig, andra egenskaper
▪ Stack, Vector
– Använd inte, deprecated
jonkv@ida
List 1: Intro

48
Principen bakom länkade listor:
LinkedList
Object
header:
size
first
(data)
5
ListNode
Object
header:
next
prev
value
Object
header:
value
(data)
(data)
12
En extra listnod per element
 använder mer minne
ListNode
Object
header:
next
prev
value
Object
header:
value
(data)
(data)
14
ListNode
Object
header:
next
prev
value
Object
header:
value
(data)
(data)
16
jonkv@ida
Länkade listor (1)
ListNode
Object
header:
next
prev
value
Snabbt att skjuta in / ta bort värden
LinkedList
Object
header:
size
first
(data)
5
ListNode
Object
header:
next
prev
value
Object
header:
value
Object
header:
value
(data)
(data)
12
ListNode
Object
header:
next
prev
value
Object
header:
value
(data)
(data)
14
49
(data)
(data)
15
ListNode
Object
header:
next
prev
value
Object
header:
value
(data)
(data)
16
jonkv@ida
Länkade listor (2)
50
Tar lång tid att ta fram värde nummer n i listan
LinkedList
Object
header:
size
first
(data)
5
ListNode
Object
header:
next
prev
value
Object
header:
value
(data)
(data)
12
ListNode<E> get(int index) {
ListNode<E> x = first;
for (int i = 0; i < index; i++)
x = x.next;
return x;
}
ListNode
Object
header:
next
prev
value
Object
header:
value
(data)
(data)
14
ListNode
Object
header:
next
prev
value
Object
header:
value
(data)
(data)
16
jonkv@ida
Länkade listor (3)
51
 Hämta / hitta element
▪ list.get(index)
▪ list.indexOf(Object needle), list.lastIndexOf(Object needle)
▪ Collections can hitta dellistor, göra binärsökning, hitta min/max-element
 Lägga till och ta bort
▪ list.add(E value)
– ärvs från Collection!
▪ list.add(int index, E value) – flyttar element efter givet index
▪ list.addAll(int index, Collection c)
▪ list.remove(int index)
 Ändra element
▪ list.set(int index, E value)
▪ Collections kan söka/ersätta, fylla med ett värde, kopiera listor
 Omarrangera listor
▪ Collections kan blanda, sortera, rotera, reversera listor
jonkv@ida
List 2: Metoder
52
Arrayer används:
 För att implementera datatyper
 ArrayList måste använda en
“primitiv” array
 När varje nanosekund spelar roll
 Bara efter CPU-profilering som visar
att listhantering spelar roll
Listor används:
 Nästan alltid!
 Många hjälpfunktioner tillgängliga
 Kan lätt lägga till och ta bort
element, osv
 Används av många klasser i Javas
klassbibliotek
 …
 När varje byte spelar roll
 Bara efter minnesprofilering…
 Ibland om storleken är fixerad
 Om storleken varierar:
Låt listorna hantera detta!
Tetrislabben använder arrayer
eftersom Board-storleken
är fixerad!
jonkv@ida
List 3: Listor vs. arrayer

53
Queue<E> extends Collection<E>
 Kan lägga till i slutet av kön
 Kan ta bort i början av kön
 Implementeras av
▪ ArrayDeque, LinkedList
– grundläggande köstrukturer
 Varianter
▪ Deque: Även "på andra sidan" (Double-Ended QUEue)
▪ PriorityQueue
– har element i sorterad ordning
Vad händer om det är omöjligt?
Operation
Stoppa in element
Ta bort element
Se på första elementet
Kastar exception
add(e)
remove()
element()
Returnerar speciellt värde
offer(e)
poll()
peek()
jonkv@ida
Queue 1: Köer

54
Map är Javas motsvarighet till dictionaries
 Vanlig klass, inte språkfiness  mer att skriva
>>> dict = {'a': 45, 'b': 39, 'c': 19}
>>> dict['a']
45
>>> dict['d'] = 4711
>>> dict
{'a': 45, 'c': 19, 'b': 39, 'd': 4711}
>>> len(dict)
4
public static void main(String[] args) {
Map<Character,Integer> dict = new HashMap<>();
dict.put('a', 45);
dict.put('b', 39);
dict.put('c', 19);
System.out.println(dict.get('a'));
dict.put('d', 4711);
System.out.println(dict);
System.out.println(dict.size());
}
45
{a=45, b=39, c=19, d=4711}
4
jonkv@ida
Map (1)

En Map<K,V> associerar nycklar/keys K med värden V
final Map<String,String> phone = new TreeMap<String,String>();
phone.put("Jane Doe", "555-1234");
phone.put("John Doe", "555-4321");
System.out.println(phone.get("John Doe"));  555-4321
 Några map-klasser:
▪ TreeMap
– sorterar elementen, kräver Comparable/Comparator
▪ HashMap
– kräver hashkoder, förklaras i TDDD86
 Operationer:
▪ map.put(K key, V value),
▪ map.get(Object key)
▪ map.remove(Object key), map.clear()
▪ map.entrySet() – ett Set som innehåller <key, value>-par
▪ map.keySet()
– ett Set som innehåller alla nycklar
▪ map.values()
– en Collection som innehåller alla värden
55
jonkv@ida
Map

Hur kan man iterera över alla element i en samling?
 Med en array eller ArrayList fungerar index utmärkt:
static boolean contains(List<?> haystack, Object needle) {
for (int i = 0; i < haystack.size(); i++) {
if (haystack.get(i).equals(needle)) return true;
}
return false;
}
57
jonkv@ida
Iteration 1: Med index

58
Hur kan man iterera över alla element i en samling?
 Med en LinkedList fungerar index, men långsamt:
static boolean contains(List<?> haystack, Object needle) {
for (int i = 0; i < haystack.size(); i++) {
if (haystack.get(i).equals(needle)) return true;
}
return false;
}
Node<E> get(int index) {
Node<E> x = first;
for (int j = 0; j < index; j++)
x = x.next;
return x;
}
i=0:
i=1:
i=2:
i=3:
i=4:
…
Gå genom element j=0
Gå genom element j=0, 1
Gå genom element j=0, 1, 2
Gå genom element j=0, 1, 2, 3
Gå genom element j=0, 1, 2, 3, 4
jonkv@ida
Iteration 2: Med index

Hur kan man iterera över alla element i en samling?
 Med en generell Collection (eller Set) finns inga index!
static boolean contains(Collection<?> haystack, Object needle) {
for (int i = 0; i < haystack.size(); i++) {
if (haystack.get(i).equals(needle)) return true;
}
return false;
}
Vi är egentligen inte intresserade av index!
Vi vill veta:
Finns det fler element?
Vad är nästa element?
59
jonkv@ida
Iteration 3: Utan index

60
Lösning: Gränssnittet Iterator
public interface Iterator<E> {
public boolean hasNext();
public E next();
…
}
Finns det fler element?
Vad är nästa element?
static boolean contains(Iterator<?> haystack, Object needle) {
while (haystack.hasNext()) {
Specialsyntax:
Object element = haystack.next();
Iterator för vilken elementtyp som helst
if (element.equals(needle))
return true;
Vet inte vilken elementtyp… men:
}
Det är i alla fall någon sorts Object!
return false;
}
jonkv@ida
Iteration 4: Iterator

61
Gränssnittet Iterable säger att objektet kan ge oss en iterator
public interface Iterable<E> {
public Iterator<E> iterator();
}
class ArrayList<E> implements List<E>, Iterable<E> {
…
}
static boolean contains(Iterable<?> haystack, Object needle) {
Iterator<?> iter = haystack.iterator();
while (iter.hasNext()) {
Object element = iter.next();
if (element.equals(needle))
return true;
}
return false;
}
jonkv@ida
Iteration 5: Iterable

En for-loop kan iterera över element i en Iterable
static boolean contains(Iterable<?> haystack, Object needle) {
for (Object element : haystack) {
if (element.equals(needle)) return true;
}
return false;
}

Användbart för alla collections och arrayer
int[] numbers = new int[rnd()];
for (int i : numbers) { … }
List<String> greetings = new ArrayList<>();
for (String str : greetings) { … }
62
jonkv@ida
Iteration 6: For(each)

Om man ändrar en samling medan man itererar över den:
 ConcurrentModificationException
 Har inget att göra med multitrådning!
static boolean contains(Iterable<?> haystack, Object needle) {
for (Object element : haystack) {
if (element.equals(needle)) return true;
if (…) {
ändra i haystack …
}
}
return false;
}
jonkv@ida
Iteration 7: ConcurrentModificationException 63

Iterator har en tredje metod
package java.util;
public interface Iterator<E> {
public boolean hasNext();
public E next();
public void remove();
}
Ta bort elementet
som just returnerades av next()
static void removeAllCopies(Iterable<String> haystack, Object needle) {
Iterator<String> iter = haystack.iterator();
while (haystack.hasNext()) {
String element = haystack.next();
if (element.equals(needle)) {
iter.remove();
}
}
}
Tas bort via iteratorn  ingen ConcurrentModificationException
64
jonkv@ida
Iteration 8: Ta bort element

ListIterator har fler metoder
 Ändra senast returnerade element
 Lägg till element innan senast returnerade element
 Gå framåt och bakåt i listan
List<String> greetings = new ArrayList<>();
ListIterator<String> iter = greetings.listIterator();
65
jonkv@ida
Iteration 9: ListIterator

67
Vad behöver en iterator för ArrayList känna till?
ArrayList
ArrayListIterator at 0
Object
header:
list
pos
(data)
Lista att iterera över
0
Nuvarande index
Object
header:
data
size
Object
header:
length
[0]
[1]
[9]
(data)
4
(data)
10
jonkv@ida
Iterator för ArrayList 1
68
public class ArrayList<E> implements List<E> {
public Iterator<E> iterator() {
return new ArrayListIterator<E>(this);
}
private class ArrayListIterator<E> implements Iterator<E> {
private ArrayList<E> list;
// Which list should we iterate over?
private int pos = 0;
// How many element have we returned so far?
public ArrayListIterator(final ArrayList<E> list) { this.list = list; }
public boolean hasNext() {
return (pos < list.size());
}
public E next() {
final E element = list.get(pos);
pos++;
return element;
}
}
}
Finns det flera element?
Vad är nästa element?
jonkv@ida
Iterator för ArrayList 2
69
Anta list=["hello","world"].
Iterator it = list.iterator();
while (it.hasNext()) {
System.out.println(it.next());
}
it at 0
Header
(data)
list
pos
0
Första iterationen: it=[list,0].
Testar: it.hasNext()  0 < list.size()  returnerar true
Anropar: it.next()  sätter pos = 1, returnerar "hello".
Andra iterationen: it=[list,1].
Testar: it.hasNext()  1 < list.size()  returnerar true
Anropar: it.next()  sätter pos = 2, returnerar "world".
Tredje iterationen: it=[list,2].
Testar it.hasNext()  2 < list.size()  returnerar false.
Avslutar loopen.
OBS: Själva listan ändras aldrig!
1
2
jonkv@ida
Iterator för ArrayList 3
70
public class LinkedList<E> implements List<E> {
public Iterator<E> iterator() {
return new LinkedListIterator<E>(this);
}
private class LinkedListIterator<E> implements Iterator<E> {
private ListNode<E> node;
// Which list node are we currently at?
public LinkedListIterator(final LinkedList<E> list) { this.node = list.first; }
public boolean hasNext() {
return node.next != null;
}
public E next() {
final E val = node.value;
node = node.next;
return value;
}
}
}
LinkedList
Object
header:
size
first
(data)
5
ListNode
Object
header:
next
prev
value
Object
header:
value
(data)
(data)
12
ListNode
Object
header:
next
prev
value
Object
header:
value
(data)
(data)
14
ListNode
Object
header:
next
prev
value
Object
header:
value
(data)
(data)
16
jonkv@ida
Iterator för LinkedList

71
En iteratorklass för textrader i en fil:
public class LineIterator implements Iterator<String> {
final BufferedReader file;
public LineIterator(String filename) { … }
public boolean hasNext()
public String next()
…
}
{ return !file.eof(); }
{ return file.readLine(); }
jonkv@ida
Iterator för textfiler

72
jonkv@ida
"Fortsättning" i nästa kurs
Mer om datastrukturer:
 TDDD86 Datastrukturer, algoritmer och programmeringsparadigm
 http://kdb-
5.liu.se/liu/lith/studiehandboken/svkursplan.lasso?&k_budget_year=2015&k_ku
rskod=TDDD86