java - parse - Diferencias entre el nuevo Integer(123), Integer.valueOf(123) y solo 123

parsestring java

Question

Recien visto código (Java) como este:

myMethod(new Integer(123));

Actualmente estoy refactorizando un código, y hay una sugerencia en la herramienta Sonar, que es más amigable con la memoria para usar algo como esto:

myMethod(Integer.valueOf(123));

Sin embargo, en este caso, creo que no hay ninguna diferencia si quisiera usar:

myMethod(123);

Podría entender eso, si pasara una variable al método, pero con código int. O si hubiera Long / Double, etc. y quiero una representación larga de número. Pero el entero?

Answer 1

public static Integer valueOf(int i)

Devuelve una instancia de Integer que representa el valor int especificado. Si no se requiere una nueva instancia de Integer, este método generalmente se debe usar con preferencia al constructor Integer (int), ya que es probable que este método produzca un rendimiento de tiempo y espacio significativamente mejor al almacenar en caché los valores solicitados con frecuencia.

Parámetros:
i - un valor int.
Devoluciones:
a instancia entera que representa i .
Ya que:
1.5

consulte javadoc

Esta variante de valueOf se agregó en JDK 5 a Byte, Short, Integer y Long (ya existía en el caso trivial en Boolean desde JDK 1.4). Todos estos son, por supuesto, objetos inmutables en Java. Solía ​​ser que si necesitabas un objeto Integer de un int, construirías un nuevo Integer. Pero en JDK 5+, realmente debería usar valueOf porque Integer ahora almacena en caché objetos Integer entre -128 y 127 y puede devolverle el mismo objeto Integer (0) cada vez en lugar de perder la construcción de un objeto en un objeto Integer idéntico completamente nuevo. .

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[i] = new Integer(i - 128);
}
}

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

Consulte por qué USTED debe usar Integer.valueOf (int)

EDITAR

Autoboxing y creación de objetos:

El punto importante que debemos considerar es que el autoboxing no reduce la creación de objetos, pero reduce la complejidad del código. Una buena regla general es utilizar tipos primitivos donde no se necesitan objetos, por dos razones:

Los tipos primitivos no serán más lentos que sus correspondientes tipos de envoltorios, y pueden ser mucho más rápidos. Puede haber algún comportamiento inesperado que implique == (comparar referencias) y .equals () (comparar valores).

Normalmente, cuando los tipos primitivos se encajonan en los tipos de envoltorio, la JVM asigna memoria y crea un nuevo objeto. Pero para algunos casos especiales, la JVM reutiliza el mismo objeto.

La siguiente es la lista de primitivas almacenadas como objetos inmutables:

• valores booleanos verdaderos y falsos

• Todos los valores de bytes

• valores cortos entre -128 y 127

• valores int entre -128 y 127

• char en el rango / u0000 a / u007F

consulte http://today.java.net/pub/a/today/2005/03/24/autoboxing.html#performance_issue

Answer 2

¿Su método requiere un int o un Integer ?

new Integer(int) y Integer.valueOf(int) devuelven objetos Integer , pero se debe preferir valueOf ya que es más eficiente porque devuelve objetos almacenados en caché. Si su método requiere un Integer , debe usar Integer.valueOf .

Si su método requiere un int , debe usar un int (por ejemplo, 123 ).

Sin embargo, no es estrictamente necesario hacer coincidir los tipos de esta manera debido al AutoBoxing , que convierte automáticamente un int en un Integer y viceversa cuando los tipos no coinciden. Esto le permite pasar un int a un método que requiere un Integer y un Integer a un método que requiere un int . Pero tenga en cuenta que hay costos de rendimiento asociados con el autoboxing. El ejemplo más común de cuándo usaría el autoboxing es si desea almacenar primitivos en una colección.

Answer 3

int es un tipo primitivo, no un objeto.

new Integer(123) y Integer.valueOf(123) devuelven el objeto Integer que representa el valor 123. Según javadoc para Integer.valueOf() :

Devuelve una instancia de Integer que representa el valor int especificado. Si no se requiere una nueva instancia de Integer, este método generalmente se debe usar con preferencia al constructor Integer (int), ya que es probable que este método produzca un rendimiento de tiempo y espacio significativamente mejor al almacenar en caché los valores solicitados con frecuencia.

Answer 4

solo rango de -128 a +127 implementos en caché.

Integer a = new Integer(1);
 Integer b = new Integer(1);

 System.out.println("a==b? " + (a==b));

 Integer c = Integer.valueOf(127);
 Integer d = Integer.valueOf(127);

 System.out.println("c==d? " + (c==d)); 

 Integer e = Integer.valueOf(128);
 Integer f = Integer.valueOf(128);

 System.out.println("e==f? " + (e==f)); 

Consulte esta especificación de java:

http://java.sun.com/docs/books/jls/third_edition/html/conversions.html#5.1.7

en JDK 5+, realmente debería usar valueOf porque Integer ahora almacena en caché objetos Integer entre -128 y 127 y puede devolverle el mismo objeto Integer (0) cada vez en lugar de desperdiciar una construcción de objeto en un objeto Integer idéntico completamente nuevo.

Answer 5

new Integer(123) creará una nueva instancia de Object para cada llamada.

De acuerdo con el javadoc , Integer.valueOf(123) tiene la diferencia de que almacena en caché los objetos ... por lo que puede (o no) terminar con el mismo Object si lo llama más de una vez.

Por ejemplo, el siguiente código:

   public static void main(String[] args) {

        Integer a = new Integer(1);
        Integer b = new Integer(1);

        System.out.println("a==b? " + (a==b));

        Integer c = Integer.valueOf(1);
        Integer d = Integer.valueOf(1);

        System.out.println("c==d? " + (c==d));

    }

Tiene la siguiente salida:

a==b? false
c==d? true

En cuanto al uso del valor int , está usando el tipo primitivo (considerando que su método también usa el tipo primitivo en su firma): usará un poco menos de memoria y podría ser más rápido, pero no estará aliado para agregarlo a las colecciones , por ejemplo.

También eche un vistazo a AutoBoxing de Java si la firma de su método usa Integer : cuando lo use, la JVM llamará automáticamente a Integer.valueOf() por lo tanto, también usará el caché).