Corso Java 2 - AVANZATO

3,647 views

Published on

0 Comments
1 Like
Statistics
Notes
  • Be the first to comment

No Downloads
Views
Total views
3,647
On SlideShare
0
From Embeds
0
Number of Embeds
1,968
Actions
Shares
0
Downloads
156
Comments
0
Likes
1
Embeds 0
No embeds

No notes for slide

Corso Java 2 - AVANZATO

  1. 1. Corso 2 JavaProgrammazione AvanzataGiuseppe Dell’Abate
  2. 2. Modulo 1JDBC e Database
  3. 3. Lezione 1Le 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).
  4. 4. Lezione 1Le 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
  5. 5. Lezione 2Il 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.
  6. 6. Lezione 2Il 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");
  7. 7. Lezione 3Tipi 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”);
  8. 8. Lezione 4Creare 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();
  9. 9. Lezione 5Creare 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.
  10. 10. Lezione 5Creare una istruzione SQL preparata 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 where nome = ?"; PreparedStatement stmt = conn.prepareStatement(sql); stmt.setString(1, "Mario"); 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();
  11. 11. Lezione 6Lanciare 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
  12. 12. Lezione 6Lanciare una store procedure String url = "jdbc:postgresql://SERVER-POSTGRESQL/esercitazioni"; String user = ""; String passwd = ""; Class.forName("org.postgresql.Driver"); Connection con = DriverManager.getConnection(url,user,passwd); CallableStatement storedProcedure = connection.prepareCall("{ call insertUser(?) }"); storedProcedure.setString(1, name); storedProcedure.execute(); storedProcedure.close(); con.close();
  13. 13. Lezione 7Recuperare 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. ResultSet rs=stmt.executeQuery(sql); while (rs.next()) { System.out.println(“Cognome: "+rs.getString("Cognome")); System.out.println(“Nome: "+rs.getString("Nome")); }
  14. 14. Lezione 8Accesso 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.
  15. 15. Lezione 8Accesso 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"; String user = ""; String passwd = ""; Class.forName("org.postgresql.Driver"); Connection con = DriverManager.getConnection(url,user,passwd); DatabaseMetaData dbmd = conn.getMetaData(); System.out.println( dbmd.getDatabaseProductName() ); System.out.println( dbmd.getDatabaseProductVersion()); System.out.println( dbmd.getDriverName() ); con.close();
  16. 16. Modulo 2Stream
  17. 17. Lezione 1Il 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.
  18. 18. Lezione 2Il 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)
  19. 19. Lezione 3I tipi di stream
  20. 20. Lezione 3I 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); } }
  21. 21. Lezione 3I tipi di stream
  22. 22. Lezione 3I 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); } }
  23. 23. Lezione 3I tipi di stream
  24. 24. Lezione 3I 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); } }
  25. 25. Lezione 3I tipi di stream
  26. 26. Lezione 3I 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(); } } }
  27. 27. Lezione 6Serializzazione 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.
  28. 28. Lezione 6Serializzazione 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()); } }
  29. 29. Lezione 6Serializzazione 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
  30. 30. Modulo 3Networking
  31. 31. 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)
  32. 32. Lezione 2Connessione 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
  33. 33. Lezione 3Le 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()
  34. 34. Lezione 4Realizzazione 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(); } }
  35. 35. Lezione 5Realizzazione 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; } } }
  36. 36. Modulo 4Programmazione Multithread
  37. 37. Lezione 1Il 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.
  38. 38. Lezione 1Il 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.
  39. 39. Lezione 2La classe Thread e linterfaccia Runnable• Per creare un Thread in Java è possibile utilizzare due scelte opzionali:1. Estendere la classe Thread2. 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).
  40. 40. Lezione 2La classe Thread e linterfaccia Runnable1. 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"); }}
  41. 41. Lezione 2La classe Thread e linterfaccia 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 ThreadHello Runnable
  42. 42. Lezione 2La classe Thread e linterfaccia 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"); }}
  43. 43. Lezione 3Le 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
  44. 44. Lezione 4Impostare 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
  45. 45. Lezione 4Impostare 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()); }}
  46. 46. Lezione 4Impostare le prioritàpublic class StartPriorita { public static void main(String[] args) { 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(); }}
  47. 47. Lezione 4Impostare 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 PRIORITAThread con MEDIA PRIORITAThread con ALTA PRIORITAThread con ALTA PRIORITAThread con ALTA PRIORITAThread con ALTA PRIORITAThread con ALTA PRIORITAThread con MEDIA PRIORITAThread con MEDIA PRIORITAThread con MEDIA PRIORITAThread con MEDIA PRIORITAThread con BASSA PRIORITAThread con BASSA PRIORITAThread con BASSA PRIORITA’Thread con BASSA PRIORITA ’
  48. 48. Lezione 5Lo 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.
  49. 49. Lezione 5Lo stato dei thread1. 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 thread3. Running: il Thread è “vivo ed in esecuzione”. Esegue il codice di cui è stato programmato fino ad interruzione interna o esterna.
  50. 50. Lezione 5Lo stato dei thread4. 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 attesa5. 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.
  51. 51. Lezione 6Condivisione 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.
  52. 52. Lezione 6Condivisione di dati tra threadpublic 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) {} } } }}
  53. 53. Lezione 6Condivisione di dati tra threadpublic 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) { } } }}
  54. 54. Lezione 6Condivisione di dati tra threadpublic 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:pingpongpingpongpingpong…..
  55. 55. Lezione 7La 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.
  56. 56. Lezione 7La 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.
  57. 57. Lezione 7La 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) {} }}
  58. 58. Lezione 7La sincronizzazione• La classe TestSinc crea 2 Thread usando la stessa istanza di TestSinc, pertanto l’accesso alla risorsa sincronizzata viene rispettatapublic class TestSinc extends Thread { Stampante stampante = new Stampante(); public static void main(String[] args) { 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"); }}
  59. 59. Lezione 7La 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(); public static void main(String[] args) { Thread t = new Thread(new TestSinc()); t.start(); Thread t2 = new Thread(new TestSinc()); t2.start(); } @Override public void run(){ stampante.stampa("prova"); }}
  60. 60. Lezione 7La 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) {} }}
  61. 61. Lezione 9Gestione 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.
  62. 62. Modulo 5Collections
  63. 63. Lezione 1Le 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.
  64. 64. Lezione 1Le API per le strutture dati
  65. 65. Lezione 2Linterfaccia 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
  66. 66. Lezione 3Le strutture monodimensionali - List• Le List sono una sequenza ordinata di elementi che ammettono duplicati• Implementate con ArrayList, Vector e LinkedListimport 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()); }}
  67. 67. Lezione 4Le strutture di tipo Set• I Set sono una sequenza di elementi che NON ammettono duplicati• Implementate con HashSet, LinkedHashSet, TreeSetimport 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()); }}
  68. 68. Lezione 5Le strutture di tipo Map• Le Map sono delle sequenze di valori identificati dall’hashcode dell’oggetto usato come chiave.• Implementate sono HashMap, Hashtable, LinkedHashMap, TreeMapimport java.util.*;public class Lista { public static void main(String[] args) { Map map = new Hashtable(); map.put(1,"prova1"); map.put(1,"prova2"); map.put(1,"prova3"); 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)); } }}
  69. 69. Lezione 6Gli 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()
  70. 70. Lezione 6Gli oggetti Comparatorpackage 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 ); }}
  71. 71. Lezione 6Gli oggetti Comparatorpackage 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; }}
  72. 72. Lezione 6Gli oggetti Comparatorpackage compare;import java.util.*;public class Start { public static void main(String[] args) { //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);
  73. 73. Lezione 6Gli oggetti Comparator …. System.out.println( "Visualizzo lordine nella lista prima dellordinamento"); 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 lordine nella lista dopo lordinamento"); for (MyBean myBean : list) System.out.println( myBean.getId() ); }}

×