Bank. Bank. BankAccount. Bank. Bank. private BankAccount[] conti; // Posizione attuale private int posizioneattuale;...

Transcript

1 Bank BankAccount Bank Bank Bank BankAccount private BankAccount[] conti; // Posizione attuale private int posizioneattuale;...

2 Bank Bank public Bank(String nome, String internationalcode, int dimensione) {... conti = new BankAccount[dimensione]; posizioneattuale = 0; public BankAccount nuovoconto(string intestatario, double initialbalance) throws DimensioneBancaInsufficienteException { if (posizioneattuale == conti.length) throw new DimensioneBancaInsufficienteException("Si vogliono inserire più di " + conti.length + " conti, che è la dimensione massima."); else {... // Crea il conto equals

3 final BankAccount final BankAccount public class BankAccount { // Si suppone sia un identificativo, il // metodo equals usa questo valore // per confrontare gli oggetti private final String idconto; // Intestatario del conto private String intestatario; private GregorianCalendar datacreazione; private double saldo; public boolean equals(object o) { if (!(o instanceof BankAccount)) return false; BankAccount other = (BankAccount) o; return idconto.equals(other.idconto);

4 idconto hashcode String public int hashcode(){ return idconto.hashcode(); equals BankAccount idconto i equals public int search(string idconto) { // Conto fittizio per il confronto BankAccount confronto = new BankAccount(idConto, "", 0); // Ricerca lineare incerta boolean trovato = false; int i = 0; while (i < posizioneattuale &&!trovato) if (conti[i].equals(confronto)) trovato = true; else i++; public boolean remove(string idconto) { int pos = search(idconto); if (pos == -1) return false; for (int i = pos; i < posizioneattuale -1; i++) conti[i] = conti[i+1]; conti[posizioneattuale - 1] = null; posizioneattuale--; return true;

5 java.util List<E> <E> List<E> public interface List<E> extends Collection<E> { // Accesso E get(int index); E set(int index, E element); // Optional boolean add(e element); // Optional void add(int index, E element); // Optional E remove(int index); // Optional mylist mylist.get(i) mylist[i] mylist.set(i, o); mylist[i] = o; add(o) o add(i, o) o i i

6 BankAccount List public class Bank { private String nome; // Codice internazionale private String internationalcode; // Utilizzo una List per mantenere i conti private List<BankAccount> conti;... List<E> interface java.util ArrayList<E> List List public Bank(String nome, String internationalcode) { this.nome = nome; this.internationalcode = internationalcode; // Utilizzo l'implementazione ArrayList conti = new ArrayList<BankAccount>(); public BankAccount nuovoconto(string intestatario, double initialbalance) { // Costruisco l'id String idconto = internationalcode + id; id++; // Creo il nuovo conto e lo aggiungo alla lista // dei conti BankAccount tmp = new BankAccount(idConto, intestatario, initialbalance); conti.add(tmp); return tmp;

7 List<E> equals List public int search(string idconto) { // Conto fittizio per il confronto // tramite il metodo equals BankAccount confronto = new BankAccount(idConto, "", 0); // Ricerca tramite il metodo di List return conti.indexof(confronto); equalsbankaccount public boolean remove(string idconto) { // Cerca il conto int pos = search(idconto); if (pos == -1) return false; // Elimita l'elemento dalla lista dei conti conti.remove(pos); return true; for-each

8 public String elencoconti(){ StringBuffer r = new StringBuffer(); for(bankaccount b : conti) r.append(b.tostring() + "\n"); return r.tostring(); b 1)hasNext() true 2)next() iterator() List public BankAccount getcontobyname(string intestatario) { BankAccount tmp; boolean trovato = false; Iterator<BankAccount> i = conti.iterator(); while (i.hasnext()){ tmp = i.next(); if (tmp.getintestatario().equals(intestatario)) return tmp; return null; List next() remove() List next() remove() next()

9 java.util.collections sortshufflereverse List<E> shuffle sort List E E reverse Comparable<E> java.lang public int compareto(e obj) String String compareto obj other obj other equals obj other obj other

10 compareto equals equalstrue BankAccount idconto compareto String compareto BankAccount public class BankAccount implements... Comparable<BankAccount>{ public int compareto( BankAccount other) { // Utilizzo il metodo compareto fra // stringhe return idconto.compareto( other.idconto); public String elencocontiperid() { // Ordino la lista in base // all'ordinamento naturale Collections.sort(conti); // Restituisco la lista dei conti return elencoconti();

11 java.util Comparator<E> Comparable<E> public int compare(e o1, E o2) Comparator compare sort(list<e> l, Comparator<E> c) BankAccount Comparator public static final Comparator<BankAccount> ORDINA_PER_INTESTATARIO = new Comparator<BankAccount>() { ; public int compare(bankaccount b1, BankAccount b2) { return b1.intestatario.compareto( b2.intestatario);

12 Comparator compareto Comparator compareto Double public static final Comparator<BankAccount> ORDINA_PER_SALDO = ; new Comparator<BankAccount>() { public int compare(bankaccount b1, BankAccount b2) { Double bb1 = new Double(b1.saldo); Double bb2 = new Double(b2.saldo); return bb1.compareto(bb2); public String elencocontipersaldo() { // Ordino la lista in base al //saldo Collections.sort(conti, BankAccount.ORDINA_PER_SALDO); return elencoconti(); BankAccount equals BankAccount equals ORDINA_PER_INTESTATARIO

13 List Collection equals public static final Comparator<BankAccount> ORDINA_PER_INTESTATARIO = new Comparator<BankAccount>() { public int compare(bankaccount b1, BankAccount b2) { int cmp = b1.intestatario.compareto( cmp b2.intestatario); if (cmp!= 0) return cmp; // Se hanno lo stesso intestatario // vale l'ordinamento naturale fra // i due conti: return b1.compareto(b2); List<E> List<E> List<E> nulllist<e>

14 Set<E> SortedSet<E> List<E> Set<E> E Set public interface Set<E> extends Collection<E> { // Basic Operations int size(); boolean isempty(); boolean contains(object element); boolean add(e element); // Optional boolean remove(object element); // Optional Iterator iterator();...

15 containsindexof List<E> true false equals equals add removeboolean Set<E> add equalse Set<E> remove equals Set<E> List<E> java.util Set<E> HashSet<E> hashcode E equals TreeSet<E> SortedSet<E> Comparable<E> List<E> SortedSet<E> E equalse

16 public interface SortedSet<E> extends Set<E> { //Tutti i metodi di Set<E> più: SortedSet<E> subset(e fromelement, E toelement); SortedSet<E> headset(e toelement); SortedSet<E> tailset(e fromelement); E first(); // Minimo E last(); // Massimo SortedSet<E> TreeSet<E> SortedSet<E> E GestoreAule Set<Aula> public class GestoreAule { private Set<Aula> aule; public GestoreAule() { aule = new HashSet<Aula>(); public boolean add(aula a){ if (a == null) return false; return aule.add(a);... Set null

17 public class Prenotazione implements Comparable<Prenotazione> { // L'utente che effettua questa prenotazione private Utente utente; // Data e ora della prenotazione private DataEOra dataeora; private String descrizione;... Prenotazione Comparable<Prenotazione> SortedSet<Prenotazioni> Aula public class Aula { // Identificativo unico di un'aula private final String nome;... // Insieme delle prenotazioni per quest'aula, // in ordine cronologico private SortedSet<Prenotazione> prenotazioni;... Aula Aula

18 public boolean libera(dataeora d) { Prenotazione p; DataEOra tmp; // Scorre l'insieme ordinato di prenotazioni e // vede se la data e l'ora sono occupate Iterator<Prenotazione> i = prenotazioni.iterator(); // Cerco una prenotazione nella stessa data e // nella stessa ora // Continua... boolean trovato = false; boolean interrompi = false; while (i.hasnext() &&!trovato &&!interrompi){ p = i.next(); tmp = p.getdataeora(); if (tmp.equals(d)) trovato = true; else if (tmp.compareto(d) > 0) // Ho superato la data senza aver trovato interrompi = true; // Continua... if (trovato) return false; else return true;