web-dev-qa-db-fra.com

Différences entre les nouveaux Integer (123), Integer.valueOf (123) et seulement 123

Récemment, j'ai vu du code (Java) comme celui-ci:

myMethod(new Integer(123));

Je suis en train de refactoriser du code, et il y a une astuce dans l'outil Sonar, qu'il est plus convivial en mémoire d'utiliser qc comme ceci:

myMethod(Integer.valueOf(123));

Cependant dans ce cas, je pense qu'il n'y a pas de différence si j'utilise:

myMethod(123);

Je pourrais comprendre que, si je passais une variable à la méthode, mais codée en dur int? Ou s'il y aurait Long/Double etc et je veux une représentation longue du nombre. Mais entier?

javaintegernew-operatorvalue-of
28
MicNeo

new Integer(123) créera une nouvelle instance Object pour chaque appel.

Selon le javadoc , Integer.valueOf(123) a la différence qu'il met en cache des objets ... donc vous pouvez (ou non) vous retrouver avec le même Object si vous appelez plus d'une fois.

Par exemple, le code suivant:

   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));

    }

A la sortie suivante:

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

Quant à l'utilisation de la valeur int, vous utilisez le type primitif (étant donné que votre méthode utilise également le type primitif sur sa signature) - elle utilisera un peu moins de mémoire et pourrait être plus rapide, mais vous ne serez pas ale pour l'ajouter aux collections, par exemple.

Jetez également un œil à Java AutoBoxing si la signature de votre méthode utilise Integer- lors de son utilisation, la JVM appellera automatiquement Integer.valueOf() pour vous (donc en utilisant le cache également ).

33
Marcelo

public static Integer valueOf(int i)

Renvoie une instance de type Integer représentant la valeur int spécifiée. Si une nouvelle instance Integer n'est pas requise, cette méthode doit généralement être utilisée de préférence au constructeur Integer (int), car cette méthode est susceptible de produire des performances d'espace et de temps nettement meilleures en mettant en cache les valeurs fréquemment demandées.

Paramètres:
i - une valeur int.
Retour:
a Instance entière représentant i.
Puisque:
1,5

se référer http://docs.Oracle.com/javase/1.5.0/docs/api/Java/lang/Integer.html#valueOf%28int%29

Cette variante de valueOf a été ajoutée dans JDK 5 à Byte, Short, Integer et Long (elle existait déjà dans le cas trivial en booléen depuis JDK 1.4). Tous ces éléments sont, bien sûr, des objets immuables en Java. Autrefois, si vous aviez besoin d'un objet Integer à partir d'un entier, vous construirez un nouvel Integer. Mais dans JDK 5+, vous devez vraiment utiliser valueOf car Integer met désormais en cache des objets Integer entre -128 et 127 et peut vous rendre le même objet Integer (0) exact à chaque fois au lieu de gaspiller un construction d'objet sur un tout nouvel objet Integer identique. 

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);
}

refer Pourquoi VOUS devriez utiliser Integer.valueOf (int)

[~ # ~] modifier [~ # ~]

autoboxing et création d'objets:

Le point important que nous devons prendre en compte est que la mise en boîte automatique ne réduit pas la création d'objets, mais elle réduit la complexité du code. Une bonne règle d'or consiste à utiliser des types primitifs là où il n'y a pas besoin d'objets, pour deux raisons:

Les types primitifs ne seront pas plus lents que leurs types d'encapsuleurs correspondants, et peuvent être beaucoup plus rapides. Il peut y avoir un comportement inattendu impliquant == (comparer les références) et .equals () (comparer les valeurs).

Normalement, lorsque les types primitifs sont encadrés dans les types wrapper, la JVM alloue de la mémoire et crée un nouvel objet. Mais pour certains cas particuliers, la JVM réutilise le même objet.

Voici la liste des primitives stockées en tant qu'objets immuables:

  • valeurs booléennes vrai et faux

  • Toutes les valeurs d'octets

  • valeurs courtes entre -128 et 127

  • valeurs int entre -128 et 127

  • caractère compris entre\u0000 et\u007F

référez-vous http://today.Java.net/pub/a/today/2005/03/24/autoboxing.html#performance_issue

8
Hemant Metalia

Votre méthode nécessite-t-elle un int ou un Integer?

new Integer(int) et Integer.valueOf(int) renvoient tous les deux des objets Integer, mais valueOf devrait être préféré car il est plus efficace car il renvoie des objets mis en cache. Si votre méthode nécessite un Integer vous devez utiliser Integer.valueOf.

Si votre méthode nécessite un int, vous devez utiliser un int (par exemple 123).

Cependant, il n'est pas strictement nécessaire de faire correspondre les types de cette manière à cause de autoboxing , qui convertit automatiquement un int en Integer et vice versa lorsque les types ne sont pas ' t correspond. Cela vous permet de passer un int dans une méthode nécessitant un Integer, et un Integer dans une méthode nécessitant un int. Mais sachez qu'il y a des coûts de performance associés à l'autoboxing. L'exemple le plus courant de l'utilisation de la zone de sélection automatique est si vous souhaitez stocker des primitives dans une collection.

1
dogbane

uniquement entre -128 et +127 implémente dans le cache.

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));

Reportez-vous à cette spécification Java:

http://Java.Sun.com/docs/books/jls/third_edition/html/conversions.html#5.1.7

dans JDK 5+, vous devriez vraiment utiliser valueOf car Integer met désormais en cache les objets Integer entre -128 et 127 et peut vous rendre le même objet Integer (0) à chaque fois au lieu de gaspiller une construction d'objet sur un tout nouvel objet Integer identique.

1
Kushan

int est un type primitif, pas un objet.

new Integer(123) et Integer.valueOf(123) renvoient tous les deux Integer objet représentant la valeur 123. Selon javadoc pour Integer.valueOf():

Renvoie une instance de type Integer représentant la valeur int spécifiée. Si une nouvelle instance Integer n'est pas requise, cette méthode doit généralement être utilisée de préférence au constructeur Integer (int), car cette méthode est susceptible de produire des performances d'espace et de temps nettement meilleures en mettant en cache les valeurs fréquemment demandées.

1
Jan Zyka