1. No category

Læringsmål for forelesningen
• Objektorientering
– Bruk av grensesnitt og implementasjoner i Collection-klasser
• Java-prog, kap. 14-16 i Big Java
– Og side 990-997 i Appendix D
– Collection-rammeverket og
iterasjon med Iterator og Iterable
– Bruk av <type>-deklarasjoner ifm. collections
(såkalte ”generics”).
• Eclipse
– Kodemaler for for-konstruksjonen
1
Grupper av objekter
• En har ofte behov for å håndtere grupper av
objekter
– operere på dem som et hele, f.eks. overføre dem som parameter
eller gjøre enkeltoperasjoner på alle ved hjelp av en løkke
– implementere relasjon/kobling fra ett objekt til mange andre
– finne et objekt som tilfredsstiller visse kriterier
• Java-tabeller (array) kan brukes til dette,
men de er lite fleksible og tilbyr ingen
hjelpemetoder
– Tabeller har fast lengde angitt av length-attributtet og kun
muligheten til å lese og sette elementer basert på en indeks (int).
2
Collection-rammeverket, kap. 15
(http://java.sun.com/j2se/1.5/docs/guide/collections/overview.html)
Forbedringer i Java7: Se side 650-651 (og 990-997) i Big Java
• Collection-rammeverket i java.util-pakken
implementerer mange måter å lagre og
bearbeide grupper av objekter
– java.util.ArrayList lar oss f.eks. legge til, hente ut og ta ut objekter
• Mange grensesnitt med tilhørende
implementasjoner metoder gjør jobben
lettere, så det er lurt å bli kjent med
Collection-API’et (API = Application
Programmers Interface)
3
Oppbyggingen til
Collection-rammeverket (1)
• Collection rammeverket består av ett
overordnet grensesnitt (Collection) og
mange spesifikke grensesnitt, som tilbyr
”samlinger” med ulik logikk
– Collection-grensesnittet spesifiserer generelle metoder som de
andre grensesnittene arver fra/utvider
– List-grensesnittet tilbyr posisjonsbaserte metoder
– Set-grensesnittet tilbyr ingen egne metoder, men begrenser
samlingen til ikke å inneholde duplikater. SortedSet-grensesnittet
støtter sortering basert på en spesifikk måte å sammenligne
elementer på (Comparator)
4
Oppbyggingen til
Collection-rammeverket (2)
• Hvert spesifikke grensesnitt har flere
implementasjoner, hvorav en er
”standardimplementasjonen”
– List sin standardimplementasjon er ArrayList, Set sin er HashSet, ...
• Utenom Collection-hierarkiet har en i tillegg noen
nyttige grensesnitt/klasser
– Map: oppslag fra et objekt (nøkkel) til et annet objekt (verdi)
– Stack: stabel med verdier, med operasjoner for å legge på og ta av toppen
– Queue: kø med verdier, med operasjoner for å fylle på i én ende og ta ut i andre
5
http://www.falkhausen.de/en/diagram/html/java.util.Collection.html
6
Før en velger hvilken type
Collection en trenger, må en vurdere
behovene...
Avdekking av behovene er alltid viktig.
Det gjelder å stille de riktige spørsmålene.
7
Behov vs. tilbud
• Duplikater
– Skal en potensielt kunne lagre flere av samme element?
– Bruk en implementasjon av List-grensesnittet.
• Rekkefølge
– Er rekkefølgen eller posisjonen viktig?
– Dersom elementene skal ha en spesiell rekkefølge, kan en ikke bruke en Setimplementasjon.
– Er innsettingsrekkefølgen eller –posisjonen viktig?
– Bruk en List-implementasjon.
• Sortering
– Ønskes elementene automatisk sortert?
– Bruk en SortedSet-implementasjon.
• Trenger en spesielle håndteringsoperasjoner
– sette inn og ta ut i bestemt rekkefølge (siste/først inn, først ut)
• Som regel er det greit å bruke List/ArrayList,
men still deg likevel spørsmålene først!
8
– F.eks. viktig å vite om en må bruke list.contains(element) før list.add(element)
– Side 651 i Big Java
Collection-grensesnittet
•
Collection-grensesnittet tilbyr generelle metoder,
bl.a. for å legge til, fjerne og spørre om elementer
–
–
–
•
•
•
•
Støtter ikke oppslag basert på indeks og dermed ikke iterasjon basert
på for (int i = 0; i < col.size(); i++) { .. }
Iterasjon gjøres vha. såkalte iteratorer (Iterator-grensesnittet), som vi
kommer nærmere inn på etterhvert.
Det finnes ingen klasser som kun implementerer Collection, alle
konkrete klasser implementerer en av de mer spesifikke
grensesnittene.
Det kan likevel være riktig å deklarere variabler som Collection, for å
markere at det kun brukes Collection-metoder.
–
9
add(Object), addAll(Collection)
remove(Object), removeAll(Collection) (retainAll(Collection) – fjern alt annet enn)
contains(Object), containsAll(Collection)
// koden bruker kun add, remove, size, samt iterator
Collection col = new ArrayList();
List-grensesnittet –
posisjonsorientert
Collection
•
List-grensesnittet utvider
Collection-grensesnittet med
indeksbaserte metoder
for å legge til, fjerne og spørre om elementer
–
–
–
•
Viktigst er muligheten til å lese og sette elementer
basert på indeks/posisjon
–
•
•
•
Object get(int), set(int, Object)
Støtter dermed også iterasjon basert på indeks, som i
for (int i = 0; i < list.size(); i++) { .. }
Iterasjon kan også gjøres vha. Iterator-grensesnittet.
ArrayList er standardimplementasjonen av List-grensesnittet
–
10
add(int, Object), addAll(int, Collection)
remove(int)
int indexOf(Object), int lastIndexOf(Object)
Du skal ha god grunn til å velge en annen implementasjon.
Bruk av List (ArrayList)
• add(object) – legger til objekt
• get(int) – henter objekt med gitt indeks
• size() – størrelsen på lista
11
List-grensesnittet
(posisjon og duplikater)
this
arg
overlapp
.addAll(
12
samme relative
posisjon og rekkefølge
)=>
.removeAll(
)=>
.retainAll(
)=>
this
etterpå
Set-grensesnittet
(ingen posisjon, ikke duplikater)
this
arg
overlapp
.addAll(
13
potensielt stokket
eller sortert
)=>
.removeAll(
)=>
.retainAll(
)=>
this
etterpå
add-metoden
• skyter et objekt inn mellom de andre
• objektene med høyere indeks forskyves og endrer
posisjon 0
i-1 i i+1
nytt element
0
i-1
i i+1
• add uten indeks legger til på slutten
nytt element
14
remove-metoden
• fjerner et element
• lista klemmes sammen
• to varianter:
– fjern bestemt objekt
– fjern objekt på bestemt posisjon
skal fjernes
15
0
i-1
i i+1
0
i-1
i
Konvertering mellom
List og tabell
• Hvordan lage en List fra en tabell
– Arrays.asList(T[] tab) returnerer en List<T> med tab som innhold, og
som ikke kan endres.
– ArrayList har en konstruktør som initialiserer den med innholdet til en
eksisterende Collection.
– Card[] cards = …
List<Card> cardList =
new ArrayList<Card>(Arrays.asList(cards));
• Hvordan lage en tabell fra en List
– List.toArray(T[] t) returnerer t fylt med lista sitt innhold.
– List<Card> cardList = …
Card[] cards = new Card[cardList.size()];
cardList.toArray(cards);
16
Collection-klasser (inkl. Iterator)
og (parameter- og resultat)typer
•
•
•
Når en bruker en Collection i praksis, er elementene en legger inn og tar
ut ofte av en spesifikk type, f.eks. String eller Person.
Likevel må en i utgangspunktet bruke casting når en henter ut
elementer, f.eks. Person p = (Person)liste.get(i)
Ved å konsekvent deklarere Collection-, List-, Iterator- og Iterablevariabler med <type> bak, forteller vi at klassen er begrenset til å kun
behandle objekter av denne spesifikke typen (eller subtyper):
List<String> tekst = new ArrayList<String>();
// add tar inn en String, og det vet Java!
tekst.add(”En String”);
// get returnerer String, og
// det skjønner også Java!
String s1 = tekst.get(0);
17
Collection-klasser (inkl. Iterator)
og (parameter- og resultat)typer
• <type>-deklarasjoner bestemmer/begrenser
parametertypen/returtypen til metoder som
add, remove, get, next, iterator osv.
• <type>-deklarasjoner er lov etter List,
ArrayList, Iterator, Iterable og generelt de
fleste klasser i Collection-rammeverket.
• Bruk alltid <type> bak, så blir koden sikret
mot en viktig type type-feil.
18
Eksempel på bruk av <type>
// lag og bruk en String-liste
// både deklarasjon og new-uttrykk begrenses
List<String> stringListe = new ArrayList<String>();
// String-lista sin add-metode krever et String-argument
stringListe.add(”En string”);
stringListe.add(”Enda en string”);
int pos = stringListe.indexOf(”En string”);
// get-metoden returnerer nødvendigvis en String
String enString = stringListe.get(pos);
19
Map-grensesnittet
• Map<K,V> er en spesiell type samling (ikke en
Collection) som brukes til tabelloppslag, dvs. når
en ønsker å finne et objekt, basert på et annet
– Map brukes typisk når en koblingen mellom objekter er temporær
K
V
En map implementerer en
matematisk funksjon:
avbildning fra et
nøkkelsett til et verdisett
• Metoder:
20
–
–
–
–
–
put(K key, V verdi) – knytter key til verdi
V get(Object key) – returnerer verdien som er knyttet til key
boolean containsKey(Object key) – sier om key finnes i nøkkelsettet
Set<K> keySet() – settet av nøkler
Collection<V> values() – samlingen av verdier
21
http://www.falkhausen.de/en/diagram/html/java.util.Map.html
Stack-klassen
• Stack<T>-klassen implementerer en
stabel, dvs. en samling med egne
operasjoner for å legge på og ta av fra
toppen
– push(T t) – legger t på toppen
– T pop() – tar bort og returnerer øverste element
– T peek() – returnerer øverste element, uten å ta det bort
22
Queuegrensesnittet
• Queue<T>-grensesnittet spesifiserer
metoder for en kø, dvs. en samling
med egne operasjoner for å legge til i
ene enden og ta ut i andre
– offer(T t) – legger t til inn-enden
– T poll() – tar ut (fjerne) et element i ut-enden
– T peek() – returnerer elementet i ut-enden, uten å fjerne
det
23
• Implementeres av LinkedList
Læringsmål for forelesningen
• Objektorientering
– Bruk av grensesnitt og implementasjoner i Collection-klasser
• Java-programmering
– Collection-rammeverket og
iterasjon med Iterator og Iterable
– Bruk av <type>-deklarasjoner ifm. collections
(såkalte ”generics”).
• Eclipse
– Kodemaler for for-konstruksjonen
24