Corso Java 2 - AVANZATO

Corso 2 Java

Programmazione Avanzata Giuseppe Dell’Abate

Modulo 1

JDBC e Database

Lezione 1

Le API di JDBC e JDBC2 • La libreria JDBC (Java Database Connectivity) contiene

un insieme di classi Java a disposizione dello sviluppatore che consente di utilizzare una serie di strumenti per l’interazione con un qualsiasi database server

• Un driver JDBC è un modulo software, dedicato ad uno specifico database, in grado di tradurre tutte le funzionalità fornite dall’interfaccia JDBC in comandi del linguaggio di interrogazione adottato dal DataBase (nella maggior parte dei casi si tratta di SQL).

Lezione 1

Le API di JDBC e JDBC2 • Mostriamo di seguito i passi necessari per interrogare un

database e processare il risultato dell’interrogazione.

1. Caricare il driver JDBC per il database interessato

2. Apertura della connessione

3. Preparare l’esecuzione della query

4. Invio dell’interrogazione al database

5. Ciclo sull’oggetto ResultSet per leggere i dati della query

6. Chiusura della connessione

Lezione 2

Il concetto di driver e connessione • Il ClassLoader Java si occupa di caricare in memoria le

librerie necessarie per la connessione

• Per ogni database vengono create delle classi java che implementano la specifica JDBC e consentono di poter eseguire tutte le operazioni necessarie per manipolare i dati.

Lezione 2

Il concetto di driver e connessione • Per dialogare con il Database occorre predisporre una

connessione che fornisca il canale di comunicazione tra noi ed il database

• Per creare la connessione occorre impostare: URL, USER e PASSWORD

▫ URL: è utilizzato per indicare i parametri di connessione al DataBase

▫ USER: utente con cui vogliamo connetterci, esistente nel DB

▫ PASSWORD: password dell’utente

• Esempio:

▫ Connection con = DriverManager.getConnection (“jdbc:oracle:thin:@localhost:1521:orcl", "scott", "tiger");

Lezione 3

Tipi di driver • In base al tipo di database utilizzato, dovremo scegliere il

suo Driver,ossia l’implementazione JDBC di quel database

• I Drivers si distinguono in base ai databases: ▫ per il Database Postgre: org.postgresql.Driver

▫ per il Database Oracle: oracle.jdbc.driver.OracleDriver

▫ per il Database Mysql: com.mysql.jdbc.Driver

▫ per il Database MicroSoft SQL Server : com.microsoft.jdbc.sqlserver.SQLServerDriver

• Esempio:

▫ Class.forName(“oracle.jdbc.driver.OracleDriver”);

Lezione 4

Creare una istruzione SQL semplice String url = "jdbc:postgresql://SERVER-POSTGRESQL/esercitazioni";

String user = ""; String passwd = "";

Class.forName("org.postgresql.Driver");

Connection con = DriverManager.getConnection(url,user,passwd);

String sql = " SELECT * FROM STUDENTE ";

Statement stmt = con.Statement();

ResultSet rs=stmt.executeQuery(sql);

while (rs.next()) {

System.out.println(“Cognome: "+rs.getString("Cognome"));

System.out.println(“Nome: "+rs.getString("Nome"));

}

stmt.close();

con.close();

Lezione 5

Creare una istruzione SQL preparata • Una istruzione preparata, a differenza del caso

precedente, utilizza l’interfaccia PrepareStatement invece di Statement.

• E’ consigliabile utilizzare PrepareStatement nel caso in cui si pensa di utilizzare frequentemente una query a fronte di argomenti diversi.

• L’uso del PrepareStatement consente di velocizzare i tempi di esecuzione, la fase di pre-elaborazione della query viene effettuata solo la prima volta.

Lezione 5

Creare una istruzione SQL preparata String url = "jdbc:postgresql://SERVER-POSTGRESQL/esercitazioni";




String sql = " SELECT * FROM STUDENTE where nome = ?";

PreparedStatement stmt = conn.prepareStatement(sql);

stmt.setString(1, "Mario");


while (rs.next()) {



}

stmt.close();

con.close();

Lezione 6

Lanciare una store procedure • Nel database vengono salvate delle procedure che consentono di

eseguire una serie di elaborazioni. • Tali procedure possono essere invocate tramite JDBC. • Esempio: creiamo una tabella dal nome user ed una procedura che

inserisca un utente nella tabella -- Tabella user CREATE TABLE user ( id INTEGER, nome VARCHAR(45) ) -- Procedura inserimento utente CREATE PROCEDURE 'insertUser'(nomeUtente VARCHAR(45)) BEGIN INSERT INTO user(name) VALUES(nomeUtente); END

Lezione 6

Lanciare una store procedure String url = "jdbc:postgresql://SERVER-POSTGRESQL/esercitazioni";




CallableStatement storedProcedure = connection.prepareCall("{ call insertUser(?) }");

storedProcedure.setString(1, name);

storedProcedure.execute();

storedProcedure.close();

con.close();

Lezione 7

Recuperare il risultato di una SELECT • Il risultato di una query viene mantenuta in un oggetto

ResultSet che consente di mantenere un puntatore sulle tabelle del database.

• Tramite questo oggetto è possibile scorrere il risultato della nostra query ed estrarre il risultato.


while (rs.next()) {



}

Lezione 8

Accesso ai metadati • Tramite le API JDBC è possibile recuperare delle

informazioni inerenti il database, le tabelle, le connessioni.

• Tali informazioni vengono dette meta-dati in quanto servono per indicare la natura del dato.

• Per esempio Cognome è un metadato mentre Esposito è un dato; il primo serve per descrivere la natura del dato mentre il secondo è il dato

• I nomi delle tabelle, delle colonne, del database, la versione, le sue proprietà sono tutti meta-dati che servono per conoscere meglio il database.

Lezione 8

Accesso ai metadati • Accesso ad alcune informazioni del database: nome,

versione, driver per la connessione. • Molte altre informazioni sono disponibili del risultato

della query usando “ResultSetMetaData”

String url = "jdbc:postgresql://SERVER-POSTGRESQL/esercitazioni";




DatabaseMetaData dbmd = conn.getMetaData();

System.out.println( dbmd.getDatabaseProductName() );

System.out.println( dbmd.getDatabaseProductVersion());

System.out.println( dbmd.getDriverName() );

con.close();

Modulo 2

Stream

Lezione 1

Il concetto di stream di dati • Stream significa “flusso” e si riferisce ad un flusso di

bytes che rappresentano dei dati che vengono trasferiti da una sorgente ad una destinazione.

• I dati vengono scomposti nella loro composizione originaria cioè in bytes per poi essere trasferiti tramite cavo, wireless su una diversa destinazione per poi essere successivamente ricomposti in dati.

Lezione 2

Il pacchetto java.io • Il package java.io è composto da due parti principali:

▫ stream di byte: utilizzati per gestire un flusso di byte (8 bit)

▫ stream di caratteri: impiegati per maneggiare un flusi di caratteri UNICODE(16 bit)

• Per ogni stream esistono i corrispondenti stream di input e di output

▫ stream di byte: InputStream ed OutputStream

▫ stream di caratteri: Reader e Writer

• Quando si parla semplicemente di stream si intende uno stream di qualunque tipo (di byte o di caratteri , di input o di output)

Lezione 3

I tipi di stream

Lezione 3

I tipi di stream • Esempio di una classe che legge i byte di un file passato

come parametro import java.io.*;

class ProvaInputStream {

public static void main(String[] args) throws IOException {

InputStream is = new FileInputStream(args[0]);

int b;

while ( (b = is.read()) != -1 )

System.out.println("Letto : " + (char)b);

}

}

Lezione 3

I tipi di stream

Lezione 3

I tipi di stream • Esempio di una classe che scrive dei dati in un file

import java.io.*; class ProvaOutputStream { public static void main(String[] args) throws

IOException { OutputStream os = new FileOutputStream(args[0]); int b; while ( (b = System.in.read()) != -1 ) os.write(b); } }

Lezione 3

I tipi di stream

Lezione 3

I tipi di stream • Esempio di una classe che legge dei dati da un file

import java.io.*; class ProvaReader { public static void main(String[] args) throws

IOException { Reader r = new FileReader(args[0]); int c; while ( (c = r.read()) != -1 ) System.out.println(“Leggo:” + (char)c); } }

Lezione 3

I tipi di stream

Lezione 3

I tipi di stream • Esempio di una classe che scrive dei dati in un file

import java.io.*; class ProvaWriter { public static void main(String[] args) throws IOException { Reader r = new InputStreamReader(System.in); Writer os = new FileWriter(args[0]); int b; while ( (b = r.read()) != -1 ) { os.write(b); os.flush(); } } }

Lezione 6

Serializzazione di oggetti • E’ una tecnica che consente di poter salvare un oggetto, o

meglio renderlo persistente, e poi ripristinato

• Occorre implementare l’interfaccia java.io.Serializable ed occorre che tutti le proprietà siano serializzabili

• Per verificare si può usare il serialver -show. Apparirà una finestra nella quale metterete il nome completo della classe che volete esaminare. Se la classe è serializzabile apparirà un valore identificativo della classe stessa, altrimenti non apparirà nulla.

Lezione 6

Serializzazione di oggetti • Salvare un oggetto

public void scrivi () {

try{

fos = new FileOutputStream ("restore.ser");

oos = new ObjectOutputStream(fos);

oos.writeObject(salvato);

oos.close();

}

catch (IOException ioe){

System.out.println("Errore:"+ioe.toString());

}

}

Lezione 6

Serializzazione di oggetti • Caricare un oggetto:

public void leggi() { try{ fis = new FileInputStream ("restore.ser"); ois = new ObjectInputStream(fis); salvato = (TipoSalvato)(ois.readObject()); ois.close(); } catch (IOException ioe){ System.out.println("Errore:"+ioe.toString()); } }

• Operazione di cast da fare all’atto del readObject. Infatti essa ritorna un Object per cui tale operazione si rende necessaria

Modulo 3

Networking

Lezione 1

Il concetto di client/server • La comunicazione tra 2 host avviene in modalità client/server

in cui il client è colui che effettua la chiamata mentre il server è colui che la accetta e risponde.

• Al fine di creare un canale di comunicazione tra i 2 host si utilizza il Socket

• Socket significa presa e serve per tenere uniti i 2 host che intendono scambiarsi i dati sotto forma di bytes

• Pertanto nel Socket passa un flusso di byte che viene trasmesso tra host diversi collegati in rete

• Esistono due tipi di socket:

▫ TCP (Transport Control Protocol)

▫ UDP (User Datagram Protocol)

Lezione 2

Connessione Socket/ServerSocket • I socket in Java sono implementati con quattro classi

distinte:

1. Socket: socket TCP lato client

2. ServerSocket: socket TCP lato server

3. DatagramSocket: socket UDP semplici e broadcast

4. MulticastSocket: socket UDP multicast

Lezione 3

Le classi per il networking • Al fine di realizzare una connessione TCP dobbiamo

utilizzare le classi Socket e ServerSocket.

• Inoltre i dati serializzati in uno stream possono essere manipolati utilizzando le classi InputStream e OutputStream recuperate da Socket e ServerSocket tramite i metodi:

▫ InputStream getInputStream()

▫ OutputStream getOutputStream()

Lezione 4

Realizzazione di un client import java.io.OutputStream; import java.net.Socket; public class Client { public static void main(String[] args) throws Exception { new Client().start(); } public void start() throws Exception { Socket socket = new Socket("localhost", 7777); OutputStream os = socket.getOutputStream(); byte [] ciao = "ciao".getBytes(); os.write( ciao ); os.flush(); os.close(); socket.close(); } }

Lezione 5

Realizzazione di un server import java.io.DataOutputStream; import java.io.InputStream; import java.net.ServerSocket; import java.net.Socket; public class Server { public static void main(String[] args) throws Exception { new Server().start(); } public void start() throws Exception { ServerSocket serverSocket = new ServerSocket(7777); while (true) { Socket socket = serverSocket.accept(); InputStream is = socket.getInputStream(); byte [] messaggio = new byte[is.available()]; is.read( messaggio ); is.close(); socket.close(); System.out.println("Messaggio ricevuto: " + new String( messaggio ) ); break; } } }

Modulo 4

Programmazione Multithread

Lezione 1

Il concetto di processo e thread • Il Sistema Operativo può eseguire molti programmi

(MSWord, IExplorer, AdobeReader ecc)

• Ogni programma è composto da uno o più processi.

• Ogni processo è costituito da uno o più Thread

• Il Thread è una sezione di codice che viene eseguito indipendentemente da altri Thread all’interno dello stesso processo.

Lezione 1

Il concetto di processo e thread • Il processo è una entità dinamica il cui stato varia nel

tempo ed a cui il Sistema Operativo assegna un’area di memoria composta da codice e dati (variabili globali e locali)

• Il Thread è una porzione di un processo che viene eseguito in modo indipendente. Il processo condivide le proprie variabili globali con i Thread ottimizzando, in questo modo, le risorse disponibili ed evitando la duplicazione dei dati.

• Il passaggio da un Thread ad un altro all’interno dello stesso processo, presenta delle tempistiche di “context switch”, cioè di cambio di contesto, molto veloci.

Lezione 2 La classe Thread e l'interfaccia Runnable

• Per creare un Thread in Java è possibile utilizzare due scelte opzionali:

1. Estendere la classe Thread

2. Implementare l’interfaccia Runnable

• L’opzione è nata per permettere a classi già figlie di altre classi, di poter diventare dei Thread implementando Runnable (esempio nel seguito).

Lezione 2 La classe Thread e l'interfaccia Runnable 1. Esempio di estensione:

public class ProvaThread extends Thread { @Override public void run(){ System.out.println("Hello Thread"); } } 2. Esempio di implementazione: public class ProvaRunnable implements Runnable { @Override public void run(){ System.out.println("Hello Runnable"); } }

Lezione 2 La classe Thread e l'interfaccia Runnable • Classe di invocazione:

public class Start {

public static void main(String[] args) {

Thread t1 = new Thread( new ProvaThread());

t1.start();

Thread t2 = new Thread( new ProvaRunnable() );

t2.start();

}

} • Il comportamento nelle 2 diverse invocazioni è lo stesso.

Hello Thread

Hello Runnable

Lezione 2 La classe Thread e l'interfaccia Runnable • Nel caso in cui una classe ha già un padre ma vogliamo che

diventi un thread, allora siamo tenuti ad usare l’interfaccia Runnable, perché in Java non esiste l’ereditarietà multipla.

public class Padre {} public class Figlio extends Padre {}

• La classe Figlio diventerà: public class Figlio extends Padre implements Runnable { @Override public void run(){ System.out.println("Hello Runnable"); } }

Lezione 3

Le API per i thread • La nostra classe deve essere una sottoclasse della classe

astratta java.lang.Thread oppure deve implementare l’interfaccia Runnable, presente nella libreria del JDK

• richiamiamo i costruttori;

▫ public Thread();

▫ public Thread(String nome);

• l’esecuzione è avviata con il metodo start()

• il metodo run() contiene le operazioni da effettuare

Lezione 4

Impostare le priorità • Ad ogni processo è assegnata una priorità ovvero un

valore intero positivo che varia tra due valori della classe Thread: MIN_PRIORITY e MAX_PRIORITY.

• Quando un thread viene creato la sua priorità è pari a NORM_PRIORITY

• se in un determinato istante esiste un thread nello stato Runnable che ha priorità maggiore di quello corrente, esso viene promosso (pre-empted) sostituendo il precedente che, pur rimanendo nello stato di Runnable, non avanzerà nella esecuzione

Lezione 4

Impostare le priorità public class Priorita extends Thread {

public Priorita(String nome_thread){

super(nome_thread);

}

@Override

public void run(){

for (int i=0; i<4;i++)

System.out.println(getName());

}

}

Lezione 4

Impostare le priorità public class StartPriorita {


Priorita thread3 = new Priorita("Thread con BASSA PRIORITA'");

thread3.setPriority(Thread.MIN_PRIORITY);

thread3.start();

Priorita thread1 = new Priorita("Thread con MEDIA PRIORITA'");

thread1.start();

Priorita thread2 = new Priorita("Thread con ALTA PRIORITA'");

thread2.setPriority(Thread.MAX_PRIORITY);

thread2.start();

}

}

Lezione 4

Impostare le priorità • La JVM quando si accorge che esistono altri Thread con priorità più

elevata, sostituisce il Thread in esecuzione di ridotta priorità. L’esecuzione sarà diversa da sistema operativo e dal suo carico.

Thread con BASSA PRIORITA'

Thread con MEDIA PRIORITA'

Thread con ALTA PRIORITA'











Thread con BASSA PRIORITA’

Thread con BASSA PRIORITA ’

Lezione 5

Lo stato dei thread • I Thread subiscono un passaggio di stato durante la loro

vita, dal momento in cui vengono creati fino a quando si conclude la loro esecuzione.

Lezione 5

Lo stato dei thread 1. New: il Tread viene creato ma ancora non è stato

chiamato il metoto start(). In questo stato il thread non è ancora “vivo”

2. Runnable: è stato invocato il metodo start(), adesso il thread è “vivo” ma ancora non è stato schedulato per l’esecuzione. Il Thread è stato inserito nella coda di esecuzione ed aspetta il suo turno anche in base alla priorità rispetto agli altri thread

3. Running: il Thread è “vivo ed in esecuzione”. Esegue il codice di cui è stato programmato fino ad interruzione interna o esterna.

Lezione 5

Lo stato dei thread 4. Waiting/blocked/sleeping: Il thread si trova nella

condizione di: 1. Wainting: il codice del Thread impone una attesa che sarà

interrotta quando si verificherà un evento richiesto

2. Blocked: è una attesa forzata a fronte di una risorsa di rete, di file system oppure a causa di un oggetto “loccato”

3. Sleeping: il codice del Thread impone una attesa che sarà interrotta quando terminerà il tempo di attesa

5. Dead: Il thread ha completato l’esecuzione del metodo run() e la sua vita è volta al termine. Vengono liberate le risorse in termini di oggetti allocati nell’HEAP della JVM.

Lezione 6

Condivisione di dati tra thread • I thread possono tra loro condividere dei dati ed essere

informati nel momento in cui una data risorsa è disponibile.

• Per ottenere questo obiettivo si usano i metodi wait() e notify() della classe Object, pertanto disponibili su tutti gli oggetti java.

• L’esempio seguente simula la condivisione di un oggetto ( Ball ) che viene scambiato tra due Thread (Ping e Pong) creando una classica partita.

• Ping lancia la palla ed aspetta che Pong la riceva. Quando Pong notifica a Ping che l’ha ricevuta, allora Ping rilancia la pallina e si rimette in attesa.

Lezione 6

Condivisione di dati tra thread public class Ping extends Thread { private Ball ball = null; public Ping(Ball ball) { this.ball = ball; } @Override public void run() { while (true) { System.out.println("ping"); synchronized (ball) { try { ball.wait(); } catch (InterruptedException ex) {} } } } }

Lezione 6

Condivisione di dati tra thread public class Pong extends Thread {

private Ball ball = null;

public Pong(Ball ball) {

this.ball = ball;

}

@Override

public synchronized void run() {

while (true) {

System.out.println("pong");

synchronized (ball) {

ball.notify();

}

try {

Thread.sleep(1000);

} catch (InterruptedException ex) {

}

}

}

}

Lezione 6

Condivisione di dati tra thread public class StartPingPong {

public static void main(String[] args) throws InterruptedException {

Ball ball = new Ball();

Ping ping = new Ping( ball );

ping.start();

Pong pong = new Pong( ball );

pong.start();

}

}

Esecuzione della classe StartPingPong provoca un palleggio infinito: ping

pong

ping

pong

ping

pong

…..

Lezione 7

La sincronizzazione • L’accesso parallelo ad una risorsa ad opera di 2 o più

soggetti, in certi casi, può causare dei problemi, pertanto è necessario poter gestire queste situazioni.

• La sincronizzazione consente di disciplinare l’accesso ad un oggetto tramite la parola chiave synchronized che determina il lock dell’oggetto stesso e l’impossibilità ad opera di altri di potervi accedere.

• La sincronizzazione si usa solo sui metodi di una classe, sia statici che di istanza.

Lezione 7

La sincronizzazione • Vediamo un esempio in cui 2 Thread accedono alla

stampante. Il primo che acquisisce il controllo della stampante potrà stampare per primo, il secondo dovrà aspettare il completamento dell’operazione e solo dopo stamperà.

• La sincronizzazione si applica ai metodi di istanze ed ai metodi static. Il metodo static in quanto unico, sincronizza l’accesso per tutti i Thread che intendono accedervi, a differenza dei metodi di istanza che invece sincronizzano l’accesso solo ai Thread che si riferiscono alla stessa istanza.

Lezione 7

La sincronizzazione • La classe Stampante ha il metodo stampa() di tipo synchronized pertanto l’accesso è

sincronizzato per lo stesso Thread, cioè un oggetto di tipo Thread non può accedere in modo concorrente al metodo stampa().

public class Stampante {

public synchronized void stampa(String text) {

System.out.println( text );

try {

Thread.sleep(2000);

} catch (InterruptedException ex) {}

}

}

Lezione 7

La sincronizzazione • La classe TestSinc crea 2 Thread usando la stessa istanza di TestSinc, pertanto l’accesso

alla risorsa sincronizzata viene rispettata

public class TestSinc extends Thread {

Stampante stampante = new Stampante();


TestSinc test1 = new TestSinc();

Thread t = new Thread(test1);

t.start();

Thread t2 = new Thread(test1);

t2.start();

}

@Override

public void run(){

stampante.stampa("prova");

}

}

Lezione 7

La sincronizzazione • Mentre invece la classe TestSinc crea 2 Thread usando diverse istanze di TestSinc,

pertanto l’accesso alla risorsa sincronizzata NON viene rispettata.

public class TestSinc extends Thread {

Stampante stampante = new Stampante();


Thread t = new Thread(new TestSinc());

t.start();

Thread t2 = new Thread(new TestSinc());

t2.start();

}

@Override

public void run(){

stampante.stampa("prova");

}

}

Lezione 7

La sincronizzazione • Se rendiamo static il metodo stampa() di tipo synchronized l’accesso è sincronizzato

per tutti i Thread, cioè tutti gli oggetti di tipo Thread non possono accedere in modo concorrente al metodo stampa().

public class Stampante {

public static synchronized void stampa(String text) {

System.out.println( text );

try {

Thread.sleep(2000);

} catch (InterruptedException ex) {}

}

}

Lezione 9

Gestione dei lock sui thread • Per acquisire il lock su un oggetto è necessario definire

un metodo synchronized ed accedere ad esso.

• Il lock sull’oggetto viene rilasciato quando il metodo synchronized è completamente eseguito.

• Il metodo synchronized può acquisire il lock su altri oggetti o sull’oggetto stesso, invocando altri metodi synchronized.

• Se il metodo synchronized passa allo stato blocked/sleeping/waiting, non rilascia il lock sugli oggetto acquisiti in precedenza.

Modulo 5

Collections

Lezione 1

Le API per le strutture dati • Il Java Collections Framework è una libreria formata da un

insieme di interfacce e di classi che le implementano per lavorare con gruppi di oggetti.

• Le interfacce e le classi del Collections Framework si trovano nel package java.util

• Il Collections Framework comprende:

▫ Interfacce: rappresentano vari tipi di collezioni di uso comune.

▫ Implementazioni: sono classi concrete che implementano le inter-facce di cui sopra, utilizzando strutture dati efficienti.

▫ Algoritmi: funzioni che realizzano algoritmi di uso comune, quali algoritmi di ricerca e di ordinamento su oggetti che implementano le interfacce del Collections Framework.

Lezione 1

Le API per le strutture dati

Lezione 2

L'interfaccia Collection • Collection è la radice della gerarchia delle collection.

• Rappresenta gruppi di oggetti che possono essere duplicati o univoci, ordinati o meno.

• Le implementazioni concrete sono List e Set

Lezione 3

Le strutture monodimensionali - List • Le List sono una sequenza ordinata di elementi che ammettono duplicati • Implementate con ArrayList, Vector e LinkedList

import java.util.*; public class Lista { public static void main(String[] args) { List list = new ArrayList(); list.add(1); list.add(1); list.add(1); Iterator iter = list.iterator(); while(iter.hasNext()) System.out.println("list: "+iter.next()); } }

Lezione 4

Le strutture di tipo Set • I Set sono una sequenza di elementi che NON ammettono duplicati • Implementate con HashSet, LinkedHashSet, TreeSet

import java.util.*; public class Lista { public static void main(String[] args) { Set set = new HashSet(); set.add(1); set.add(1); set.add(1); Iterator ite = set.iterator(); while(ite.hasNext()) System.out.println("set:" + ite.next()); } }

Lezione 5

Le strutture di tipo Map • Le Map sono delle sequenze di valori identificati dall’hashcode dell’oggetto

usato come chiave. • Implementate sono HashMap, Hashtable, LinkedHashMap, TreeMap

import java.util.*;

public class Lista {


Map map = new Hashtable();

map.put(1,"prova1");



Iterator iter_map = map.keySet().iterator();

while(iter_map.hasNext()){

Object obj = iter_map.next();

System.out.println("map_key:" + obj );

System.out.println("map_value:" + map.get(obj));

}

}

}

Lezione 6

Gli oggetti Comparator

• Gli oggetti Comparator sono utilizzati per effettuare

confronti tra oggetti, in particolare il controllo viene effettuato sulle proprietà delle classi per determinare l’ordine tra le classi.

• E’ necessario implementare il metodo: ▫ public int compare(Object t1, Object t2)

• Nell’esempio seguente creiamo una classe che implementa Comparator per ordinare l’oggetto MyBean che viene inserito in una lista.

• Notare che l’ordinamento non è implicito e non avviene nel momento in cui gli oggetti vengono inseriti, ma è esplicito ed avviene solo dopo aver invocato il metodo Collections.sort()

Lezione 6


package compare;

import java.util.Comparator;

public class Compare implements Comparator<MyBean> {

@Override

public int compare(MyBean t, MyBean t1) {

int x = t.getId();

int y = t1.getId();

return (x < y )? -1 : ((x==y) ? 0 : 1 );

}

}

Lezione 6


package compare; public class MyBean { private int id; private String name; public MyBean(int id, String name){ this.id = id; this.name = name; } public int getId() { return id; } public String getName() { return name; } }

Lezione 6


package compare;

import java.util.*;

public class Start {


//Creo i bean

MyBean mb1 = new MyBean(5,"ciccio");

MyBean mb2 = new MyBean(7,"pippo");

MyBean mb3 = new MyBean(9,"pluto");

//inserisco i bean nella lista

List<MyBean> list = new ArrayList<MyBean>();

list.add(mb2);

list.add(mb3);

list.add(mb1);

Lezione 6


….

System.out.println( "Visualizzo l'ordine nella lista prima dell'ordinamento");

for (MyBean myBean : list)

System.out.println( myBean.getId() );

//Creo il Comparator ed ordino la lista

Compare compare = new Compare();

Collections.sort(list, compare);

System.out.println( "Visualizzo l'ordine nella lista dopo l'ordinamento");

for (MyBean myBean : list)

System.out.println( myBean.getId() );

}

}

Documents

Corso Java 2 - AVANZATO