I metadati permettono di associare informazioni aggiuntive a classi, interfacce, metodi e campi. Queste informazioni possono essere lette dai file sorgenti, dai file class e a runtime usando la reflection. I metadati sono particolarmente utili quando ad esempio abbiamo dei file di configurazione esterni; in questo caso si possono portare le informazioni presenti nel file esterno, all’interno della classe e poi leggerli e usarli a runtime; o ancora, basti pensare al codice che bisogna scrivere per esportare un metodo come web service mediante JAX-RPC. Con l’utilizzo delle annotationsè possibile “decorare” opportunamente le classi e creare un tool che genera automaticamente il codice necessario per creare un web service. Lo stesso discorso è valido per tutte quelle situazioni in cui bisogna scrivere codice ripetitivo, come fare il lookup di una risorsa JNDIo configurare una connessione JDBC.

Prima:

    public interface NetUtilsI extends Remote {
        public void ping() throws RemoteException;
    }

    public class NetUtils implements NetUtilsI {
        public void ping() {
            ...
        }
    }

Adesso:

    public class NetUtils {
        public @remote void ping() {
            ...
        }
    }

L’applicazione dei generics è possibile vederla nella Collections API. Le classi che vi appartengono (ArrayList, HasMap, ecc.) possono contenere dati di vari tipi; con i generics è possibile indicare il tipo di dato che conterrà la collezione avendo un controllo a tempo di compilazione. Ma vediamo un esempio per chiarire meglio la cosa:

Prima si faceva :

    ArrayList list = new ArrayList();
        list.add(0, new Integer(42));
        int total = ((Integer)list.get(0)).intValue();

Adesso:

    ArrayList<Integer> list =new ArrayList<Integer>();
        list.add(0, new Integer(42));
        int total = list.get(0).intValue();

Osserviamo come nel secondo caso non sia più necessario il casting dell’oggetto estratto dalla Collection, inoltre se tentassimo diinserire un oggetto di tipo String in listavremmo un errore a tempo di compilazione.

Convertire un tipo primitivo come int o boolean nel suo equivalente “oggetto” Integer e Boolean e viceversa è un’operazione che necessita della scrittura di codice extra, soprattutto quando si utilizzano le Collections. L’autoboxing e l’auto-unboxing permettono di scrivere codice più chiaro e conciso in questo tipo di situazioni.

Prima, ad esempio, si scriveva:

    ArrayList<Integer> list = new ArrayList<Integer>();
        list.add(0, new Integer(100));
        int total = (list.get(0)).intValue();

Adesso:

    ArrayList<Integer> list = new ArrayList<Integer>();
        list.add(0, 100);
        int total = list.get(0);

La classe Iterator viene molto usata nelle Collections per navigare sequenzialmente gli elementi contenuti in essa. In questa versione del jdk è stata contratta la sintassi per i cicli.

Prima si faceva :

    ArrayList<Integer> list = new ArrayList<Integer>();
        for (Iterator i = list.iterator(); i.hasNext();) {
            Integer value=(Integer)i.next();
        }

Adesso più semplicemente:

    ArrayList<Integer> list = new ArrayList<Integer>();
        for (Integer i : list) { ... }

Da notare come l’uso dei generics permette di evitare il casting degli oggetti.

Finalmente è stato introdotto il tipo enumerativo!!! (Quante volte mi avrebbe fatto comodo……!!!)

Gli import statici permettono di riferire costanti statiche senza indicarne la classe. Un esempio chiarirà meglio la cosa: Se devo invocare, ad esempio, Math.cos(), facendo un import statico potrò invocare semplicemente cos():

     import static java.lang.Math.*;
      r = cos(PI * theta); 

E’ stato introdotto il metodo printf del C che permette la formattazione dell’output. Sono presenti la maggior parte dei più comuni formatters ed inoltre le classi Date e BigInteger sono stati dotati di propri formatter. Riferirsi alla classe java.util.Formatterper maggiori informazioni.

    System.out.printf("name count%n");
     System.out.printf("%s %5d%n", user, total);

Da notare l’uso del newline cross-platform %n da preferire all’uso di\n

La classe Scanner permette di leggere dati da tastiera o da un qualunque altro stream. Nell’esempio seguente ci si aspetta da standard input una stringa e poi un intero; finche non sono disponibili i dati richiesti si resta in uno stato di blocco. E’ possibile elaborare input più complessi con gli algoritmi di pattern-matching presenti nella classe java.util.Formatter.

 Scanner s= new Scanner(System.in);
    String param= s.next();
    int value=s.nextInt();
    s.close(); 

Questa funzionalità consente di passare un numero variabile di argomenti ad un metodo; basta usare la semplice notazione ... per indicare che un metodo accetta una lista di lunghezza imprecisata di argomenti.

Esempio:

    public static String format(String intro, Object... arguments);
         String result = MessageFormat.format("Oggi è il ",      
                                                                                     new Date(),
                                                                                     "e la temperatura è di ",
                                                                                       new Integer(18), “gradi”);

Sono state introdotte diverse utility per facilitare l’uso della concorrenza e quindi dei Thread. E’ possibile costruire thread pool ecollection thread-safe inoltre sono messe a disposizione primitive di basso livello per sfruttare il supporto alla concorrenza messo a disposizione del processore. Una delle novità interessanti da sottolineare è l’introduzione della classe Semaphore. Un semaforo può essere usato come la wait per rendere esclusivo l’accesso ad una parte di codice, offrendo però una maggiore flessibilità.

Esempio:

    finalprivate Semaphore s= new Semaphore(1, true);

        s.acquireUninterruptibly();
        try {
                x=x+10; //valore protetto
        } finally {
          s.release(); //rilascia la risorsa
        } 

La programmazione di client Desktop è uno degli elementi chiave della piattaforma java e in questa versione vengono prospettati notevoli miglioramenti per la fase di avvio delle applicazioni (normalmente abbastanza lenta) e una migliore gestione della memoria ma anche un nuovo tema per le interfacce swing chiamato Ocean e il Windows XP Look & Feel.

Per chi è dotato di acceleratori grafici con driver OpenGL, adesso è possibile accedere da Java2D alle funzioni native.

La versione del jdk per Linux è inoltre dotato del veloce toolkit X11 chiamato XAWT (sun.awt.X11.XToolkit), abilitato per default, che permette il drag & drop di oggetti con altri software come StarOffice o Mozilla.

Nella versione 1.4 della J2SE era stata introdotta l’interfaccia RowSet, che estende ResultSet al fine di creare un metodo “leggero” per passare i dati provenienti da DB tra i componenti di un’applicazione. In pratica il RowSet è l’esportazione di JDBC verso JavaBeans; sono presenti i metodi setters “tipati” (setInt, setString ecc.) per passare i parametri al fine di eseguire una query e i metodi getters per leggere i risultati. Ne sono state implementate ben cinque versioni, tra quelle più interessanti citiamo la CachedRowSet che non resta permanentemente connesso alla fonte dati, ma che vi accede solo quando necessario e la WebRowSet che può importare ed esportare un RowSet in formato XML.

Vediamo un esempio di utilizzo della classe WebRowSet :

   Class.forName("oracle.jdbc.driver.OracleDriver");
    WebRowSetImpl wrs = new WebRowSetImpl();
    wrs.setCommand("SELECT nome_prodotto,prezzo FROM catalogo");
    wrs.setUsername("user1");
    wrs.setPassword("pwd1");
    wrs.setUrl("jdbc:oracle:thin:@hostname:1521:test");
    wrs.execute(); // esegue la query e popola il webset
    wrs.absolute(1); // muove il cursore alla prima riga
    wrs.updateInt(2, 10); // setta a 10 il secondo campo reperito cioè // prezzo
    wrs.updateRow(); // aggiorna la riga
    wrs.acceptChanges(); // scrive il dato modificato nel data source
    wrs.writeXml(System.out); // esporta il rowset in formato XML
    wrs.close(); // chiude il rowset

J2SE 1.5 in a Nutshell
http://java.sun.com/developer/technicalArticles/releases/j2se15/

JDK 1.5 from Joshua and Neal
http://www.theserverside.com/blogs/showblog.tss?id=JDK15

New Features and Enhancements J2SE 5.0
http://java.sun.com/j2se/1.5.0/docs/relnotes/features.html