operador

Si alguna vez habéis programado en un lenguaje de programación con sintaxis heredada de C: el mismo C, C++, Java, C#… seguro que habéis utilizado el operador postincremento, sobre todo en iteraciones for, el famoso: i++ (o equivalente). Lo que es menos frecuente es haber utilizado el operador ++i, pero si lo habéis utilizado seguro que lo habéis hecho para algo similar al anterior. La diferencia entre ambos es algo que un día me inquietó y que hoy os voy a comentar.

La diferencia es la precedencia del operador, es decir, qué operador realiza su acción antes. Esta diferencia no importa cuando la única operación de una sentencia es i++ o ++i, es decir:

i++;
++i;

Típica situación del caso de las iteraciones for, es lo mismo. Sin embargo, cuando hay otra operación de por medio, las cosas cambian. Veamos:

i = 0;
v = i++;

La variable v contendrá 0 e i contendrá 1. Primero se ha asignado el valor de i a v y posteriormente se ha incrementado i. Si utilizamos el otro operador, que tiene más precedencia, se ejecutará antes el incremento de i y posteriormente se asignará su nuevo valor, 1, a la variable v.

i = 0;
v = ++i;

En este caso ambas variables, v e i, contienen 1.

La diferencia funcional, como podéis ver, existe y es conveniente conocerla, para poder utilizarla, explotarla y de paso, conocer algo más sobre los lenguajes de este tipo.

Aparte existe otra diferencia, ésta de carácter computacional y que es conveniente conocerla de cara a hacer más eficiente nuestro código. ++i realiza dos instrucciones, incrementar y retornar; mientras que i++, por lo que acabamos de comentar lleva a cabo tres: guardar el estado actual, incrementar, retornar el estado anterior.

java_logo

Aunque todavía queda un poco para el lanzamiento de la versión estable de Java 7 (ahora mismo si no me equivoco están en la actualización 17 de Java 6), aquí os traigo una serie de mejoras que va a incorporar y que podéis ya probar a través del JDK 7 Early Access.

La recopilación de las mejoras ha salido publicada en el blog tecnológico de JoeJag (en inglés) y aquí os la dejo traducida:

Soporte mejorado para colecciones

A partir de ahora las colecciones podrán declararse al estilo de Ruby o Perl. En lugar de tener que hacer:
List list = new ArrayList();
list.add("item");
String item = list.get(0);

Set set = new HashSet();
set.add("item");

Map map = new HashMap();
map.put("key", 1);
int value = map.get("key");

Se podrá hacer directamente:
List list = ["item"];
String item = list[0];

Set set = {"item"};

Map map = {"key" : 1};
int value = map["key"];

Manejo automático de recursos

Algunos recursos como InputStream, Writers, Sockets o clases relacionadas con Sql, tienen que ser ser cerrados manualmente en cada utilización, por ejemplo:
BufferedReader br = new BufferedReader(new FileReader(path));
try {
return br.readLine();
} finally {
br.close();
}

Sin embargo, a partir de ahora, automáticamente podremos hacer:
try (BufferedReader br = new BufferedReader(new FileReader(path)) {
return br.readLine();
}

O si tenemos más de un recurso:
try (
InputStream in = new FileInputStream(src);
OutputStream out = new FileOutputStream(dest))
{
// código
}

Inferencia de tipos mejorada para creación genérica de instancias (operador diamante < >)

Si antes estábamos obligados a hacer:
Map> anagrams = new HashMap>();

Ahora simplemente:
Map> anagrams = new HashMap<>();

Barras bajas en literales numéricos

Porque los números grandes son complejos de leer sin problemas:
int un_millon= 1_000_000;

Cadenas para la clausula switch

Posiblemente el más esperado de todos (hasta ahora sólo los tipos enum y números podían ser utilizados en los switch). Ya podremos hacer directamente:
String s = ...
switch(s) {
case "linuxhispano":
llamar(w);

case "web":
case "internet":
procesar(w);
break;

case "foo":
procesarfoo(s);
// fall-through

default:
demas(s);
break;
}

Binarios literales

Utilizando el prefijo 0b (es un cero ‘0′ no una o), podremos representar directamente enteros en formato binario:
int binary = 0b1001_1001;

Simplificación de la invocación de métodos con argumentos variables

Si hasta ahora el compilador emitía warning en el lugar de la llamada al método, ahora lo hará en el de la declaración del mismo para facilitar la labor a los desarrolladores.