AOWS

Just another adrian’s weblog

Caché en las “wrapper classes” de Java

with one comment

Una wrapper class (o clase envoltorio) es una clase que contiene a un tipo primitivo. Cada tipo tiene su clase correspondiente: Byte (byte), Short (short), Integer (int), Long (long), Float (float), Double (double), Boolean (boolean) y Character (char). Utilizando estas clases (y sobre todo gracias al autoboxing) podemos trabajar con tipos primitivos como si de objetos se trataran, además por supuesto de añadir métodos de conversión y similares.

Estas clases incorporan un mecanismo de caché y tienen ya precargados algunos objetos en memoria. Por ejemplo, al arrancar la máquina virtual se crean 256 objetos de tipo Integer (que representan los valores entre -127 y 128) o 2 de tipo Boolean (true y false). Como muestra el código fuente de IntegerCache (en la clase Integer):

private static class IntegerCache {
    private IntegerCache() { }
    static final Integer cache[] = new Integer[-(-128) + 127 + 1];
    
    static {
        for(int i = 0; i < cache.length; i++)
            cache&#91;i&#93; = new Integer(i - 128);
    }
}
&#91;/sourcecode&#93;

Los objetos se crean en el inicializador estático y se usan en el método <code>valueOf</code>:


public static Integer valueOf(int i) {
    final int offset = 128;
    if (i >= -128 && i <= 127) { // must cache
        return IntegerCache.cache&#91;i + offset&#93;;
    }
    return new Integer(i);
}
&#91;/sourcecode&#93;

Conocer esta característica puede ser más que interesante pues evitaremos el crear objetos innecesariamente. Valga el siguiente código para ver cómo podemos sacarle partido:

&#91;sourcecode language="java"&#93;
Integer i1 = new Integer(1);
Integer i2 = 1;
Integer i3 = Integer.valueOf(1);
&#91;/sourcecode&#93;

Estas 3 formas de crear un objeto Integer que <em>contiene</em> al entero primitivo 1 son equivalentes. O mejor dicho, casi equivalentes, y es que la primera creará un objeto nuevo cada vez que la ejecutemos, mientras las otras dos harán uso de la caché como hemos visto anteriormente.


System.out.println( i1==i2 ); // false
System.out.println( i1==i3 ); // false
System.out.println( i2==i3 ); // true

Como vemos el operador == nos confirma que i2 e i3 son el mismo objeto. Sin embargo:

Integer i1 = 200;
Integer i2 = 200;
System.out.println( i1==i2 ); // false

Integer i3 = Integer.valueOf(200);
Integer i4 = Integer.valueOf(200);
System.out.println( i3==i4 ); // false

el valor 200 no está cacheado, por lo que se crean nuevas instancias de Integer.

Una buena práctica, por lo tanto, es crear estas clases envoltorio utilizando el método valueOf o asignando el literal para así evitar la creación de objetos extra.

Written by adrian

11 mayo, 2009 a 19:23

Publicado en Uncategorized

Tagged with

Una respuesta

Subscribe to comments with RSS.

  1. Kaludi was arrested by SOG with Mobile Sim card obtained using
    fake identity.


Responder

Introduce tus datos o haz clic en un icono para iniciar sesión:

Logo de WordPress.com

Estás comentando usando tu cuenta de WordPress.com. Cerrar sesión / Cambiar )

Imagen de Twitter

Estás comentando usando tu cuenta de Twitter. Cerrar sesión / Cambiar )

Foto de Facebook

Estás comentando usando tu cuenta de Facebook. Cerrar sesión / Cambiar )

Google+ photo

Estás comentando usando tu cuenta de Google+. Cerrar sesión / Cambiar )

Conectando a %s

A %d blogueros les gusta esto: