-Algoritmer och DatastrukturerListor & Generics
”Ording och reda” på datastrukturer i
java med hjälp av olika interface
En datastruktur är:
data (representerad på
olika sätt)
Metoder
Finns i java.util
http://java.sun.com/j2se/1.5.0/
docs/api/
Collection- generell samling data
List- ordnad samling av data
Set- ordnad samling av data som får inte
innehålla dubbletter
Map- Samling av data i par ( objekt+ nyckel)
Queue, - samling data som tillåter access efter en
bestämd ordning
För utveckling av verksamhet, produkter och livskvalitet.
För utveckling av verksamhet, produkter och livskvalitet.
Interface Collection
Interface List
• Basen är ett interface Collection som representerar en
samling element utan något vetskap om hur elementen är positionerade.
Collection interfacen innehåller följande metoder:
boolean isEmpty ();
boolean add (E x);
boolean contains (Object x);
boolean remove (Object x);
void clear ();
int size ();
Iterator iterator ();
……………………
För utveckling av verksamhet, produkter och livskvalitet.
Listor är en ordnad samling (”rad”) av object
public interface List extends Collection{
void add (int idx, Object element);
boolean add (Object element);
Object get (int idx);
Object set (int idx, Object element);
Iterator iterator ();
...
...
}
För utveckling av verksamhet, produkter och livskvalitet.
1
Queue
List-klasser i java
En ordnad samling av objekt
Man kan bara komma åt första objekten i kö
Man kan lägga till bara sist i kö
•
Det finns två konkreta generiska klasser i Javas API för listhantering. Båda
implementerar alltså interfacet List
ArrayList som implementerats med array
LinkedList, som använder länkad struktur. Enskilda ”Nod” av data som länkas
med varandra.
………………………………………
void enqueue ( Object e);
Object dequeue ();
Head
För utveckling av verksamhet, produkter och livskvalitet.
För utveckling av verksamhet, produkter och livskvalitet.
En ”SimpleDataStructure”
Ett program
public class SimpleDataStructure
{
// data hålls i en array
private int theSize;
private Object [ ] theItems;
// ta bort objekt om det hittas, inte helt bra
public boolean remove ( Object obj)
{
int idx=-1;
boolean found =false;
for(int i=0;i<theItems.length; i++)
// konstruerare
public SimpleDataStructure()
{
theItems=new Object[10];
theSize=0;
}
// inte så bra
public void add ( Object obj)
{
theItems [thesize]=obj;
theSize++;
}
if( obj.equals(theItems[i]) ) {
idx=i;
found=true;
break;
}
for( int i = idx; i < theSize - 1; i++ )
theItems[ i ] = theItems[ i + 1 ];
theSize--;
return found;
}
För utveckling av verksamhet, produkter och livskvalitet.
public class Program
{
...main()....{
SimpleDataStructure ladok =new SimpleDataStructure ();
ladok.add( new Student() );
ladok.add( new Student());
..........................................
( av misstag efter 1000 rader kod)
ladok.add( new Donkey());
}
}
För utveckling av verksamhet, produkter och livskvalitet.
2
En ”SimpleDataStructure” generic
Generiska klasser i Java 5.0
public class SimpleDataStructure <AnyType>
implements Collection <AnyType>
{
private int theSize;
private AnyType [ ] theItems;
• Typparametrar anges inom tecknen < och > i klassrubriken:
public class ArrayList<E> { ... }
public void add ( AnyType obj)
{
theItems[thesize++]= obj;
}
public class Program
{
...main()....{
SimpleDataStructure <Student> ladok=
new SimpleDataStructure <Student> ();
•
Typparametern kan användas i klassen för att t ex deklarera attribut,
parametrar och returtyper för metoder
}
public class ArrayList <E> {
private E [] elements;
public boolean add(E x) { ... } // lägg in x sist
public E get(int i) { ... } //hämta element på plats i
...
}
•
Vi skapar instanser genom att ge parametern E ett ”verkligt datatyp”
ArrayList < Student> iList = new ArrayList < Student> ();
I iList kan endast Student -objekt läggas in
För utveckling av verksamhet, produkter och livskvalitet.
För utveckling av verksamhet, produkter och livskvalitet.
Interface Comparable som ”generic”
En klass som implementear en
”generic” interface, enkel fall
public boolean remove( AnyType obj){
// idx- hitta index of objekt obj
........
for( int i = idx; i < size( ) - 1; i++ )
theItems[ i ] = theItems[ i + 1 ]
theSize--;
return found;
}
•
ladok.add( new Student());
ladok.add( new Student());
...........................................
ladok.add( new Donkey()); // compile error
}}
I java biblioteket finns interfacen Comparable som används för att definiera
objekt som kan jämföras och rangordnas
public interface Comparable<AnyType>
{
public int compareTo( AnyType other);
}
För utveckling av verksamhet, produkter och livskvalitet.
class Ball implements Comparable <Ball>
{
private int radius;
public Ball ( int value)
{
radie=value;
}
public void move (){…..}
AnyType
ersäts med
Ball
public int compareTo( Ball other)
{
if (radius>other.radius)
return 1;
else if (radius<other.radius)
return -1;
else
return 0
}
För utveckling av verksamhet, produkter och livskvalitet.
3
En klass som implementear en
”generic” interface, Svår fall
AnyType
ersäts med
Person
class Person implements Comparable <Person>
{
private String name;
private int age;
Interface Comparator som alternativ
class AgeComparator implements
Comparator<Person>{
public int compare (Person emp1, Person emp2)
{
……………………………………………….
public int compareTo( Person other)
{
if( name.compareTo(other.getName())==0) /jämför namn
{ if (adress .......) // jämför adress
class NameComparator implements
Comparator<Person>{
public int compare(Person emp1, Person
emp2){
String emp1Name = emp1.getName();
String emp2Name = emp2.getName();
int emp1Age = emp1.getAge();
int emp2Age = emp2.getAge();
}
}
if(emp1Age > emp2Age)
return 1;
else if(emp1Age < emp2Age)
return -1;
else
return 0;
return emp1Name.compareTo(emp2Name)
}
}
}
}
}
För utveckling av verksamhet, produkter och livskvalitet.
För utveckling av verksamhet, produkter och livskvalitet.
Hur används ”Comparator-s” ?
En ”generic” algoritm- findMax metoden
Program exempel TestComparator
public static <AnyType extends Comparable<? super AnyType>>
AnyType findMax ( AnyType [ ] a )
{
int maxIndex = 0;
for( int i = 1; i < a.length; i++ )
if( a[ i ].compareTo ( a[ maxIndex ] ) > 0 )
maxIndex = i;
return a[ maxIndex ];
}
För utveckling av verksamhet, produkter och livskvalitet.
För utveckling av verksamhet, produkter och livskvalitet.
4
Interface Iterator , Iterable
* Iterator interface for Collections.
*/
public interface Iterator< AnyType>
{
* Tests if there are more items in the collection.
* @return true if there are more items in the collection.
boolean hasNext ( );
* Obtains the next item in the collection.
* @return the next (as yet unseen) item in the collection.
AnyType next( );
}
* Remove the last item returned by next.
* Can only be called once after next.
void remove( );
En iterable datastruktur
import java.util.*;
public class MyArrayList<AnyType> implements Iterable<AnyType>
{
private AnyType [] list ;
private int count ;
……………………………………………….
public Iterator <AnyType> iterator()
{
return new ArrayListIterator (list, count);
}
}
För utveckling av verksamhet, produkter och livskvalitet.
För utveckling av verksamhet, produkter och livskvalitet.
En ArrayListIterator
Iterator fortsättning
import java.util.*;
class ArrayListIterator <T> implements Iterator<T>
{
private int count;
private int current;
private T[] items;
public boolean hasNext()
{
return current<count;
// konstruerare
public ArrayListIterator(T[ ] elements, int size)
{
items=elements;
count=size;
current=0;
}
}
public T next ()
{
current++;
return items [current-1];
}
public void remove()
{
// metoden måste vara med men lämna den tom
}
}
För utveckling av verksamhet, produkter och livskvalitet.
För utveckling av verksamhet, produkter och livskvalitet.
5
List-klasser i java
Test
• Det finns två konkreta generiska klasser i Javas API för
listhantering. Båda implementerar alltså interfacet List
ArrayList som implementerats med array
LinkedList, som använder länkad struktur i implementationen
“Testing
Man bör bara använda ArrayList om alla insättningar görs
sist i listan. Insättningar i andra positioner samt remove orsakar flyttningar av
element.
“Testing can show the presence of bugs, but not the
absence” (Dijkstra)
is the process of executing a program with
the intent of finding errors” (Myers)
https://supportweb.cs.bham.ac.uk/docs/tutorials/docsystem/build/tutorials/juni
t/junit.html
För utveckling av verksamhet, produkter och livskvalitet.
Varför är vi inte bättre på TEST?
• Testning är onödigt och icke produktiv
• Om utvecklingen sker korrekt kommer alltid
kravet att vara uppfyllt
• Utveklingstiden för mjukvara är svårbedömd.
Oftast brist om tid.
• Leveransen i tid är viktigare än felfri mjukvara
• Test gör slumpmässigt och oplanerat
För utveckling av verksamhet, produkter och livskvalitet.
För utveckling av verksamhet, produkter och livskvalitet.
Test begrepp
-Olika typer av test, som utförs på olika nivå i
mjukvaruutveckling.
- De klassificeras i en av kategorin ”white-box” eller black-box
Enhets
test
Unittest
Integrations
test
Funktions
test
Funktionstestet
Modultest testar systemet
som en helhet
utifrån de
funktionella krav
System
test
Acceptans
test
Systemtester testar
systemet fungerar
enligt de
övergripande
specifikationer
Systemtest
men utförs
av
slutanvänd.
För utveckling av verksamhet, produkter och livskvalitet.
6
Vad skall vi testa?
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
public class SimpleDataStructureTest {
/** Fixture initialization (common initialization
* for all tests). **/
@Before public void setUp() {
}
/** A test that always fails. **/
@Test public void defaultTest() {
Assert.assertEquals ("Default test added by jGRASP. Delete "
+ "this test once you have added your own.” , 0, 1);
}
}
För utveckling av verksamhet, produkter och livskvalitet.
Statement
Description
fail(String)
Let the method fail. Might be used to check that a certain part of
the code is not reached. Or to have failing test before the test
code is implemented.
assertTrue(true) / assertTrue(false)
Will always be true / false. Can be used to predefine a test result,
if the test is not yet implemented.
assertTrue([message], boolean
condition)
Checks that the boolean condition is true.
assertsEquals([String message],
expected, actual)
Tests that two values are the same. Note: for arrays the reference
is checked not the content of the arrays.
assertsEquals([String message],
expected, actual, tolerance)
Test that float or double values match. The tolerance is the
number of decimals which must be the same.
assertNull([message], object)
Checks that the object is null.
assertNotNull([message], object)
Checks that the object is not null.
assertSame([String], expected, actual)
Checks that both variables refer to the same object.
assertNotSame([String], expected,
actual)
Checks that both variables refer to different
** Testar metoden add
// - add av 1 objekt blir size 1
// - add när dubblering sker, testa size
// - add och contains
// - add mot get
// - add och isEmpty
// - add och indexof
** Testar remove
// - remove mot size()
// -remove mot contains
// -remove när isEmpty
// - remove när objektet inte finns *
** Testar get
och IndexOutofBounds
// - contains mot
För utveckling av verksamhet, produkter och livskvalitet.
Annotation/ speciella komentarer
•
•
•
•
För utveckling av verksamhet, produkter och livskvalitet.
@Test public void method() The annotation @Test identifies that a
method is a test method.
@Before public void method() Will execute the method before each test.
This method can prepare the test environment (e.g. read input data,
initialize the class).
@After public void method() Will execute the method after each test.
This method can cleanup the test environment (e.g. delete temporary data,
restore defaults).
@BeforeClass public void method() Will execute the method once,
before the start of all tests. This can be used to perform time intensive
activities, for example to connect to a database.
För utveckling av verksamhet, produkter och livskvalitet.
7
Annotations
•
@Test (expected = Exception.class) Fails, if the method does not throw
the named exception.
•
@Test(timeout=100) Fails, if the method takes longer than 100
milliseconds
För utveckling av verksamhet, produkter och livskvalitet.
Använd inte Unit Test om
• Metoden/ modulen kommunicerar med lokal
databas
• Kommunicerar över nätverk
• Använder filsystem
För utveckling av verksamhet, produkter och livskvalitet.
8
