Google Guava?

Il Progetto contiene molte delle core libraries usate da Google nei progetti Java-based. Queste librerie coprono molti aspetti: le collection, la cache, la gestione della concorrenza, il processamento delle stringhe, l’I/O e così via.

Un’altra libreria?

Sicuramente di librerie ben progettate che semplificano molto il lavoro dello sviluppatore Java ce ne sono parecchie: tra tutte cito soltanto il set di librerie Apache Commons, usatissime e preziose. Inoltre c’è da dire che anche il linguaggio Java standard sta evolvendo: e Java8 prevedono diverse modifiche al linguaggio, che sta diventando più potente ma allo stesso tempo più stringato, seguendo la tendenza di altri linguaggi, uno fra tutti: .

Nonostante questo non si può non dedicare un piccolo post ad una libreria Java che, beh, è fatta da Google (e usata dal progetto JBoss RichFaces4, tra gli altri)! Siete pronti? Andiamo!

Partenza!

Sono partito dal mio fido Eclipse: è possibile scaricarsi il Jar e aggiungerlo al build path oppure utilizzare Maven inserendo la seguente dipendenza nel nostro pom.xml:

        
                com.google.guava
                guava
                11.0.1
        
  

Ulteriori dettagli sono disponibili nella documentazione di Google ().

Guava, come lava!

Crea collection in modo rapido

Le collection generiche sono una grande introduzione di Java 5, ma la loro creazione può essere davvero un po’ troppo verbosa:

Map> mappa = new HashMap>();

Con la precedente inizializzazione diventa molto più succinta:

Map> mappa = Maps.newHashMap();

Un tocco di functional

Come filtrare ad esempio gli elementi di una lista in modo che rimangano solo quelli != null? Alle ortiche il vecchio ciclare, direbbero i funzionali: e anche in abbiamo un comodo metodo filter:

public class MainTest {
        private static List integers;

        @BeforeClass
        public static void init() {
                integers = new ArrayList();
                integers.add(1);
                integers.add(null);
                integers.add(3);
                integers.add(null);
                integers.add(5);
        }

        @Test
        public void testFilter() {
                Collection filtered = Collections2.filter(integers,
                                Predicates.notNull());

                assertEquals(3, filtered.size());
                
                Collection filtered2 = Collections2.filter(integers, Predicates.or(Predicates.equalTo(1), Predicates.equalTo(3)));
                
                assertEquals(2, filtered2.size());
        }
}

Da notare che filter non modifica la collezione passata in ingresso, ma ne restituisce una copia diversa. Per modificare la collezione originaria si può utilizzare il metodo trasform.

MultiMaps

Non di rado utilizziamo una Map per memorizzare valori multipli in corrispondenza della stessa chiave. L’utilizzo di Java standard implica scrivere codice verboso in questi casi, ma utilizzando le Multimaps di il codice diventa minimalista:

Multimap punteggi = HashMultimap.create();
punteggi.put("Manuele", 20);
punteggi.put("Manuele", 10);
punteggi.put("Manuele", 15);
System.out.println(Collections.max(punteggi.get("Manuele"))); 
// scrive 20 in console

HashCode, toString e compareTo

Quasi sicuramente ci si trova a definire l’hashCode (e l’equals in modo coerente) nei nostri Pojo, così come il toString, tanto comodo tra l’altro per il e il debugging.

Per quanto riguarda l’hashCode di solito si fa generare ad Eclipse (Menu Source -> Generate hashCode() and equals…), ma il codice prodotto tuttavia risulta sempre un po’ ostico e verboso. Se vogliamo del codice più pulito possiamo utilizzare un metodo di utilità della classe Objects:

public class Persona
{
   private String nome;
   private String cognome;
   ...
   @Override
   public int hashCode() {
        return Objects.hashCode(nome, cognome);
   }
}

Veniamo al toString: ne volete uno elegante scrivendo poco codice? Allora usate il metodo Objects.toStringHelper:

public class Persona
{ 
@Override
   public String toString() {
        return Objects.toStringHelper(this).add("nome", nome).add("cognome", cognome).toString();
   }

@Test
        public void testToString() {
                Persona persona = new Persona("Manuele", "Piastra");
                System.out.println(persona);
                //Scrive Persona{nome=Manuele, cognome=Piastra}
        }

Anche il metodo compareTo dell’interfaccia Comparable si implementa in modo più smart grazie alla classe ComparisonChain:

public class Persona implements Comparable {
{
   private String nome;
   private String cognome;
   ...
  @Override
        public int compareTo(Persona p) {
                return ComparisonChain.start().compare(this.nome, p.nome).compare(this.cognome, p.cognome).result();
        }
}

Occhio alla precondizioni

Se ci si trova spesso a testare certe precondizioni può darci una mano facendoci scrivere meno codice più leggibile; ad esempio anziché scrivere:

if (eta <= 18) {
    throw new IllegalArgumentException("Hai " + eta + " anni: devi essere maggiorenne per guidare!");
}

possiamo utilizzare:

Preconditions.checkArgument(eta > 18, "Hai %s anni: devi essere maggiorenne per guidare!", eta);

ottenendo lo stesso identico risultato.

Conclusioni

Volete scrivere del codice più smart e non potete passare a Java7? Allora le Apache Commons e le sono due ottime alternative. Sicuramente ciascuna delle due ha pregi e difetti e credo che solo usandole per un po’ si riesca a capire quale abbia il design che preferiamo. Una cosa è sicura: entrambe sono librerie di qualità che possono migliorare la nostra produttività e rendere il nostro codice più stringato e manutenibile.

E voi avete usato ? Qual’è stata la vostra esperienza a riguardo? Avete qualche altro suggerimento da aggiungere? Alla prossima!