Résumé de l'analyse détaillée de la différence entre Integer et int en Java

Comme mentionné dans l'article ci-dessus, pourquoi les génériques Java utilisent-ils des objets au lieu de types primitifs ? Mais je ne comprends toujours pas très bien la différence entre Integer et int, alors je suis allé sur Baidu et j'ai trouvé un article écrit par un gars formidable, je l'ai trouvé plutôt bien, alors je l'ai republié et partagé.

La différence entre Integer et int

Integer est la classe d'encapsulation fournie par int, et int est le type de données de base de Java ; Integer est nul et la valeur par défaut de int est 0 ; les variables déclarées comme Integer doivent être instanciées, tandis que les variables déclarées comme int n'ont pas besoin d'être instanciées ; tandis que int est un type de base et stocke directement les valeurs.

En plus de connaître la différence la plus fondamentale entre Integer et int, vous devez également connaître d'autres problèmes rencontrés lors de l'utilisation réelle d'Integer et int.
Sinon, si l'intervieweur demande à nouveau si Integer i = 1; int ii = 1 ; On estime que certaines personnes ne seront pas en mesure d'y répondre. Si vous posez d'autres questions, on estime que davantage de personnes seront confuses. Je les ai donc résumés, en espérant que cela sera utile à tout le monde.
Le code est le suivant :

public class Main {
 
    public static void main(String[] args) {
 
        int a = 128;
        Integer b = 127;
        Integer c = 127;
        Integer d = 128;
        Integer e = 128;
        Integer f = new Integer("128");
        Integer g = new Integer("127");
        Integer h = new Integer("127");
 
 
        //方案一（）
        System.out.println("方案一：Integer与new Integer不同初始化方法的值的比较,Integer与new Integer不会相等");
        //Integer e = 128;
        //Integer f = new Integer("128");
        if (e == f){
            System.out.println("true");
        }else{
            System.out.println("false");
        }
        System.out.println("---------------------");
 
        //方案二
        System.out.println("方案二：创建两个都是直接赋值的Integer");
        //Integer b = 127;
        //Integer c = 127;
        if (b == c){
            System.out.println("true");
        }else{
            System.out.println("false");
        }
        //Integer d = 128;
        //Integer e = 128;
        if (d == e){
            System.out.println("true");
        }else{
            System.out.println("false");
        }
        System.out.println("---------------------");
 
        //方案三
        System.out.println("方案三：两个都是new出来的Integer");
        //Integer g = new Integer("127");
        //Integer h = new Integer("127");
        if (g == h){
            System.out.println("true");
        }else{
            System.out.println("false");
        }
        System.out.println("---------------------");
 
        //方案四
        System.out.println("方案四：int与Integer比较");
        //int a = 128;
        //Integer f = new Integer("128");
        if (a == f){
            System.out.println("true");
        }else{
            System.out.println("false");
        }
 
    }
}

Les résultats d'exécution sont les suivants :

方案一：Integer与new Integer不同初始化方法的值的比较,Integer与new Integer不会相等
false
---------------------
方案二：创建两个都是直接赋值的Integer
true
false
---------------------
方案三：两个都是new出来的Integer
false
---------------------
方案四：int与Integer比较
true

Le résumé est le suivant :

Option 1 :
Je vais d'abord analyser e et f Deux objets utilisent deux méthodes d'initialisation différentes, Integer et new Integer, pour comparer les deux objets

Integer e = 128;
Integer f = new Integer("128");
 
if (e == f){
    System.out.println("true");
}else{
    System.out.println("false");
}

Résultat renvoyé : false
Conclusion : Integer ; Ne sera pas égal au nouvel entier. La référence de e pointe vers le tas, tandis que f pointe vers la mémoire (pool constant) dédiée à son stockage. Leurs adresses mémoire sont différentes, donc fausses

Option 2 :
Créez les deux directement. L'Entier attribué compare les deux objets ;

//Integer b = 127;
//Integer c = 127;
if (b == c){
    System.out.println("true");
}else{
    System.out.println("false");
}
//Integer d = 128;
//Integer e = 128;
if (d == e){
    System.out.println("true");
}else{
    System.out.println("false");
}

renvoie le résultat :
vrai
faux
Conclusion : les deux sont directement attribués Entier, si le nombre est compris entre -. 128 et 127, c'est vrai, sinon c'est faux
Raison : Lorsque java compile Integer i2 = 128, il est traduit en -> Integer i2 = Integer.valueOf( 128); La fonction mettra en cache les nombres entre -128 et 127

Si vous regardez le code source, tout le monde comprendra que les nombres entre -128 et 127 seront mis en cache, Integer b = Quand 127, 127 sera mis en cache. La prochaine fois que Integer c = 127 sera écrit, il sera récupéré directement du cache et ne sera pas nouveau.

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

Troisième option :
J'utilise d'abord la nouvelle méthode d'initialisation Integer pour les deux objets g et h, puis je compare les deux objets

Integer g = new Integer("127");
Integer h = new Integer("127");
if (g == h){
    System.out.println("true");
}else{
    System.out.println("false");
}

Résultat renvoyé : false
Conclusion : Les deux sont de nouveaux objets Integer, pointant vers deux objets Integer différents, les deux sont faux

Option 4 :
J'utilise d'abord deux méthodes d'initialisation différentes, int et new Integer, pour les deux objets a et f, puis comparez les deux objets

int a = 128;
Integer f = new Integer("128");
if (a == f){
    System.out.println("true");
}else{
    System.out.println("false");
}

Résultat renvoyé : true
Conclusion : La comparaison entre int et integer (que ce soit new ou pas) est vrai, car Integer sera automatiquement déballé dans int puis comparé

Articles associés :

Tutoriel Java - la différence entre int et Integer

Explication détaillée de la différence entre int et Integer en Java

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!