Optimización local

Ver [4]: Las optimizaciones locales se realizan sobre un bloque básico. Algunos
ejemplos de optimización local son:
Folding
Propagación de constantes
Reducción de subexpresiones comunes

Folding o ensamblamiento
El ensamblamiento es remplazar las expresiones por su resultado cuando se pueden
evaluar en tiempo de compilación (resultado constante).
Ejemplo:
A = 2+3+A+C A = 5 +A+C

Propagación de constantes
Desde que se asigna a una variable un valor constante hasta la siguiente asignación,
se considera a la variable equivalente a la constante.

PI = 3.14 PI = 3.14 PI = 3.14

G2R = PI/180 G2R = 3.14/180 G2R = 0.017

PI y G2R se consideran constantes hasta la próxima asignación.

Reutilización de expresiones comunes

Ante instrucciones b + c, sustituir por a y ante instrucciones a – d, sustituir por d.
a=b+
cd=a-
de=b
+cf=a
-d

a=b+
cd=a-
de=a
f=d
 Algunos otros ejemplos de optimización en Java

Concatenación de series Java

Ver [2]: El operador + implica la creación de un objeto String nuevo para cada
concatenación; por ejemplo:

keyforCache = hostSystem + CommonFunctions.separator + UN OBJETO EXTRA STRING

+ sourceQueueValue + CommonFunctions.separator + DOS OBJETOS EXTRA STRING

+ smiKey + CommonFunctions.separator + DOS OBJETOS EXTRA STRING
+ newElement; + UN OBJETO EXTRA STRING

Para mejorar el rendimiento, se puede utilizar la clase StringBuffer y el método append

para concatenar los objetos java.lang.String, en lugar del operador +, tal como se
muestra en el ejemplo siguiente:

StringBuffer keyforCacheBuf = new StringBuffer(); SOLO SE CREA UN OBJETO

keyforCacheBuf.append(hostSystem);
keyforCacheBuf.append(CommonFunctions.separator);
keyforCacheBuf.append(sourceQueueValue);
keyforCacheBuf.append(CommonFunctions.separator);
keyforCacheBuf.append(smiKey);
keyforCacheBuf.append(CommonFunctions.separator);
keyforCacheBuf.append(newElement);
keyforCache = keyforCacheBuf.toString();

Reutilización de variables
Ver [3]: Si vemos que hemos dejado de utilizar una variable en particular, hay que
reutilizarla, siempre y cuando no afecte el código donde la usamos originalmente. Por
ejemplo, en vez de usar esto:

1. i=0; DECLARAR UNA VARIABLE AQUÍ

2. while(i<10)
3. {
4. echo 'Hola mundo';
5. i++; Y USARLA AQUÍ
6. }
7.
8. j=0; DECLARAR OTRA VARIABLE AQUÍ
9. while(j<10)
10. {
11. echo 'Adios!';
12. j++; Y USARLA AQUÍ
13. }
Utiliza primitivas donde sea posible
Ver [1]: Otra manera rápida y fácil de evitar cualquier sobrecarga y mejorar el
rendimiento de su aplicación es utilizar tipos primitivos en lugar de sus clases
contenedoras. Por ejemplo, utilizar un int en lugar de un Integer. Eso permite que su
máquina virtual en Java almacene el valor en la pila en lugar del almacenamiento
dinámico para reducir el consumo de memoria y, en general, manejarlo de manera
más eficiente.

Tratar de evitar BigInteger y BigDecimal

Ver [1]: BigInteger y BigDecimal son populares debido a su precisión, sin embargo,
requieren mucha más memoria que un simple largo o doble y ralentizan todos los
cálculos de manera espectacular. Entonces, mejor se debe pensar dos veces si se
necesita la precisión adicional.

Muchas veces esto podría ser lo único que se necesita cambiar para solucionar los
problemas que se estén presentando de rendimiento, especialmente si está
implementando un algoritmo matemático.

Por ejemplo, calcularemos el factorial de 1000 utilizando BigInteger:

1. package com.arquitectura;
2.
3. import java.math.BigInteger;
4.
5. public class CalcularFactorial2 {
6.
7. public static void main(String[] args) {
8.
9. System.out.println(factorial(new BigInteger("1000")));
10.
11. }
12. static BigInteger factorial(BigInteger n)
13. {
14. if (n.equals(BigInteger.ZERO))
15. return BigInteger.ONE;
16. else
17. return n.multiply(factorial(n.subtract(BigInteger.ONE)));
18. }
19. }
En el codigo anterior hemos creado un objeto de tipo BigInteger y hemos usado los
métodos que tiene (multiply) para realizar las operaciones que necesitamos. Una vez
procesado el resultado será el siguiente:

Como se puede observar es un número muy grande.

Consejos para hacer más eficiente la programación

Respetar las convenciones de java

Ver [7]: Las convenciones de código son importantes para los programadores por un
gran número de razones:

El 80% del coste del código de un programa va a su mantenimiento.

Las convenciones de código mejoran la lectura del software, permitiendo

entender código nuevo mucho más rápidamente y más a fondo.
Si distribuyes tu código fuente como un producto, necesitas asegurarte de que
está bien hecho y presentado como cualquier otro producto.

Por lo tanto, para que tu código sea eficiente debe respetar las convenciones y para
que funcionen las convenciones, cada persona que escribe software debe seguir la
convención.

Sustituir concatenación de Strings por StringBuffer

Ver [8]: La concatenación de Strings mediante el operador “+” o el método concat es
una operación costosa en tiempo de ejecución, pues se realiza la copia de los Strings
en memoria, requiriendo el doble de tamaño del String original. En lugar de ello, es
mejor utilizar la clase StringBuffer y su método “append”, que son más eficientes.

Usar “new” sólo cuando sea necesario

Ver [8]: Utilizar la palabra clave “new” cuando se instancia una clase reserva el espacio
de memoria mínimo necesario para contener el objeto instanciado. Si ese objeto,
debido a la ejecución del código posterior, no llega nunca a utilizarse, se ha consumido
espacio de memoria sin ser realmente necesario.

Evitar la creación de objetos temporales innecesarios

Ver [8]: La creación de estos objetos consume recursos, y adicionalmente añaden más
trabajo de limpieza para el Garbage Collector.