- valueOf - convierte a la clase Wrapper
- parseInt - convierte a tipo primitivo
Integer.parseInt acepta solo String y devuelve el tipo entero primitivo (int).
public static int parseInt(String s) throws NumberFormatException {
return parseInt(s,10);
}
Iteger.valueOf accept int y String. Si el valor es String, valueOf lo convierte al int simple usando parseInt y devuelve un nuevo entero si la entrada es menor que -128 o mayor que 127. Si la entrada está en el rango (-128-127) siempre devuelve los objetos Integer de un IntegerCache interno. La clase entera mantiene una clase IntegerCache estática interna que actúa como caché y contiene objetos enteros de -128 a 127 y es por eso que cuando intentamos obtener un objeto entero para 127 (por ejemplo) siempre obtenemos el mismo objeto.
Iteger.valueOf(200)
dará un nuevo número entero de 200. Es como new Integer(200)
Iteger.valueOf(127)
es lo mismo que Integer = 127
;
Si no va a convertir String al uso Integer Iteger.valueOf
.
Si no puede convertir String al simple int use Integer.parseInt
. Funciona mas rapido.
public static Integer valueOf(int i) {
if (i >= IntegerCache.low && i <= IntegerCache.high)
return IntegerCache.cache[i + (-IntegerCache.low)];
return new Integer(i);
}
public static Integer valueOf(String s) throws NumberFormatException {
return Integer.valueOf(parseInt(s, 10));
}
private static class IntegerCache {
static final int low = -128;
static final int high;
static final Integer cache[];
static {
// high value may be configured by property
int h = 127;
String integerCacheHighPropValue =
sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high");
if (integerCacheHighPropValue != null) {
try {
int i = parseInt(integerCacheHighPropValue);
i = Math.max(i, 127);
// Maximum array size is Integer.MAX_VALUE
h = Math.min(i, Integer.MAX_VALUE - (-low) -1);
} catch( NumberFormatException nfe) {
// If the property cannot be parsed into an int, ignore it.
}
}
high = h;
cache = new Integer[(high - low) + 1];
int j = low;
for(int k = 0; k < cache.length; k++)
cache[k] = new Integer(j++);
// range [-128, 127] must be interned (JLS7 5.1.7)
assert IntegerCache.high >= 127;
}
private IntegerCache() {}
}
Y comparando Integer.valueOf (127) == Integer.valueOf (127) devuelve verdadero
Integer a = 127; // Compiler converts this line to Integer a = Integer.valueOf(127);
Integer b = 127; // Compiler converts this line to Integer b = Integer.valueOf(127);
a == b; // return true
Porque toma los objetos Integer con las mismas referencias del caché.
Pero Integer.valueOf (128) == Integer.valueOf (128) es falso, porque 128 está fuera del rango IntegerCache y devuelve un nuevo Integer, por lo que los objetos tendrán referencias diferentes.