Mejora tu código Java usando Groovy

¿Y por qué razón desearíamos progresar nuestro código Java? Seguro que más de una vez escribiendo Java has pensado que es muy verboso o bien que seguro que debe haber una forma más simple y fácil de hacer esto. En un caso así, Groovy es para ti.

Apache Groovy es un lenguaje activo, opcionalmente tipado, con posibilidad de tipado y colección estáticos para la JVM. Tiene como propósito multiplicar la productividad de los desarrolladores merced a una sintaxis breve, familiar y simple de aprender. Se integra sin inconvenientes con cualquier programa Java y también de manera inmediata da a una aplicación poderosas peculiaridades como scripting, DSLs, metaprogramación en runtime y compile-time y programación funcional.

Características más importantes

Entre las peculiaridades más esenciales de Groovy, destacan:

Tipado dinámico: Si sabemos el género de una variable podemos definirlo como en Java, mas a veces, para variables locales de métodos el código es más inteligible si no lo hacemos. En un caso así usaremos la palabra reservada def como tipo.
Colección estática opcional: Desde la versión dos.0 (hace más de cuatro años) Groovy aguanta colección estática, o sea, el bytecode generado es muy afín al que produciría el código Java equivalente. Con esta característica Groovy puede ser tan veloz y eficaz como Java a costa de sacrificar su dinamismo, que, siendo realistas, no necesitaremos en el noventa por ciento de nuestro código.
Perfecta integración con Java: Desde Groovy podemos usar cualquier biblioteca Java existente en nuestros días sin precisar amoldarla ni de hacer nada singular. Sencillamente agregamos la dependencia al classpath y listo, ya podemos usarla desde Groovy.
Sintaxis nativa de listas, mapas y rangos: Groovy propocina una sintaxis nativa y muy explícita para listas, mapas y rangos con la que podemos lograr que nuestro código sea muy inteligible y brev.
Las salvedades son unchecked: Se han escrito ríos de tinta sobre las checked exceptions de Java mas la enorme mayoría de los defensores del lenguaje y Java Champions coinciden en que ha sido uno de los fallos en el diseño del lenguaje. En Groovy todas y cada una son unchecked, con lo que no es preciso manchar de forma superflua la signatura de los métodos con throws que no van a ningún lugar ni tener bloques catch en blanco o bien con un simple System.out.println.

Diferencias con Java

Podría redactar múltiples artículos sobre las diferencias entre Java y Groovy, mas las más esenciales son:

Uso de properties

En multitud de ocasiones definimos una clase con atributos privados y un montón de getters y setters para acceder a ellos. En Groovy no es preciso, el compilador se hace cargo de definirlos por nosotros.

class Persona undefined

Con este código estamos definiendo la clase pública Persona y los atributos privados nombre y edad. El compilador producirá los getters y setters precisos y vamos a poder redactar el próximo código que va a llamar al setter. Asimismo podemos redactar el código entre comentarios que sería el equivalente en Java.

persona.nombre = 'Iván' // Igual que persona.setNombre('Iván')

De forma adicional si anotamos la clase con @Canonical vamos a tener una implementación para equals, hashCode, toString y vamos a tener constructores para emplear los atributos definidos en la clase.

Strings interpolados (GStrings)

Creo que lo mejor es verlo con un ejemplo:

println El coste de la acción dólares americanos accion a día dólares americanos fecha es dólares americanos valor

Se reemplazará el valor de las variables en el string sin precisar ir edificando el string con fragmentos y variables. El código queda considerablemente más fácil y simple de leer.

Además de esto, si en vez de una comilla ponemos 3, vamos a poder redactar strings multilinea:

String multilinea = Podemos redactar
el string en
múltiples líneas

Listas y mapas

Es común manipular listas y mapas en nuestro código, con lo que una sintaxis sucinta hace que el código sea considerablemente más inteligible.

def lista = [1, dos, tres, 4] // ArrayList

// O bien asimismo
List lista = [1, dos, tres, 4]

def mapa = [nombre: 'Iván', edad: 36] // HashMap
println mapa.nombre // mapa.get(nombre);
mapa.edad = treinta y siete // mapa.put(edad, treinta y siete);

Closures vs Lambdas

Java aguanta Lambdas desde la versión ocho mas en Groovy tenemos el término de Closures desde el comienzo. Si bien no se comportan precisamente igual, como regla podemos decir que vamos a poder usar una closure de Groovy en cualquier código que admita una lambda de Java.

// Java
Arrays.asList(1, dos, tres).stream()
.map(i -> i * dos)
.filter(i -> i > tres)
.findFirst()
.orElseThrow(IllegalArgumentException::new);

// Groovy
[1, dos, 3].stream()
.map undefined
.filter undefined
.findFirst()
.orElseThrow(IllegalArgumentException.metaClass.