Java Java Collections Framework Pag. 1/19

ArrayL'array è l'unica collezione supportata internamente dal linguaggio Java, deriva da Object e implementa le interfacce Serializable e Clonable. A volte gli array sono chiamati comunemente anche vettori ma è preferibile usare il termine array perchè array e vettori in Java non sono esattamente la stessa cosa (lo vedremo in seguito).

Un array, come molti già sapranno, è un insieme di oggetti tutti dello stesso tipo (cioè omogenei tra di loro) distinguibili l'uno dall'altro in base a un indice o posizione.

Ogni oggetto che fa parte dell'insieme è detto elemento dell'array mentre il numero degli elementi dell'array (detto dimensione) una volta fissato non può più essere cambiato. Di solito gli elementi di un array vengono memorizzati in locazioni contigue di memoria.

L'indice (intero che può essere una costante o un'espressione numerica) che serve per accedere ad ogni singolo elemento deve essere un valore valido, cioè compreso tra 0 e la dimensione dell'array – 1, altrimenti il linguaggio genera una eccezione di tipo ArrayIndexOutOfBoundsException.

Fig. 1 – La gerarchia delle eccezioni per un array

La dichiarazione di un array in Java si scrive in questo modo:

int[] a;

Se dichiariamo l'array senza allocarlo e poi cerchiamo di accedere ad uno dei suoi elementi (magari scrivendo per esempio, subito dopo la dichiarazione, l'istruzione System.out.println(a[4])), otteniamo l'eccezione NullPointerException, perchè, in effetti, una volta dichiarato l'array il valore contenuto in a è appunto null.

Fig. 2 – Un array appena dichiarato (il pallino nero rappresenta il valore speciale null)

Possiamo dichiarare e creare l'array con l'operatore new:

int[] a = new int[5];

In questo momento tutti gli elementi dell'array sono uguali a 0 (per un array di interi, uguali a spazi per un array di char, uguali a false per un array di boolean ecc).

ITIS Castelli, BS Maurizio Cozzetto Brescia, 18 nov 2009

Java Java Collections Framework Pag. 2/19

Fig. 3 – L'array a allocato

Possiamo semplificare la figura in questo modo:

Fig. 4 – Indichiamo solo il nome del reference e le locazioni cui punta

Fig. 5 – Altra rappresentazione dell'array usando la notazione UML

Possiamo caricare i valori dei singoli elementi dell'array usando un opportuno algoritmo:

for (int i = 0; i < a.lenght; i++) a[i] = 2*i + 2;

Il numero di elementi di un array (o dimensione) in Java si indica con length ed è una proprietà mentre non esiste un metodo o una proprietà in C++ (possiamo comunque calcolare dinamicamente la dimensione di un array usando la funzione sizeof() e l'espressione sizeof(a)/sizeof(int) nel caso di un vettore di interi). Il numero di caratteri di una stringa in Java e in C++ invece è restituito dal metodo lenght() (in C++ esiste comunque anche il metodo size() per il numero di caratteri di una stringa).

Abbiamo detto che la dimensione una volta fissata non si può cambiare: tuttavia la dimensione può anche essere una variabile come indica il seguente esempio:

int[] a; // Dichiarazione dell'array a

int n=5; // Dimensione dell'array

a=new int[n]; // Creazione

// Inizializzazionefor (int i=0; i<a.length; i++) a[i]=2*i+2;

Da questo momento in poi però non possiamo più cambiare la dimensione dell'array.

Fig. 6 – I valori contenuti nell'array dopo l'esecuzione del ciclo for

ITIS Castelli, BS Maurizio Cozzetto Brescia, 18 nov 2009

Java Java Collections Framework Pag. 3/19

Possiamo contestualmente dichiarare e inizializzare i valori dell'array in maniera rapida e diretta:

int[] a = {2,4,6,8,10};

Array di oggettiGli elementi di un array possono anche essere oggetti ad esempio stringhe. Ricordiamo che le stringhe di caratteri sono oggetti della classe String:

String s = new String("Questa è una stringa");

Tuttavia il modo più comune di creare una stringa consiste nell'assegnare una costante stringa a un oggetto di tipo String:

String s = "Questa è una stringa";

Per creare in maniera rapida un array di stringhe, possiamo quindi scrivere:

String[] winx = {“Bloom”,”Stella”,”Musa”,”Flora”,”Tecna”,”Aisha”};

Fig. 7 – Un array di stringhe

Se volessimo invece memorizzare maggiori informazioni negli oggetti, allora dobbiamo creare una classe di supporto (Fata, fonte wikipedia) e istanziare gli oggetti che faranno parte dell'array:

/* * Fata.java */

package winxclub;

import java.util.GregorianCalendar;

/** * * @author maurizio */

public class Fata { String nome; String creataDa; String editore; String apparizione; String voceOrigin; String luogoDiNascita;

ITIS Castelli, BS Maurizio Cozzetto Brescia, 18 nov 2009

Java Java Collections Framework Pag. 4/19

GregorianCalendar dataDiNascita; String occhi; String statoAttuale; String abilita; String alleati; String nemici; String parenti; String base;

public Fata(String nome, String luogoDiNascita, GregorianCalendar dataDiNascita, String occhi, String abilita) { this.luogoDiNascita = luogoDiNascita; this.dataDiNascita = dataDiNascita; this.nome = nome; this.occhi = occhi; this.abilita = abilita; }

private String dateToString(GregorianCalendar dataDiNascita) { int anno = dataDiNascita.get(Calendar.YEAR); // i mesi si contano da zero, quindi JANUARY=0, FEBRUARY=1 ecc int mese = dataDiNascita.get(Calendar.MONTH)+1; int giorno = dataDiNascita.get(Calendar.DAY_OF_MONTH); String dataStr = giorno+"/"+mese+"/"+anno; return dataStr; }

public String toString() { return "Nome "+nome+ ", luogo di nascita "+luogoDiNascita+", data di nascita "+dateToString(this.dataDiNascita)+", occhi "+occhi; }

} // fine classe Fata

Fig. 8 – Le Winx: da sinistra a destra: Flora, Aisha, Musa, Bloom, Tecna e Stella

Ora istanziamo 3 dei 6 oggetti corrispondenti ai nostri personaggi (ipotizziamo che il seguente codice sia contenuto nel metodo statico main di una classe di prova Main):

Fata bloom = new Fata("Bloom", "Domino", new GregorianCalendar(1988, 11, 10),"Celesti", "Fiamma del drago");

Fata stella = new Fata("Stella", "Solaria", new GregorianCalendar(1987, 7, 18),"Marroni","Potere del sole e della luna");

ITIS Castelli, BS Maurizio Cozzetto Brescia, 18 nov 2009

Java Java Collections Framework Pag. 5/19

Fata aisha = new Fata("Aisha", "Andros", new GregorianCalendar(1989, 4, 15), "Celesti-blu", "Fluido Morfix");

Creiamo ora l'array winxClub:

Fata[] winxClub = new Fata[6];

e assegniamo i valori ai singoli elementi dell'array:

winxClub[0] = bloom;

winxClub[1] = stella;

// Dobbiamo ancora istanziare le altre winx Musa, Flora e Tecna

winxClub[5] = aisha;

Avremo potuto scrivere il codice in maniera più compatta come abbiamo visto precedentemente:

Fata[] winxClub = {bloom, stella, null, null, null, aisha};

In questa situazione non tutti gli elementi sono assegnati: scorrendo quindi l'array in maniera sequenziale, dobbiamo escludere dal conteggio i reference uguali a null.

for (int i = 0; i<winxClub.length; i++) if (winxClub[i]!=null) System.out.println(winxClub[i].toString());

Fig. 9 – Un array di oggetti

ITIS Castelli, BS Maurizio Cozzetto Brescia, 18 nov 2009

Java Java Collections Framework Pag. 6/19

Collections FrameworkUna Collection è una struttura dati - un oggetto in sostanza - che contiene riferimenti ad altri oggetti, di solito dello stesso tipo. Nelle prime versioni di Java in realtà nelle Collection era possibile memorizzare oggetti di natura qualunque: per ricavare poi un particolare elemento della collezione era necessario effettuare un cast.

Tipicamente le Collection rappresentano dati che formano gruppi ”naturali”, come una mano di poker (Collection di carte), un elenco di brani su un cd (Collection di canzoni), una casella di posta elettronica (Collection di e-mail) o un elenco telefonico (Collection di coppie di tipo nome-numero di telefono).

Un Collections Framework è un'architettura unificata per rappresentare e manipolare le Collection. Tutti i Collections Framework contengono i seguenti elementi:

Interfacce: Nelle interfacce troviamo per definizione solo le operazioni ammissibili sulle collezioni (metodi astratti). Spetterà poi alle classi concrete implementare i metodi descritti nelle interfacce.

Implementazioni: Implementazioni concrete delle interfacce. In pratica, sono strutture dati riutilizzabili.

Algoritmi: Metodi che eseguono operazioni utili, come la ricerca e l’ordinamento, all’interno di oggetti che implementano le interfacce. Gli algoritmi sono polimorfi, cioè lo stesso metodo può essere usato in molte differenti implementazioni di una certa interfaccia. In pratica, gli algoritmi sono funzionalità riutilizzabili.

Le interfacceLe Core Collections Interfaces descrivono differenti tipi di collezioni, come riportato in figura 10.

L’interfaccia Collection è la radice dell'albero (in Java un'interfaccia ne può estendere un'altra) e comprende le interfacce List, Set e SortedSet, mentre Map è la radice dell'interfaccia SortedMap. Alcuni tipi di collezioni permettono la duplicazione di elementi, altri non la permettono. Alcuni sono ordinati e altri non lo sono.

Fig. 10 – Core Collection Interfaces

ITIS Castelli, BS Maurizio Cozzetto Brescia, 18 nov 2009

Java Java Collections Framework Pag. 7/19

Diamo una breve descrizione delle interfacce:

Set = Collezione che non può contenere elementi duplicati. L’interfaccia fornisce un’astrazione del modello matematico di insieme.

List = Collezione ordinata (detta anche sequenza), che può contenere elementi duplicati, ciascuno dei quali è identificato da un indice (la posizione).

Map = Oggetto che collega chiavi a valori. Una mappa non può contenere chiavi duplicate e ogni chiave può essere collegata al massimo con un valore. Modella il concetto matematico di funzione.

SortedSet = E’ un Set che mantiene gli elementi in ordine crescente. Diverse operazioni aggiuntive sono fornite per usufruire dei vantaggi dell’ordinamento.

SortedMap = E’ una Map che mantiene il collegamento chiave-valore in ordine crescente di chiave.

Le implementazioniLe implementazioni più comunemente utilizzate sono quelle riportate in tabella 1 ma noi studieremo solo Set, List e Map. Ogni implementazione fornisce tutte le operazioni contenute nella sua interfaccia.

Diamo una breve descrizione di alcune classi concrete:

HashSet = Gli elementi sono memorizzati in ordine sparso, senza alcuna garanzia sull’ordine in cui potranno essere letti.

ArrayList = Implementazione di List come array ridimensionabile (è possibile aggiungere ed eliminare elementi).

Vector = E' come ArrayList ma i suoi elementi sono Object (inoltre la classe è sincronizzata)

HashMap = Implementazione di Map ma gli elementi non sono ordinati

Interfaccia Implementazione Strutture dati “storiche”

Set HashSet

TreeSet

LinkedHashSet

List ArrayList Vector

LinkedList Stack

Map HashMap HashTable

TreeMap Properties

LinkedHashMap

Tab. 1 – Rapporto tra Interfacce e implementazioni

Interfaccia List e sua implementazione ArrayListRiscriviamo l'esempio precedente usando questa volta la classe ArrayList e il concetto di genericità (generics) introdotto per la prima volta in Java 5.

ITIS Castelli, BS Maurizio Cozzetto Brescia, 18 nov 2009

Java Java Collections Framework Pag. 8/19

Consideriamo sempre la classe di supporto Fata dell'esempio precedente e il seguente codice:

List<Fata> winxClub = new ArrayList<Fata>(); // dichiarazione e creazione di un ArrayList

In questo momento la situazione in memoria è la seguente:

Fig. 11 – Situazione dopo aver creato l'oggetto winxClub; in questo momento non ci sono elementi nella struttura dati

Non ci sono elementi e la struttura è vuota:

System.out.println("il winxclub è vuoto? "+winxClub.isEmpty());

Subito dopo istanziamo un oggetto e aggiungiamolo alla struttura:

Fata bloom = new Fata("Bloom", "Domino", new GregorianCalendar(1988, 11, 10),"Celesti", "Fiamma del drago");

winxClub.add(bloom); // aggiungiamo Bloom al winxClub

Questa la situazione in memoria:

Fig. 12 – L'ArrayList contiene per il momento un solo elemento

ITIS Castelli, BS Maurizio Cozzetto Brescia, 18 nov 2009

Java Java Collections Framework Pag. 9/19

Fig. 13 – L'interfaccia List e i suoi metodi astratti

Aggiungiamo ancora un elemento:

Fata stella = new Fata("Stella", "Solaria", new GregorianCalendar(1987, 7, 18),"Marroni","Potere del sole e della luna");

Fig. 14 – La struttura con due elementi in memoria

ITIS Castelli, BS Maurizio Cozzetto Brescia, 18 nov 2009

Java Java Collections Framework Pag. 10/19

Possiamo continuare ad aggiungere elementi in maniera dinamica alla struttura col metodo add() anche senza usare direttamente nomi di variabili istanza:

winxClub.add(new Fata("Aisha", "Andros", new GregorianCalendar(1989, 4, 15), "Celesti-blu", "Fluido Morfix"));

Nulla vieterebbe di aggiungere ancora una volta un elemento aggiunto precedentemente:

winxClub.add(stella); // abbiamo un elemento duplicato

E' possibile farsi dare il numero di elementi della struttura col metodo size() (size() tiene conto anche degli elementi duplicati):

System.out.println(winxClub.size());

Osserviamo che il metodo add() restituisce un valore booleano true se l'inserimento ha successo, false in caso contrario:

if(winxClub.add(bloom)==true) System.out.println(“Inserimento effettuato”);else System.out.println(“Impossible inserire l'elemento”);

Possiamo scorrere la struttura con un oggetto di tipo Iterator

for (Iterator i=winxClub.iterator(); i.hasNext(); ) System.out.println(i.next().toString());

oppure con un ciclo for generalizzato:

for (Fata f : winxClub) System.out.println(f.toString());

oppure con un ciclo for con indice:

for (int i=0; i<winxClub.size(); i++) System.out.println(winxClub.get(i).toString());

Possiamo eliminare un elemento (il primo che incontriamo se ce n'è più di uno) dalla struttura col metodo remove():

boolean b = winxClub.remove(stella);

if (b) System.out.println(“Eliminata stella dal winxClub”);else System.out.println(“Impossibile eliminare stella”);

Viene ovviamente decrementato il valore restituito da size().

Oppure possiamo passare al metodo remove() la posizione dell'elemento che intendiamo cancellare; la posizione deve essere un valore compreso tra 0 e size()-1, altrimenti il programma genera una eccezione di tipo IndexOutOfBoundsException. Questa volta il metodo restituisce un reference all'oggetto eliminato invece che un valore booleano:

Fata f = winxClub.remove(2);

if (f==null) System.out.println(“Impossibile eliminare l'elemento di posizione 2”);else System.out.println(“Elemento eliminato ”+f.toString());

ITIS Castelli, BS Maurizio Cozzetto Brescia, 18 nov 2009

Java Java Collections Framework Pag. 11/19

Creiamo ora una winx fittizia (elemento “dummy”) e aggiungiamola alla lista:

Fata g = new Fata("Fata dummy","Luogo di nascita dummy", new GregorianCalendar(1988,1,1),"Colore dummy","Abilità dummy");

winxClub.add(g);

Ora creiamo musa e sostituiamola all'elemento “dummy” col metodo set():

Fata musa = new Fata("Musa","Melody",new GregorianCalendar(1988,4,30),"Non noto","Potere della musica");

int d = winxClub.size();

winxClub.set(d-1,musa);

Gli elementi dell'arraylist sono individuabili in base alla posizione; per accedere a un singolo elemento possiamo usare il metodo get():

Fata h = winxClub.get(2);

if (h!=null) System.out.println(h.toString());else System.out.println(“Il reference è null”);

Ci sarebbero molti altri metodi da analizzare ma non abbiamo tempo per studiarli tutti.

Interfaccia Set e sua implementazione HashSetL'interfaccia Set contiene metodi ereditati da Collection ma aggiunge la limitazione che proibisce elementi duplicati. La piattaforma Java contiene 3 implementazioni generali di Set ma HashSet è l'implementazione con le prestazioni migliori ma non abbiamo idea di quale sia l’ordine degli elementi quando si itera su di essi.

Fig. 15 – Interfaccia Set

L'implementazione HashSet si basa sul concetto di funzione di Hash (se si desidera approfondire questo argomento, consigliamo l'ottimo articolo del prof. Alessandro Bugatti disponibile all'indirizzo http://www.imparando.net/elearning/claroline/backends/download.php?url=L0hhc2hfdGFibGUvSGFzaC5wZGY%3D&cidReset=true&cidReq=INF0003)

ITIS Castelli, BS Maurizio Cozzetto Brescia, 18 nov 2009

Java Java Collections Framework Pag. 12/19

Wikipedia (http://it.wikipedia.org/wiki/Hash) riporta la seguente definizione:

«Nel linguaggio matematico e informatico, la funzione hash è una funzione non iniettiva che mappa una stringa di lunghezza arbitraria in una stringa di lunghezza predefinita.»

Le funzioni di hashing hanno una notevole importanza nel campo della crittografia, nell'ambito dei database e nella trasmissione dei dati.

La funzione di hashing deve essere progettata in modo da ridurre al minimo le collisioni (si verifica una collisione quando due stringhe di input producono lo stesso valore di hash) e, anche qualora queste si verificassero, devono esistere delle politiche di gestione delle collisioni.

Il nostro esempio questa volta (capiremo più avanti perchè) riguarda i supereroi della casa editrice Marvel (i Vendicatori, con le varianti New Avengers, Mighty Avengers, fig. 17 e fig. 18 rispettivamente).

class SuperEroe { String nome; String editore; String alterEgo; String creatoDa; String primaApparizione; int altezza; // in cm int peso; // in kg String occhi; String capelli; String statoAttuale; String abilita; String alleati; String nemici; String parenti;

public SuperEroe(String nome, String alterEgo, String abilita) { this.nome = nome; this.alterEgo = alterEgo; this.abilita = abilita;

}

public String toString() { return "nome: "+nome+", alter ego: "+alterEgo+", abilità: "+abilita; }}

Creaimo ora l'HashSet nel seguente modo:

Set<SuperEroe> newAvengers = new HashSet<SuperEroe>();

Non vi sono elementi nell'HashSet in questo momento: provvediamo quindi ad aggiungerne tre:

SuperEroe spiderman = new SuperEroe("Spider-Man","Peter Parker","Tutte le capacità di un ragno moltiplicate alla taglia umana (forza, velocità, agilità), senso di ragno che lo avverte dei pericoli");

newAvengers.add(spiderman);

SuperEroe wolverine = new SuperEroe("Wolverine","James Howlett (Logan)","fattore rigenerante, artigli protrattili, sensi sviluppatissimi, forza e agilità notevoli, esperto di arti marziali");

newAvengers.add(wolverine);

SuperEroe ironMan = new SuperEroe("Iron Man","Antony Edward (Tony) Stark","Genio scientifico, capacità dell'armatura: superforza, semi-invulnerabilità,

ITIS Castelli, BS Maurizio Cozzetto Brescia, 18 nov 2009

Java Java Collections Framework Pag. 13/19

volo, raggi repulsori, armi da fuoco e missili di varia natura");

newAvengers.add(ironMan);

Il codice precedente non è dissimile da quello usato con le liste (il metodo add() infatti è polimorfico) e la rappresentazione in memoria, come si può vedere nella fig. 16, non è neanche molto diversa, tuttavia con i set non esiste il concetto di posizione dell'elemento.

Questo significa inoltre che l'esecuzione di un ciclo di lettura degli elementi come il seguente, se lanciato più volte, può produrre risultati differenti:

// Visualizziamo tutti gli elementi

for (SuperEroe se : newAvengers) System.out.println(se.toString());

Fig. 16 – 3 dei nuovi vendicatori

ITIS Castelli, BS Maurizio Cozzetto Brescia, 18 nov 2009

Java Java Collections Framework Pag. 14/19

Fig. 17 – Copertina del primo numero “The New Avengers (I nuovi vendicatori)“

Bulk operations

Le bulk operations (letteralmente “operazioni in blocco”) sono particolarmente utili se applicate all’interfaccia Set, perché permettono di applicare su insiemi le operazioni algebriche di unione (addAll()), differenza (removeAll()) e intersezione (retainAll()), oltre a permettere di verificare se un dato insieme è sottoinsieme di un altro (containsAll()). Se s1 e s2 sono set, allora:

s1.addAll(s2) Trasforma s1 nell'unione degli elementi di s1 ed s1 (coincide con l'unione insiemistica, cioè trova l'insieme degli elementi di s1 ed s2).

s1.removeAll(s2) Trasforma s1 nella differenza insiemistica (asimmetrica) di s1 ed s2 (cioè calcola l'insieme degli elementi di s1 che non appartengono ad s2).

s1.retainAll(s2) Trasforma s1 nell'intersezione di s1 ed s2 (cioè il set contiene tutti gli elementi di s1 ed s2 che sono comuni).

I metodi addAll(), removeAll() e retainAll() restituiscono true se s1 è stata modificata in seguito all’esecuzione dell’operazione.

s1.containsAll(s2) Restituisce true se s2 è sottoinsieme di s1.

Per calcolare l'unione, l'intersezione o la differenza insiemistica di due set in modo non distruttivo (senza modificare i set), l'oggetto chiamante deve copiare il set prima di chiamare l'operazione bulk.

Per provare alcuni dei metodi sopra elencati, consideriamo il nuovo set relativo ai Potenti Vendicatori (The Mighty Avengers):

Set<SuperEroe> mightyAvengers = new HashSet<SuperEroe>();

ITIS Castelli, BS Maurizio Cozzetto Brescia, 18 nov 2009

Java Java Collections Framework Pag. 15/19

SuperEroe quickSilver = new SuperEroe("Quicksilver","Pietro Django Maximoff","Supervelocità");

SuperEroe stature = new SuperEroe("Stature","Cassandra Eleanor (Cassie) Lang","Può diventare alta fino a 30 metri o piccola come una formica, può emettere scariche di energia");

Aggiungiamo i 3 Potenti Vendicatori:

mightyAvengers.add(quickSilver);mightyAvengers.add(stature);mightyAvengers.add(ironMan);

Vogliamo l'intersezione tra newAvengers e mightyAvengers

// Copia del set newAvengersSet<SuperEroe> intersezione = new HashSet<SuperEroe>(newAvengers);

intersezione.retainAll(mightyAvengers);

System.out.println("Intersezione tra NewAvengers e MightyAvengers");

for (SuperEroe se : intersezione) System.out.println(se.toString());

Il risultato, come è prevedibile, è ironMan. Lasciamo al lettore il compito di creare eventualmente altri gruppi e di provare le altre operazioni insiemistiche, magari facendo delle prove con i Dark Avengers (fig. 19), guardando su www.wikipedia.it o www.wikipedia.en.

Interfaccia Map e sua implementazione HashMapJava contiene 3 implementazioni generali di Map mentre l'implementazione migliore è HashMap che però non fornisce una garanzia sull'ordine degli elementi, come si può intuire rileggendo la sezione relativa all'interfaccia Set. Per fare un esempio di HashMap, consideriamo come chiave di accesso agli elementi della mappa il nome del supereroe. Mappiamo cioè i nomi (stringhe) con gli oggetti (di tipo SuperEroe).

Istanziamo una mappa:

Map<String, SuperEroe> newAvengers = new HashMap<String, SuperEroe>();

ITIS Castelli, BS Maurizio Cozzetto Brescia, 18 nov 2009

Java Java Collections Framework Pag. 16/19

Fig. 18 – Copertina del n. 1 di “The Mighty Avengers (I Potenti Vendicatori)”

Fig. 19 – Copertina del n. 1 di “Dark Avengers”

ITIS Castelli, BS Maurizio Cozzetto Brescia, 18 nov 2009

Java Java Collections Framework Pag. 17/19

Per aggiungere elementi alla mappa, scriviamo per esempio:

SuperEroe spiderman = new SuperEroe("Spider-Man","Peter Parker","Tutte le capacità di un ragno moltiplicate alla taglia umana (forza, velocità, agilità), senso di ragno che lo avverte dei pericoli");

// Aggiungiamo spiderman alla mappanewAvengers.put(spiderman.nome,spiderman);

Questa volta usiamo il metodo put() che richiede due argomenti (una chiave e un valore). Possiamo aggiornare il valore degli attributi dell'oggetto mappato dalla chiave usando ancora il metodo put():

// Aggiorniamo le abilità di Spider-Manspiderman.abilita = "Forza, velocità, agilità, senso di ragno";

newAvengers.put(spiderman.nome,spiderman);

// Controlliamo se la variazione è stata effettuataSystem.out.println(spiderman.toString());

Aggiungiamo un nuovo vendicatore:

SuperEroe wolverine = new SuperEroe("Wolverine","James Howlett (Logan)","Fattore rigenerante, artigli protrattili, sensi sviluppatissimi, forza e agilità notevoli, esperto di arti marziali");

newAvengers.put(wolverine.nome, wolverine);

Fig. 20 – Rappresentazione di una mappa (nella figura sono state rappresentate le chiavi)

Il metodo values() restituisce la Collection dei valori:

Collection<SuperEroe> elencoNewAvengers = newAvengers.values();

ITIS Castelli, BS Maurizio Cozzetto Brescia, 18 nov 2009

Java Java Collections Framework Pag. 18/19

Visualizziamo gli oggetti:

for (SuperEroe se : elencoNewAvengers) System.out.println(se.toString());

Fig. 21 – L'interfaccia Map

Possiamo anche visualizzare le chiavi (l'insieme delle chiavi è proprio un Set):

Set<String> elencoNomi = newAvengers.keySet();

// Elenco delle chiavifor (String nome : elencoNomi) System.out.println(nome);

Per rimuovere un elemento della mappa, usiamo il metodo remove() che ha come argomento la chiave:

if (newAvengers.remove(wolverine.nome)!=null) System.out.println("Eliminato "+wolverine.nome);else System.out.println("Impossibile eliminare "+wolverine.nome);

Per cercare un super eroe nella mappa, usiamo il metodo get() che vuole come argomento la chiave (stringa):

SuperEroe x = newAvengers.get("Spider-Man");

// Se l'elemento non c'è nella mappa, get restituisce null

if (x==null) System.out.println("Il super eroe non c'è nella mappa");else System.out.println(x.toString());

Come al solito, il metodo size() restituisce il numero degli elementi della mappa:

System.out.println(newAvengers.size());

E' possibile inoltre sapere se una certa chiave è contenuta nella mappa:

// Il metodo containsKey() restituisce true o falseSystem.out.println(newAvengers.containsKey("Iron Man"));

oppure se un certo oggetto è contenuto nella mappa:

System.out.println(newAvengers.containsValue(x));

ITIS Castelli, BS Maurizio Cozzetto Brescia, 18 nov 2009

Java Java Collections Framework Pag. 19/19

Fig. 22 – Spider-Man rivela al mondo la sua identità segreta (Civil War n. 1, miniserie Marvel)

Fonti di riferimentoJava Tutorial, Corso rapido quarta edizione, AV, McGraw-Hill

Java Collection Framework, John Zuckowski, http://www.ibm.com/developerworks/edu/j-dw-javacoll-i.html

Wikipedia (en e it), http://www.wikipedia.org

Java Riassunto, Francesco Galgani, http:// www.guella.it/universita/javariassunto.pdf

Informatica Programmazione in Java, F. Scorzoni, Loescher

ITIS Castelli, BS Maurizio Cozzetto Brescia, 18 nov 2009