Java "égaux" et "==" similitudes
Tout d'abord, parlons brièvement de «égal» et «==»
== L'opération compare si les valeurs des deux variables sont égales pour le type de données de base.
Pour les variables de référence, cela signifie si les adresses stockées dans le tas sont les mêmes,
Le contenu de la pile est-il le même?
Si les deux variables représentées par l'opération égale sont des références au même objet,
Autrement dit, si le contenu dans le tas est le même.
En résumé, == compare les adresses de 2 objets, tandis que l'égalité compare le contenu de 2 objets.
Permettez-moi de présenter brièvement la classe String
La classe de chaîne est également appelée séquence de caractères immuables
String utilise la valeur de char finale privée [] pour réaliser le stockage des chaînes. C'est-à-dire que, une fois l'objet String créé, le contenu de chaîne stocké dans cet objet ne peut pas être modifié. La classe String a une méthode de création spéciale, qui est d'utiliser "" "Double Quotes pour le créer. Par exemple, la nouvelle chaîne ("123") crée en fait 2 objets de chaîne, l'un est créé par "123" à "" Double Quotes, et l'autre est créé par New. Cependant, les périodes qu'ils créent sont différentes, l'une est la période de compilation et l'autre est la période d'exécution. Java surcharge l'opérateur + pour le type de chaîne, et vous pouvez utiliser directement + pour concaténer deux chaînes. L'appel de la méthode inter () de la classe de chaîne pendant l'exécution peut ajouter dynamiquement des objets au pool de chaînes.
Différencier deux méthodes de création d'objets de chaîne "" et new ()
La chaîne est une données d'emballage spéciales. Peut être utilisé:
String str1 = new String ("123"); String str2 = "123";Créer deux formes
Le premier consiste à utiliser new () pour créer un nouvel objet, qui sera stocké dans le tas. Un nouvel objet est créé à chaque fois qu'il est appelé. (Il est en fait deux, comme mentionné ci-dessus, mais après l'existence de "123" dans la piscine constante, le nouveau "123" ne sera plus créé dans la piscine constante)
Le deuxième type consiste à créer d'abord une variable STR dans l'objet de la classe String dans la pile, puis à utiliser une référence symbolique pour savoir s'il y a "ABC" dans le pool constant de chaîne. Sinon, stockez "ABC" dans la piscine constante de chaîne et laissez STR pointer "ABC". S'il y a déjà "ABC", laissez directement Str vers "ABC".
Nous devons prêter attention à ce moment
D'une part, la première méthode d'écriture est bénéfique et enregistre l'espace mémoire. Dans le même temps, il peut améliorer la vitesse d'exécution du programme dans une certaine mesure, car le JVM décidera automatiquement s'il est nécessaire de créer un nouvel objet basé sur la situation réelle des données dans la pile. Pour le code de String str = New String ("123");, de nouveaux objets sont créés dans le tas, que les valeurs de chaîne soient égales ou non, s'il est nécessaire de créer de nouveaux objets, augmentant ainsi la charge du programme. D'un autre côté, lorsque nous définissons une classe en utilisant un format tel que String str = "123";, nous tenons toujours pour acquis que nous créons un objet STR de la classe String.
L'objet n'a peut-être pas été créé! Et peut-être simplement indiquer un objet qui a été créé précédemment. Ce n'est que via la nouvelle méthode () que nous pouvons nous assurer qu'un nouvel objet est créé à chaque fois.
Veuillez consulter l'exemple suivant
Package TestString; classe publique testString {public static void main (String [] args) {String a = "123"; String b = "123"; System.out.println (a == b); System.out.println (a.equals (b)); System.out.println("-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- And Le contenu des deux objets référencés dans le tas est le même, donc a.equals (b) est vrai * / chaîne c = nouvelle chaîne ("1234"); System.out.println("---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- But c is La même chose que d tas, donc c.equals (d) est vrai * / string e = "a1"; String f = "a" +1; System.out.println (E == F); System.out.println (E.Equals (F)); System.out.println ("------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- * Oui, Java elle-même a une surcharge de l'opérateur, mais vous ne pouvez pas utiliser la surcharge de l'opérateur qui se définit. String H = "G" + HH; System.out.println (G == H); System.out.println("---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Merci d'avoir lu, j'espère que cela peut vous aider. Merci pour votre soutien à ce site!