Föreläsning 10. ADT:er och datastrukturer

Föreläsning 10 ADT:er och datastrukturer

ADT:er och datastrukturer Dessa två begrepp är kopplade till varandra men de står för olika saker. En ADT (abstrakt datatyp) är just abstrakt och är inte kopplad till något programmeringsspråk eller till implementering. En datastruktur är konkret och till de flesta programmeringsspråk finns en eller flera inbyggda datastrukturer. 2

ADT (abstrakt datatyp) En ADT är en programspråksoberoende beskrivning av en mängd data och operationer på denna data för att lagra, komma åt och manipulera den. Abstrakta datatyper är abstrakta i den meningen att det inte finns definierat hur datan och operationerna är implementerade. Primitiva datatyper som heltal och flyttal har värde och operationer (t.ex. plus, minus, multiplikation och division). Precis som primitiva datatyper har värde och operationer har också abstrakta datatyper det. I objektorienterade programmeringsspråk (som Java) implementeras ADT:er med klasser. 3

ADT (abstrakt datatyp) Exempel på vanliga abstrakta datatyper är: - mängd - sekvens (lista, kö, stack) - träd (binärt sökträd, AVL-träd, B-träd) - graf I lab 3 kom vi i kontakt med ADT:n Memory som är en beskrivning av den data och de operationer (på den datan) som behövs för en miniräknare. Många programmeringsspråk har inbyggda implementationer av vissa ADT:er. Exempelvis finns olika list-implementationer i Java. I Java finns också olika gränssnitt för att underlätta implementerandet av ADT:er. 4

Datastruktur En datastruktur är en samling data (sammanbundna på något sätt) med ett namn och en mängd operationer. Operationerna kan variera från datastruktur till datastruktur men inkluderar metoder för att ge åtkomst till datan. När man implementerar en ADT kan man behöva en datastruktur. En datastruktur kan modellera en abstrakt datatyp. I Java finns flera datastrukturer som modellerar en lista: - Vector (bygger på en array) - ArrayList (bygger på en array) - DefaultListModel (bygger på en Vector) - LinkedList (bygger på länkade noder) 5

ADT:n Lista Datat i en lista utgörs av en ordnad sekvens av element. Operationerna utgörs exempelvis av: - insättning av element (på godtycklig plats) - borttagning av element (på godtycklig plats) - borttagning av specifikt element - sökning av element - beräkning av listans storlek - kontroll av huruvida listan är tom eller inte - platsbestämning av ett visst element - utplockning av element på en viss plats 6

Klassen Vector Klassen Vector är en datastruktur som modellerar en lista. Klassen Vector är en generisk klass, vilket innebär att man med den kan skapa alla typer av listor (exempelvis heltalslistor, ellipslistor, etc.). När man skapar listan (med new) talar man om vad för slags element listan ska innehålla. Vector <Ellipse> _ellipselist; _ellipselist = new Vector <Ellipse>(); Klassen Vector finns i paketet java.util 7

Några metoder i klassen Vector Metod Vector <E>() void addelement(e element) E elementat(int index) boolean isempty() boolean remove(e element) E remove(int index) int size() Beskrivning Skapar en tom lista av element av typ E Lägger element i slutet av listan Returnerar elementet på plats index i listan Returnerar sant om listan är tom, annars falskt Tar bort första förekomst av element i listan Tar bort elementet på plats index i listan Returnerar antalet element i listan 8

import java.util.*; public class DataStructures { private Vector <Integer> _vector; } Att använda generiska klasser public DataStructures() { _vector = new Vector<Integer>(); } public void test() { int sum = 0; for (int i = 0; i < 5; i++) _vector.addelement(new Integer(i)); for (int i = 0; i < _vector.size(); i++) sum += _vector.elementat(i).intvalue(); System.out.println( Summan = + sum); } public static void main(string [] args) { DataStructures ds = new DataStructures(); ds.test(); } 9

Att göra generiska klasser public class Holder <E> { private E _element; } public Holder() { super(); } public E getelement() { return _element; } public void setelement(e aelement) { _element = aelement; } 10

Jämförelse av List-klasser Klass Underliggande struktur Generisk Vector Array Ja ArrayList Array Ja DefaultListModel Vector Nej (lista av Object) LinkedList Länkade noder Ja Kommentarer: Vector och ArrayList nästan identiska klasser. Vad skiljer dessa från en array? (Se tabell 13.1) Vad skiljer en array från länkade noder? Vad innebär det att DefaultListModel är en lista av Object? 11

Jämför array med klasserna Vector och ArrayList Fördelar Nackdelar Array Mer effektiv Storlek måste anges Vector & ArrayList Växer, krymper Ökad läsbarhet Mindre effektiv För fler skillnader, se kursboken tabell 13.1. 12

Jämför array med länkade noder m in n e t Array (med 5 element): + effektiv vid hämtning - ineffektiv vid insättning och borttagning Länkad lista (med 5 element): + effektiv vid insättning och borttagning - ineffektiv vid hämtning 13

Jämför generiska List-klasser med List-klasser med Object Antag att vi har en klass Person med konstruktorn public Person(String aname, int anage) och att vi vill skapa en lista med personer. Alternativ 1: Använd en generisk klass som Vector: Vector<Person> _list = new Vector<Person>(); _list.addelement(new Person( Siv, 25));... Person p = _list.elementat(0); Alternativ 2: Använd en klass med Object (Default- ListModel) och polymorfism: DefaultListModel _list = new DefaultListModel(); _list.addelement(new Person( Erik, 16));... Person p = (Person)_list.elementAt(0); 14

Designmönstret Iterator Pattern Med Iterator-mönstret kan en klient komma åt innehållet i en datastruktur utan att känna till detaljerna om datastrukturens uppbyggnad. I Java implementeras Iterator-mönstret som gränssnittet Iterator med följande metoder: Metod boolean hasnext() E next() void remove() Beskrivning Returnerar sant om fler element finns att besöka Returnerar nästa element att besöka Tar bort det senast returnerade elementet 15

Designmönstret Iterator Pattern Ett exempel på hur man använder Iterator-mönstret. Antag att vi vill göra en metod för att summera heltalen i en Vector<Integer>-lista: public int sum(vector<integer> vek) { int sum = 0; Iterator<Integer> iterator = vek.iterator(); while (iterator.hasnext()) { sum += iterator.next().intvalue(); } } return sum; Jämför med metoderna till Scanner-klassen, som implementerar Iterator<String>. 16

Syftet med Lab 4 är att: ge övning i att använda abstrakta datatyper (ADT), ge övning i att använda olika datastrukturer, ge övning i att använda kontrakt (för- och eftervillkor), ge övning i att skriva kommentarer i kod, och ge fortsatt övning i objektorienterad programmering och i att göra grafiska användargränssnitt. 17

Laborationsuppgift Gör ett grafiskt användargränssnitt för en affär med följande funktioner: Användaren ska kunna lägga till en person i affären med namn och ålder. Användaren ska kunna flytta en av personerna i affären till en av de två kassaköerna. Användaren ska kunna låta betjäna personen först i någon av kassaköerna (dvs personen lämnar kassakön och butiken). Dessutom ska det grafiska användargränssnittet hela tiden visa personerna (med namn och ålder) som finns dels ute i butiken och dels i de båda kassaköerna. 18

Analys (substantiv i rött, verb i blått) Gör ett grafiskt användargränssnitt för en affär med följande funktioner: Användaren ska kunna lägga till en person i affären med namn och ålder. Användaren ska kunna flytta en av personerna i affären till en av de två kassaköerna. Användaren ska kunna låta betjäna personen först i någon av kassaköerna (dvs personen lämnar kassakön och butiken). Dessutom ska det grafiska användargränssnittet hela tiden visa personerna (med namn och ålder) som finns dels ute i butiken och dels i de båda kassaköerna. 19

Analys Analysen ger att vi bör ha klasser för (substantiven) - Affär - Kö (kassakö) - Person Klassen Person bör ha attribut för - Namn - Ålder Klassen Affär bör ha komponenter - Kö (2 stycken) och följande metoder (verben) - lägga till (person) - flytta (person till någon av de två köerna) - låta betjäna (person först i kön försvinner) Klasserna Affär och Kö måste ha en lista för att spara personer. 20

Design Gör ADT:er. Försök att göra ADT:n Kö, dvs tänk igenom vilka egenskaper och metoder en kö ska ha. Gör kontrakt till metoderna. Gör en skiss på layouten och tänk igenom vilka komponenter som behövs. Förutom knappar (JButton), etiketter (JLabel), fönster (JFrame) och paneler (JPanel) behöver vi till denna applikation textfält (JTextField) där användaren kan skriva in personernas namn respektive ålder samt fält där personerna i affären och i köerna visas. Använd swing-komponenten JList för dessa fält (klickbar). När man skapar ett JList-objekt ska man samtidigt skicka med en lista (DefaultListModel). Låt därför listorna som finns i klasserna Affär och Kö vara av typen DefaultListModel. 21

Design Skissa på ett UML-diagram. Ett första utkast kan se ut så här: Affär - _lista: DefaultListModel - _kassa1: Kö - _kassa2: Kö + Affär() + läggatill(?):? + flytta(?):? + betjäna(?):? + getlista(): DefaultListModel... 1 2 Kö - _lista: DefaultListModel jmf. med ADT:n Person - _namn:? - _ålder:?? 22

Implementering Utgå från klassdiagrammet. Det är bättre att göra många och korta metoder än få och långa. De tre klasserna för Affär, Kö och Person måste finnas med (namnen på dem kan dock bytas ut). De tre klasserna ovan måste vara ordentligt dokumenterade i koden med beskrivning och kontrakt för varje metod. Använd swing-komponenten JList för att visa personerna i GUI:t (se Java API). Använd datastrukturen DefaultListModel för listorna i Affär och Kö. 23

Testning Testa applikationen noga för alla möjliga indata (även de som är felaktiga ). Tänk på vettiga felutskrifter i GUI:t. Inga undantag får kastas utan att fångas upp. 24