Corso Java 2 - AVANZATO

Corso 2 Java
Programmazione Avanzata
Giuseppe Dell’Abate

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 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
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”
DatabaseMetaData dbmd = conn.getMetaData();
System.out.println( dbmd.getDatabaseProductName() );
System.out.println( dbmd.getDatabaseProductVersion());
System.out.println( dbmd.getDriverName() );
con.close();

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
• 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
• 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
• 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
• 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
• 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
• 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

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
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
• 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
• 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
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
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
• 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
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
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
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);
}
}

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);
}
}

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.

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 {
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.*;
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.*;
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() );
}
}

Corso Java 2 - AVANZATO

More Related Content

What's hot

Viewers also liked

Similar to Corso Java 2 - AVANZATO

Corso Java 2 - AVANZATO