Concatenacin de cadenas en

Java: Optimizaciones realizadas

por el compilador
08may08
La mquina virtual de Java no conoce al operador de
concatenacin (+) a la hora de ejecutar nuestro cdigo.
Por este motivo el compilador se encarga de traducir los lugares
donde este operador aparece por el cdigo necesario que permite
cumplir con el mismo propsito y de forma ptima.
Veremos cuales son las traducciones realizadas por el compilador y
como podemos aprovecharlas a nuestro favor.
Definiciones
Antes de empezar vamos a definir algunos trminos, que aunque no
sean definidos de una forma muy formal, permitirn una mejor
comprensin del texto:
Cadena: Una instancia de la clase String. El objeto puede estar
asignado a una variable, una constante o no (cadenas annimas)
Cadenas Annimas: Cadenas no asociadas a ningn objeto que se
crean y utilizan en la sentencia que se declaran, y luego son
descartadas. Por ejemplo en:
1 System.out.println("Hola Mundo");
la cadena Hola Mundo se crea y utiliza en el System.out.println y
luego se descarta.
Caso 1: Concatenacin de cadenas
annimas
Aunque muchas veces parezca incorrecta o ineficiente la
realizacin de concatenacin de dos cadenas annimas en vez de
solo utilizar una, resulta ser lo mismo luego de pasar por el
compilador, ya que si tenemos por ejemplo:
1
2
3
//...
String a = "Hola " + "Mundo";
//...
Se convertir en:
1
2
3
//...
String a = "Hola Mundo";
//...
Viendo la maquina virtual lo mismo que si hubiramos asignado
Hola Mundo de primera intencin.
Cul puede ser el beneficio entonces de separar una cadena
annima en dos o ms pedazos?
El beneficio que encontramos no es al momento de correr nuestro
programa, sino al momento de mantenerlo, ya que en varias
ocasiones permitir una mejor lectura del mismo:
1
2
3
String fragmento = "Por lo tanto, los que no son totalmente conscientes de"
+ " la desventaja de servirse de las armas no pueden ser totalmente
conscientes"
+ " de las ventajas de utilizarlas";
Caso 2: Concatenacin de constantes
Si tenemos definidas constantes y las concatenamos con alguna
cadena annima o entre si, primero que nada el compilador
realizar el intercambio de las constantes por la cadena que
representan y luego las trata como el caso anterior. Por ejemplo:
1
2
//...
public static final String CONSTANTE_A = "AAA";
3
4
5
6
7
8
9
10
11
private static final String CONSTANTE_B = "BBB";
public final String CONSTANTE_C = "CCC";
private final String CONSTANTE_D = "DDD";
//...
String a = "Mostrar " + CONSTANTE_A;
String b = "Mostrar " + CONSTANTE_B;
String c = "Mostrar " + CONSTANTE_C;
String d = "Mostrar " + CONSTANTE_D;
//...
Despus de compilar tendremos:
1
2
3
4
5
6
//...
String a = "Mostrar AAA";
String b = "Mostrar BBB";
String c = "Mostrar CCC";
String d = "Mostrar DDD";
//...
Por lo que podemos ver que no importa el modificador de acceso o
si es esttica o no, mientras el valor de la constante este
disponible a la hora de compilar, ser reemplazado en la
concatenacin.
En este caso podemos ver que la ventaja que trae aparejado el uso
de constantes, que es permitirnos hacer mas legible nuestro cdigo
no va en contraposicin a la de la tener una buena eficiencia en la
ejecucin, ya que no se perder tiempo realizando
concatenaciones porque fueron realizadas al momento de la
compilacin.
Caso 3: Concatenacin de variables
finales
Al igual que en el caso anterior si tenemos definida un variable
declarada dentro de un mtodo como final y esta la concatenamos,
el compilador la reemplazara la referencia por el valor que
representa la variable final.
Por ejemplo:
1
2
3
4
//...
final String a = " AAA";
String b = "Mostrar " + a;
//...
Despus de compilar obtendremos:
1
2
3
4
//...
final String a = " AAA";
String b = "Mostrar AAA";
//...
Otra vez tenemos las mismas ventajas del punto anterior.
Caso 4: Concatenacin de variables
La concatenacin de variables es distinta de los casos anteriores
debido a que en ningn caso el compilador puede suponer el valor
almacenado en las mismas. Como no sabe con que valores se
contar, lo que se realiza a la hora de compilar es armar un
StringBuilder e irle agregando las cadenas que queremos visualizar.
Esta vez la sentencia quedar preparada y la concatenacin real se
realizara durante el momento de ejecucin.
Por ejemplo:
1
2
3
4
//...
String v = "Mundo";
//...
String resultado = "Hola " + v;
5
//...
Como se puede observar, no se puede asegurar de ninguna manera
que el valor de v va a seguir siendo Mundo al momento de
concatenar, por lo que el compilador genera:
1
2
3
//...
String resultado = (new StringBuilder()).append("Hola
").append(v).toString();
//...
Bsicamente al ejecutarse realizar lo siguiente:
- crear una instancia de StringBuilder
le agregar la cadena Hola
le agregar el valor de la variable v
obtendr la cadena resultante
asignar la cadena resultante a la variable resultado
Nuevamente lo que ganamos es expresin a la hora de analizar
nuestro cdigo. Veamos un ejemplo ilustrativo de esto, es ms
difcil entender a simple vista esto:
1
2
3
//...
String res = "Cantidad de tomates:
".concat(Integer.toString(cantidad));
//...
A esto:
1
2
3
//...
String res = "Cantidad de tomates: " + cantidad;
//...
Caso 5: Caso especial de
concatenacin de variables
Existe un caso especial a la hora de realizar optimizaciones que el
compilador no es capaz de darse cuenta, cuando a una variable
debemos concatenarle cadenas en varias sentencias, por ejemplo
un caso muy simple:
1
2
3
4
5
6
//...
String e = "Hola";
for (int i = 0; i < 100; i++) {
e += " mundo";
}
//...
En este caso el cdigo generado ser el siguiente:
1
2
3
4
5
6
//...
String e = "Hola";
for (int i = 0; i < 100; i++){
e = (new StringBuilder()).append(e).append("
mundo").toString();
}
//...
Por lo tanto cada nueva iteracin del bucle lleva aparejado la
creacin de un StringBuilder para agregarles las cadenas y
asignrselo a la variable e
Lo que se puede realizar es crear un StringBuilder e irlo asignando
en cada iteracin, de la forma:
1
2
3
4
5
6
7
//...
StringBuilder sb = new StringBuilder("Hola");
for (int i = 0; i < 100; i++) {
sb.append(" mundo");
}
String e = sb.toString();
//...
Entonces la ejecucin se resume a:
- crear una instancia de StringBuilder con el texto inicial (Hola)
le agregar la cadena mundo una vez por cada bucle
obtendr la cadena resultante
asignar la cadena resultante a la variable e
Como pudimos ver en un post anterior la principal ventaja es la
gran cantidad de tiempo ganado durante la ejecucin.
Conclusin
Como pudimos ver a lo largo de estos casos es que es importante
saber como el compilador hace las cosas para de esa forma poder
preocuparnos ms en el diseo/mantenimiento de nuestras
aplicaciones a estar optimizando cdigo que optimizara el
compilador y que visualmente es difcil de comprender.
Si es eficiente y bello, no se puede pedir ms.
Concatenar cadenas en Java
25 junio 2011
Buenas a todos!
Hoy os voy a haces un ejemplo de cmo concatenar variables en Java, os presentar dos formas
para poder hacerlo: el funcin tradicional ( mediante smbolos de conjuncin) o mediante la funcin
concat.
El smbolo de conjuncin de strings en Java es +, mediante l podremos concatenar cadenas de
caracteres.
public static void main(String[] args) {
String var1= new String("Hola");
String var2= new String("mundo");
String cadena1= var1 + " "+ var2;
JOptionPane.showMessageDialog( null, cadena1);
}
El la funcin Concat hace lo mismo que el smbolo.
public static void main(String[] args) {
String var2= new String("mundo");
String var3=new String("Adios ");
String cadena2= var3.concat(var2);
JOptionPane.showMessageDialog( null, cadena2);
}