Collection Classes

Collection Classes

Koppling mellan abstraktioner på hög nivå och praktiska och effektiva implementationer av datastrukturer

abstraktionerna: naturliga matematiska begrepp

• mängder,

• sekvenser

• avbildningar (maps/tabeller) Vårt mål:

• lära lite om CC (mycket användbart)

Men först

• Repetition: Student.java, StudentTest.java

• Gränssnitt (Interface)

• Parametriska typer

Interface, första exempel

public interface MyInterface { void aMethod(int i);

}

public class MyClass implements MyInterface { public void aMethod(int i) {

...

} ...

}

Interface (forts)

• Vi säger att en klass implementerar ett interface.

• En klass kan bara ärva en annan klass men implementera många interface.

• Man kan använda interface för att hänga på en klass ytterligare egenskaper.

• En ’vanlig’ variabeldeklaration beskriver hur det data som variabeln lagrar ser ut

• En variabel som deklareras att vara av ett visst

interface: varje objekt som variabeln refererar måste implementera gränssnittet

Exempel på interface i Javas API

• EventListener

• Comparable

• List, Set, Map

• Iterator

Samlingar (Collections Framework)

• relativt nytt: Från Java 2 platform, version 1.2

• idé: ett litet antal generella gränssnitt (interface) som beskriver mängder, sekvenser, tabeller

• varje samling implementerar ett eller flera gränssnitt

• Flera utökningar i Java 5 underlättar: generaliserad for-loop, autoboxing/unboxing, generiska typer

Generiska typer–exempel

public class Box<X> { private X x;

public X getX() { return x;

}

public void putX (X x0) { x = x0;

}

Genererisk typ—test

public static void main (String [] arg) { Box<String> b = new Box<String> ();

b.putX("Foo");

String s = b.getX();

System.out.println(s);

Box<Integer> c = new Box<Integer> ();

c.put(42);

int i = c.getX();

System.out.println(i);

}

Allmänt om generiska typer

• Parametrarna “lever” bara vid kompileringstillfället.

• I princip kan ett Java 5-program generera samma bytekod som ett Java 1.4.2-program.

• Jfr templates i C++.

• Typ-parametrarna används när kompilatorn kontrollerar programmet—och sätter in vissa konverteringar (autobox/unboxing).

Parametriska metoder

class Id {

public static <T> T id(T x) { return x;

} }

Collection Classes

Jia: 8.2, Skansholm: 17

Se även Suns tutorial om Collections

Motivation:

Vill samla olika datastrukturer för att representera tabeller, mängder, sekvenser i ett standardbibliotek.

Viktigt att alla datastrukturer kan hanteras på ett likartat sätt, så att

• det är lätt att lära sig använda biblioteket

• man kan lätt ändra val av datastruktur

• lätt att sätta ihop olika programkomponenter som skickar och tar emot datastrukturer i form av

samlingar

Olika slag av samlingar i Java

• Arrayer (Till exempel: int[]) – grundläggande

– lagrar alla datatyper

• Vector

– liknar array

– men kan expanderas

– lagrar endast ’äkta’ objekt (som definierats i en klass)

Repetition: Interface

En slags ’lättviktsklasser’.

Beskriver en uppsättning metoder.

Man säger att en klass implementerar ett interface.

Collections, ett första exempel

• Simple.java

• Simple142.java

Samma exempel i gamla Java

Interface för samlingar

Set List SortedMap Collection Map

SortedSet

Exempel på klasser som implementerar samlingar

• ArrayList

Arrayer. Implementerar List

• LinkedList

Länkade listor. Implementerar List

• HashMap

Hashtabeller. Implementerar Map

• TreeSet

Balanserade binärträd. Implementerar Set, SortedSet

Collection

En samling element

operationer för att lägga till och ta bort element Konvention:

Varje klass K som implementerar Collection har en konstruktor K(Collection c)

(som tar en godtycklig samling)

Därmed kan man lätt konvertera mellan olika samlingar

Operationer på Collection <E>

• int size()

• boolean isEmpty()

• boolean contains(Object element)

• boolean remove(Object element)

• boolean add(E element)

• Iterator<E> iterator()

Operationer på många element

• boolean containsAll(Collection<?> c)

• boolean addAll(Collection<? extends E> c)

• boolean removeAll(Collection<?> c)

• boolean retainAll(Collection<?> c)

• void clear()

• E[] toArray()

Iteratorer

Tre operationer på Iterator<E>

boolean hasNext();

E next();

void remove();

Lite om utökade for-loopar

Man kan skriva for(type x : c) {

om c är av en typ som implementerar gränssnittet Iterator.

Detta översätts till kod som använder iteratorer.

(Jfr exemplet Simple.java)

Denna notation kan även användas för iteration över arrayer.

Collections: Ett exempel

import java.util.*;

class A {

public static void main(String args[]) {

List<String> l = new ArrayList<String>();

for (int i=0; i<args.length; i++) l.add(args[i]);

System.out.println(l);

} }

Körexempel

$ javac A.java

$ java A en gång är ingen gång [en, gång, är, ingen, gång]

$

Exempel: LinkedList Program B.java

Exempel (med for-loopar) Program C.java

Gränssnittet Set

• Representerar mängder

• En samling föremål, utan inbördes ordning

• samma operationer som Collection

• Implementeras av HashSet och TreeSet

• (TreeSet implementerar även SortedSet)

Exempel: HashSet Program: D.java

Gränssnittet SortedSet

En mängd som garanterar att dess iterator kommer att traversera mängden enligt elementens “naturliga”

ordning, eller enligt en Comparator (en slags jämförelseoperator) som ges till konstruktorn,

Alla element som sätts in i en sorterad mängd måste antingen implementera gränssnittet Comparable (eller accepteras av en given Comparator)

SortedSet<E>, operationer

• E first()

Returnerar första elementet

• E last()

Sista elementet

• SortedSet subSet(E a, E b)

returnerar en vy bestående av alla element i

mängden från och med element a fram till (men exklusive) element b

Exempel: TreeSet public class E {

public static void main(String args[]) {

Set<String> l = new TreeSet<String>();

for (String s : args) l.add(s);

System.out.println(l);

} }

Körexempel TreeSet

$ javac E.java

$ java E bättre en fågel i handen än tio i skogen [bättre, en, fågel, handen, i, skogen, tio, än]

$ java E ö åra älv [älv, åra, ö]

$

Kort mellanspel 1

Gränssnittet Comparator<E> definierar metoden public int compare(E o1, E o2)

som jämför sina två argument och returnerar

• ett negativt tal om första argumentet är mindre än det andra

• noll om dom är lika

• ett positivt tal om första argumentet är större.

Kort mellanspel 2 Svensk sortering

Klassen Locale representerar en geografisk, politisk eller kulturell region.

Skriv new Locale("sv", "se") för svenska språket (sv) och Sverige (se).

Klassen Collator implementerar gränssnittet

Comparator<Object>. Den har en statisk metod Collator getInstance(Locale desiredLocale)

som skapar en jämförelseoperator för en given region.

Exempel: Svensk sortering

class F {

public static void main(String args[]) { Collator collator =

Collator.getInstance(new Locale("sv", "se"));

SortedSet l = new TreeSet(collator);

[...]

}}

Körexempel: Svensk sortering

$ javac F.java

$ java E Ögren Vallander Vikström Wiklund Åberg Änglund [Vallander, Vikström, Wiklund, Änglund, Åberg, Ögren]

$ java F Ögren Vallander Vikström Wiklund Åberg Änglund [Vallander, Wiklund, Vikström, Åberg, Änglund, Ögren]

$

Gränssnittet List<E>

En sekvens av objekt där samma objekt kan förekomma flera gånger

Operationer ur Collection E get(int index)

E set(int index, E element)

• get

• set

• E add(int index, E element)

• int indexOf(E element)

Gränssnittet List: implementationer

List implementeras av ArrayList och LinkedList

• ArrayList

Access via position är snabbt.

Att skjuta in eller ta bort element (med add och remove) är dyrt.

• LinkedList

Access via position är dyrt.

Gränssnittet Map<K,V>

En avbildning, eller tabell

Skansholm: Avbildningstabell

Idé: En association mellan objekt.

(K – nycklar; V – värden)

Exempel: en telefonkatalog. Givet ett namn kan vi ta fram telefonnummer

Implementeras av HashMap<K,V> och TreeMap<K, V>

TreeMap<K, V> implementerar även SortedMap<K, V>

Gränssnittet Map<K, V>: operationer V put(K key, V value)

V get(Object key)

V remove(Object key)

boolean containsKey(Object key) boolean containsValue(Object key) int size()

boolean isEmpty()

Gränssnittet Map (forts)

void putAll(Map<? extends K, ? extends V> t) void clear()

Set<K> keySet() Collection values() Set<V> entrySet()

Gränssnittet Map.Entry<K, V>:

K getKey() V getValue() V setValue(V)

Hitta duplicerade ord med HashSet

Program: FindDups.java, FindDups2.java

Autoboxing/unboxing, bakgrund

För var och en av de åtta primitiva datatyperna finns en motsvarande klass, tex

int — Integer boolean — Boolean

Man kan konvertera mellan genom att skriva Integer x = new Integer(42);

int y = x.intValue();

Autoboxing/unboxing i java 5.0

I Java 5.0 sker konverteringen automatiskt, man kan skriva

Integer x = 42;

int y = x;

Man kan klara sig utan de primitiva typerna:

Integer s = 0;

for (Integer i = 0; i<10; i++) { s = s + i;

Räkna antal förekomster

Program: Freq.java, Freq2.java

Kort mellanspel: Klassen StringBuffer

Exempel:

x = "a" + 4 + "c"

kan även skrivas

x = new StringBuffer().append("a").append(4).append("c").toString() Konstruktorer:

• StringBuffer(String s)

• StringBuffer(int l)

• StringBuffer append (boolean b)

• char charAt(int i)

• void setCharAt(int i, char c)

• String toString()

Perm2.java

• Problem: Givet en fil med ord, hitta ord som är varandras permutationer.

• Lösning: Definiera en funktion alphabetize som tar en sträng och returnerar en sträng med bokstäverna i alfabetisk ordning.

• Bygg en tabell Map<String,List<String>> där

strängarna läggs in enligt den alfabetiserade nyckeln.

• Två strängar med samma nyckel är varandras

• Definiera en egen ordning på strängar (CaseInsensitiveComparator).

• Definiera en klass med en egen ordning (Person) enligt:

1. Ordna först efter namn, 2. sen efter ålder

• En klass med egen ordning, Person2, som låter alla över 65 få företräde.