Test 1:
Regardons d'abord un ensemble de comparaisons de type de chaînes. Sans plus tarder, entrez simplement le code:
Test de classe publique {public static void main (String [] args) {String a = "java book jardin"; String b = "Java Book Garden"; String c = new String ("Java Book Garden"); String d = new String ("Java Book Garden"). Intern (); if (a == b) {System.out.println ("a == b"); } else {System.out.println ("A! = B"); } if (a.equals (b)) {System.out.println ("a.equals (b)"); } else {System.out.println ("! A.equals (b)"); } if (a == c) {System.out.println ("a == c"); } else {System.out.println ("A! = C"); } if (a.equals (c)) {System.out.println ("a.equals (c)"); } else {System.out.println ("! A.equals (c)"); } if (a == d) {System.out.println ("a == d"); } else {System.out.println ("A! = D"); } if (a.equals (d)) {System.out.println ("a.equals (d)"); } else {System.out.println ("a.equals (d)"); }}}Résultat de sortie:
a == ba.equals (b) a! = ca.equals (c) a == da.equals (d)
Résumer:
Résultat A == B: Lorsque le programme est en cours d'exécution, il créera un pool de tampon de chaîne. Lorsque String A = "Java Book Garden", "Java Book Garden" est placé dans la piscine de tampon à cordes. Lorsque String B = "Java Book Garden" crée une chaîne, le programme recherchera d'abord des objets avec la même valeur dans cette piscine tampon de chaîne. Par conséquent, lorsque B est créé, le programme trouve A avec la même valeur et fait référence à l'objet référencé par a. Par conséquent, A et B se réfèrent au même objet, donc a == b.
En conséquence, A! = C: String c = new String ("Java Book Garden") Nouveau un nouvel objet, il n'est donc pas recherché à partir du pool de tampon de chaîne, et crée directement un nouvel objet. Donc a! = C.
Résultat A == D: Lorsque la méthode interne est appelée, si le pool contient déjà une chaîne égale à cet objet de chaîne (l'objet est déterminé par la méthode equals (objet)), la chaîne dans le pool est renvoyée. Sinon, ajoutez cet objet String au pool et renvoie une référence à cet objet String. Tous D appelle les objets de a.
égal à compare les valeurs, donc lorsque les valeurs sont les mêmes, elles sont égales.
Test 2:
Voici un test d'un ensemble de types int et de types entiers:
Classe publique Test {public static void main (String [] args) {int a = 127; int a1 = 127; int b = 128; entier c = 127; Entier C1 = 127; Entier d = 128; Entier d1 = 128; if (a == a1) {System.out.println ("a == a1"); } else {System.out.println ("a! = a1"); } if (b == b1) {System.out.println ("b == b1"); } else {System.out.println ("B! = B1"); } if (c == c1) {System.out.println ("C == C1"); } else {System.out.println ("C! = C1"); } if (d == d1) {System.out.println ("d == d1"); } else {System.out.println ("d! = d1"); }}}Résultat de sortie:
a == a1b == b1c == C1d! = d1
Le résultat "A == A1" et "B == B1": Int sont des types de base, et les valeurs sont stockées directement, tandis que Integer est un objet, et pointe vers cet objet avec une référence. La plupart des comparaisons sont faites de "a == a1" et "b == b1".
Les résultats "C == C1" et "D! = D1" peuvent avoir des questions ici, pourquoi "D! = D1". Jetons un coup d'œil au code source d'Enteger ensemble.
/ ** * Cache pour soutenir la sémantique d'identité d'objet de l'autoboxing pour les valeurs entre * -128 et 127 (inclusives) comme requis par JLS. * * Le cache est initialisé lors de la première utilisation. La taille du cache * peut être contrôlée par l'option -xx: autoboxcacheMax = <Size>. * Pendant l'initialisation VM, java.lang.integer.integercache.high Property * peut être défini et enregistré dans les propriétés du système privé dans la classe * Sun.Misc.vm. * / classe statique privée IntegerCache {statique final int low = -128; statique final int high; Cache entier final statique []; statique {// La valeur élevée peut être configurée par la propriété int h = 127; String IntegerCacheHighPropValue = Sun.Misc.vm.GetsAvedProperty ("Java.lang.integer.integerCache.high"); if (IntegerCacheHighPropValue! = null) {int i = paSeInt (IntegerCacheHighPropValue); i = math.max (i, 127); // La taille maximale du tableau est Integer.max_value h = math.min (i, Integer.max_value - (-low) -1); } high = h; cache = nouvel entier [(élevé - bas) + 1]; int j = bas; pour (int k = 0; k <cache.length; k ++) cache [k] = nouveau entier (j ++); } private IntegerCache () {}} / ** * Renvoie une instance {@code entier} représentant la valeur spécifiée * {@code int}. Si une nouvelle instance {@code Integer} n'est pas * requise, cette méthode doit généralement être utilisée en préférence pour * le constructeur {@Link #Integer (int)}, car cette méthode est probablement * pour donner des performances d'espace et de temps significativement meilleures par * les valeurs fréquemment demandées fréquemment. * * Cette méthode mettra toujours en cache les valeurs dans la plage -128 à 127, * inclusive, et peut mettre en cache d'autres valeurs en dehors de cette plage. * * @param I une valeur {@code int}. * @return une instance {@code entier} représentant {@code i}. * @Since 1.5 * / public static entier statique Valeur (int i) {Assert IntegerCache.high> = 127; if (i> = IntegerCache.low && i <= IntegerCache.high) return IntegerCache.cache [i + (-IntegerCache.low)]; retourner un nouvel entier (i); }CONCLUSION: Ici INTEGER INITIALISERA UN POOL CONSTANT de [-128,127]. Si la valeur est dans cette plage, le même objet est référencé. Si ce n'est pas dans cette plage, il peut être vu à partir du code source que le nouvel objet renvoyé est: Renvoie un nouvel entier (i);
Par conséquent, le résultat "C == C1" fait référence au même objet, et le résultat "D! = D1" fait référence à un nouvel objet d'un nouvel objet, il est donc différent.