Utilisant l'opérateur == en Java pour comparer wrapper objets

Je suis en train de lire SCJP Java 6 par Kathy Sierra et Bert Bates et ce livre est déroutant moi. Sur la page 245 ils affirment que le code suivant ci-dessous.

Integer i1 = 1000;
Integer i2 = 1000;
if(i1 != i2)
System.out.println("different objects");

//Prints output
different objects

Puis sur la page suivante, ils ont le code suivant

Integer i3 = 10;
Integer i4 = 10;
if(i3 == i4)
System.out.println("same objects");

//Prints output
same objects

Je suis tellement confus! Quand je l'ai essayer sur mon propre il semble que vous ne pouvez pas utiliser l' == pour comparer de la même manière que vous le feriez utiliser la méthode equals (). À l'aide de l' == me donne toujours la valeur 'false', même si les variables entières sont réglés à la même valeur (p. 10). Suis-je la corriger? À l'aide de l' == pour comparer le même objet Integer (avec les mêmes valeurs) entraînera toujours "faux"

InformationsquelleAutor dido | 2012-04-14
  1. 60

    La clé de la réponse est appelé objet un stage. Java stagiaires petit nombre (moins de 128), de sorte que toutes les instances de Integer(n) avec n dans les internés de la gamme sont les mêmes. Les nombres plus grand que ou égal à 128 ne sont pas internés, d'où Integer(1000) objets ne sont pas égaux les uns aux autres.

    • Wow! Je n'ai vu que trop. Pourquoi?? C'est donc à confusion. Quel est le raisonnement derrière cela?
    • notez que seuls les objets obtenus à partir de littéraux, l'autoboxing et Integer.valueOf() sont internés des objets, tandis que ceux construits avec new Integer sont toujours des objets distincts
    • Je crois me souvenir que vaut aussi pour les petites Chaînes, mais je ne suis pas sûr de savoir si c'est vrai et si oui, ce qui est considéré comme une petite Chaîne. Savez-vous quelque chose à ce sujet?
    • Non, cela n'a rien à voir avec la taille. Constantes de chaîne sont internés et vous pouvez appeler intern sur votre chaîne de variables pour le même effet, c'est tout. Et la raison est simple: Nous avons besoin de stocker des constantes de chaîne, quelque part, de toute façon, et pour les petits entiers, c'est juste une performance/optimisation de la mémoire
    • L'une des raisons derrière un stage nombres entiers est une tentative pour économiser de la mémoire et, dans une certaine mesure - pour gagner du temps ainsi. Lorsque Integer objets sont utilisés comme clés de hachage des cartes ou des objets dans les jeux de hachage, le pourcentage de petits nombres est disproportionnée grande. En s'y consacrant à eux, vous pouvez ignorer la ré-allocation de la mémoire pour stocker des copies identiques des objets immuables qui sont égaux les uns aux autres, et de laisser l'égalité de comparer finir plus vite par la vérification de référence de l'égalité d'abord. Le meilleur de tous, elle ne vous coûte rien en termes de cycles de CPU, donc c'était une décision facile à prendre.
    • Java n'est pas un stage de petits nombres. Integer lui-même est en train de faire l'objet de mise en commun.
    • Vous avez raison, j'ai utilisé le terme vaguement à signifier à la fois la langue et de ses bibliothèques, spécifiquement java.lang.Entier. Les deux sont plus ou moins inséparables (par exemple, un compilateur Java "sait" comment la boîte int constantes Integers) donc je pense que cette utilisation est justifiée.
    • J'ai vu des cas où ce stage a causé une grave dégradation des performances. J'ai été de créer un grand nombre d'Entiers dans une boucle serrée, et l'instanciation coût n'est pas négligeable.
    • Comme toute technique d'optimisation, un stage manuellement peut aller mal. Il y a une différence de coût entre le faire manuellement à beaucoup d'entiers dans une boucle serrée, et de le faire à l'avance pour un petit nombre d'entiers.
    • java n'a pas de stagiaire en Entier de façon dynamique, les internés des valeurs entières sont allouées au démarrage. Il ne fait un test de portée (valeur < internedValues.la longueur)lorsque l'autoboxing int.
    • Si je me souviens correctement, il vérifie également dans le Integer.valueOf méthode.
    • c'est la plage de vérifier que je voulais, après tout l'autoboxing est effectuée à l'aide de valueOf. avec seulement j'ai voulu reportez-vous à la surcharge n'étant qu'un contrôle de portée (pas un locuteur natif anglais).

    InformationsquelleAutor dasblinkenlight
  2. 17

    Si vous regardez le code source de Integer vous verrez que Integer.valueOf(int) piscines toutes les valeurs de -128 à 127. La raison en est que les petites valeurs entières sont utilisés fréquemment et sont donc digne d'être mis en commun dans le cache.

    Pris directement à partir de Integer.java:

    public static Integer valueOf(int i) {
    if(i >= -128 && i <= IntegerCache.high)
        return IntegerCache.cache[i + 128];
    else
        return new Integer(i);
}

    Noter que cette mise en commun est mise en œuvre spécifique et il n'y a aucune garantie de la mise en commun de gamme.

    Les réponses à propos de stage sont corrects dans le concept, mais incorrecte avec la terminologie. Stage en Java implique normalement que le Java runtime est d'effectuer la mise en commun (tels que la Chaîne du stagiaire). Dans Integer cas, c'est la classe elle-même qui est en train de faire la mise en commun. Il n'y a pas de JVM quelque chose de magique.

    • En fait, la mise en cache de Integer objets pour int valeurs dans l'intervalle [-128, 127] est spécifié dans l'API docs, de sorte qu'une partie de la plage est, en fait, c'est garanti.
    InformationsquelleAutor Steve Kuo
  3. 7

    La réponse ci-dessus à propos de Stage est à droite sur. Quelque chose à considérer si vous ne:

    Integer i3 = new Integer(10);
Integer i4 = new Integer(10);

    Vous n'aurez pas les nouveaux objets puisque vous avez créé de nouveaux objets explicitement. Si vous écrivez le code comme suit, il sera interné:

    Integer i3 = Integer.valueOf(10);
Integer i4 = Integer.valueOf(10);

    Ils seront désormais les mêmes l'objet de nouveau. Si vous jetez un oeil à la Méthode valueOf à l'intérieur de la Integer.java classe dans le src.zip fichier, vous pouvez voir où il vérifie si la valeur de l'int est à l'extérieur de -128 à 127, il appelle la nouvelle classe Integer sinon il se charge dans la mémoire cache.

    InformationsquelleAutor haskovec
  4. 2
    Integer i1 = 1000;
Integer i2 = 1000;

    Le compilateur "boîtes" de l'int 1000 comme objet Integer. Pour ce faire, il convertit la source à la suivante:

    Integer i1 = Integer.valueOf(1000);
Integer i2 = Integer.valueOf(1000);

    Maintenant valueOf pourrait être un simple appel à new Integer(1000) toutefois la création d'un nouvel objet Integer chaque fois qu'un int est en boîte coûterait à la fois du temps et de l'espace. Pour éviter cela, la classe Integer conserve un tableau d'Entiers à des objets destinés à un nombre limité de valeurs int. 

    if(value> maxRange || value< minRange){
     //not in pool return new Integer
     return new Integer(value);
}else{
     //return pooled Integer object
     //for the value, pool contains all Integer
     //values from minRange to maxRange
     return integerPool[value-minRange];
}

    La vitesse acquise contre le souvenir perdu de ce qui peut être ajusté par le réglage de la portée avec un argument jvm au démarrage du programme (autant que je sache, la valeur par défaut est de -127 à 128).

    InformationsquelleAutor josefx
  5. 0

    Lorsque le Java opérateur == est utilisé pour comparer quoi que ce soit d'autre que les types primitifs, il vérifie référentielle de l'égalité; cela s'applique même lorsque les choses comparés sont enveloppés primitives. De plus, le valueOf méthode et généré par le compilateur l'autoboxing déclaration sont généralement gratuits, de façon arbitraire, de retour d'un nouvel objet qui ne sera pas de référence à l'égal des autres déjà existantes de référence, ou pour renvoyer une référence à un objet existant (ce qui serait, bien sûr, être de référence égale à tous les pré-existantes référence permettant d'identifier le même objet). Les implémentations sont nécessaires pour maintenir un "pool" de Integer cas pour les valeurs de -128 à 127, de telle sorte que tous les appels à Integer.valueOf sur un nombre dans la plage sera de retour références pour le même objet, mais autre que celui d'une mise en œuvre serait libre de faire quelque chose comme 

    static Integer [] intPool = new Integer[256];

public Integer valueOf(int n)
{
  int hash = (n*0x18675309) >>> 24;
  Integer instance = intPool[n];
  if (instance == null && instance.value != n)
  {
    instance = new Integer(n);
    intPool[hash] = instance ;
  }
  return instance;
}

    Je n'ai pas particulièrement d'attendre implémentations Java pour faire quelque chose comme ça, puisque dans de nombreux cas, le "cache" ratio pourrait être proche de 0% et le temps supplémentaire consacré à la recherche de cas dans le cache serait perdu. Néanmoins, il n'y a jamais aucune garantie qu'une référence retourné par instanceOf ne correspond pas certain de référence retourné par cette méthode (même si elle ne correspond pas à la dernier de référence retourné par cette méthode, certains algorithmes de mise en cache peut éventuellement provoquer le retour d'un plus tôt de référence, surtout si la piscine est partagée par plusieurs threads sans verrouillage. Le manque de verrouillage ne sera jamais la cause le code de retour rien d'autre qu'une référence à un entier avec la valeur correcte, mais peut causer des variations imprévisibles de la qui a renvoyé les références de comparer l'égalité). Seule référence à Integer les objets créés directement à l'aide du constructeur new Integer(n) sont garantis d'être unique, code, qui prévoit que toute référence retourné par valueOf à correspond pas à la référence retournée par valueOf, sans avoir réellement observé qu'il ne correspond pas, doit être considéré comme rompu.

    InformationsquelleAutor supercat
  6. 0

    Comparaison de chaîne et comparaison des entiers à l'aide de == et != donne boolean résultats pas que nous attendons.Soyez donc prudent et assurez-vous que les inconnues sont les résultats pour ne pas entraver la performance , de la fiabilité et de l'exactitude de votre logiciel.

    InformationsquelleAutor Antony Thomas Ramanattu
  7. 0

    "==" toujours comparer l'emplacement de la mémoire ou des références à des objets de valeurs.
    méthode equals de toujours comparer les valeurs.mais équivaut aussi, indirectement, utilise le "==" opérateur de comparer les valeurs. Entier Entier utilise le cache pour stocker les valeurs de -128 à +127.Si l'opérateur == est utilisé pour vérifier les valeurs entre -128 à 127 puis il retourne la valeur true. si une valeur comprise entre -128 à 127 comme 

    Integer i1 = -128; 
Integer i2 = -128; 
System.out.println(i1 == i2); //returns true

    autre que celle indiquée ci-dessus, puis elle retourne false

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

    Consultez le lien pour quelques informations supplémentaires

    InformationsquelleAutor vijay
  8. 0

    Selon jls-5.1.7 

    If the value p being boxed is true, false, a byte, or a char in the range \u0000 to \u007f,   
or an int or short number between -128 and 127 (inclusive), then let r1 and r2 
be the results of any two boxing conversions of p. It is always the case that r1 == r2.

    Donc, n'importe quel nombre entre -128 et 127 est mis en cache par le nombre Entier de la classe.

    Rappelez-vous, lors de la comparaison de deux objets toujours utiliser equals méthode.

    La mise en cache le code est écrit en IntegerCache classe qui est membre de Integer classe.

    Voici l'extrait de code:

     /**
 * Cache to support the object identity semantics of autoboxing for values between
 * -128 and 127 (inclusive) as required by JLS.
 *
 * The cache is initialized on first usage.  The size of the cache
 * may be controlled by the {@code -XX:AutoBoxCacheMax=<size>} option.
 * During VM initialization, java.lang.Integer.IntegerCache.high property
 * may be set and saved in the private system properties in the
 * sun.misc.VM class.
 */

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() {}
}

    Références

    InformationsquelleAutor Aniket Kulkarni