-
s = new String("xyz"); Combien d'objets String sont créés ? Deux objets, l'un est "xyx" et l'autre est l'objet de référence pointant vers "xyx".
String s="Hello";int i=3; s=i+s; Cette expression est-elle correcte ? En Java, le type de données ne correspond pas. Parce que la chaîne est une classe ! Approche correcte : s+="3" ou s+='3' ou s+=(char)i;
Nous allons présenter une autre façon de créer des objets String : du texte entre guillemets. Cette méthode est unique à String et elle est très différente de la nouvelle méthode.
Il existe un pool de chaînes dans la machine virtuelle JAVA (JVM), qui stocke de nombreux objets String et peut être partagé, ce qui améliore l'efficacité. String a="abc";, lorsque cette ligne de code est exécutée, la machine virtuelle JAVA recherche d'abord dans le pool de chaînes pour voir si un tel objet avec la valeur "abc" existe déjà. La base du jugement est la classe String égale (Objet). obj) La valeur de retour de la méthode. Si tel est le cas, aucun nouvel objet ne sera créé et une référence à l'objet existant sera renvoyée directement ; sinon, l'objet sera d'abord créé, puis ajouté au pool de chaînes, puis sa référence sera renvoyée.
Création d'objets chaîne : en raison de l'utilisation intensive d'objets chaîne [c'est un objet, d'une manière générale, les objets allouent toujours de la mémoire dans le tas], en Java, afin d'économiser de l'espace mémoire et du temps d'exécution [comme lors de la comparaison de chaînes, == est meilleur que égal à()], tous les littéraux de chaîne sont placés dans un pool de littéraux pendant la phase de compilation et le pool de littéraux d'exécution devient une partie du pool de constantes. L'avantage du pool littéral est que toutes les mêmes constantes de chaîne du pool sont fusionnées et n'occupent qu'un seul espace. Nous savons que pour deux variables de référence, utilisez == pour déterminer si leurs valeurs [références] sont égales, c'est-à-dire qu'elles pointent vers le même objet :
Regardez maintenant l'instruction String s = new String("abc"); Ici, "abc" lui-même est un objet dans le pool, et lorsque new String() est exécuté au moment de l'exécution, une copie de l'objet dans le pool est placée. dans le tas et remettez la référence de cet objet dans le tas à s. ok, cette instruction crée 2 objets String.
String s1 = new String("abc") ;String s2 = new String("abc") ;if( s1 == s2 ){ //Instruction qui ne sera pas exécutée}
//Combien d'objets chaîne ont été créés ? [Trois, un dans le pool et deux dans le tas. ]
Seuls les nouveaux objets générés par une connexion "+" entre des objets String créés à l'aide de guillemets pour inclure du texte seront ajoutés au pool de chaînes. Pour toutes les expressions de connexion "+" qui contiennent de nouveaux objets créés dans la nouvelle méthode (y compris null), les nouveaux objets qu'elles génèrent ne seront pas ajoutés au pool de chaînes.
1.== signifie qu'ils sont référencés à partir du même objet, et equals() signifie que les valeurs sont égales.
String str1 = "abc" ; l'objet référencé est sur la pile (ou le pool de chaînes).
String str1 =new String ("abc"); L'objet référencé est en mémoire/tas.
2.String str1 = "string" dans la pile
String str3 = "str" ;
String str4 = "ing" ;
String str2 = str3+str4; dans le tas, car la fonction du signe + est de renvoyer un autre objet String nouvellement créé au lieu de rechercher la valeur de chaîne sur la pile. Si c'est String str2 = "str"+"ing" alors le résultat final est sur la pile. str1==str2 est vrai.
Mais il y a une situation qui requiert notre attention. Veuillez regarder le code ci-dessous :
classe publique StringStaticTest {
public static final String A = "ab"; // constante A
public static final String B = "cd"; // constante B
public static void main (String[] arguments) {
String s = A + B; // Initialise s en connectant les deux constantes avec +
Chaîne t = "abcd" ;
si (s == t) {
System.out.println("s est égal à t, c'est le même objet");
} autre {
System.out.println("s n'est pas égal à t, ce n'est pas le même objet");
}
}
}
Le résultat de l'exécution de ce code est le suivant :
s est égal à t, c'est le même objet
La raison en est que dans l'exemple ci-dessus, A et B sont des constantes et leurs valeurs sont fixes, donc la valeur de s est également fixe et elle a été déterminée lors de la compilation de la classe. C'est-à-dire : String s=A+B; est équivalent à : String s="ab"+"cd";
Permettez-moi de modifier légèrement l'exemple ci-dessus et de voir ce qui se passe :
classe publique StringStaticTest {
chaîne finale statique publique A ; // constante A
chaîne finale statique publique B ; // constante B
statique {
A = « ab » ;
B = "cd" ;
}
public static void main (String[] arguments) {
// Initialise s en connectant les deux constantes avec +
Chaîne s = A + B ;
Chaîne t = "abcd" ;
si (s == t) {
System.out.println("s est égal à t, c'est le même objet");
} autre {
System.out.println("s n'est pas égal à t, ce n'est pas le même objet");
}
}
}
Le résultat de son opération est le suivant :
s n'est pas égal à t, ce n'est pas le même objet
Je viens de faire un petit changement, et le résultat est exactement le contraire de l'exemple de tout à l'heure. Analysons-le à nouveau. Bien que A et B soient définis comme des constantes (ne peuvent être affectées qu’une seule fois), elles ne sont pas affectées immédiatement. Avant que la valeur de s ne soit calculée, le moment où ils sont attribués et la valeur qui leur est attribuée sont toutes des variables. Par conséquent, A et B se comportent comme une variable avant de se voir attribuer une valeur. Ensuite, les s ne peuvent pas être déterminés au moment de la compilation, mais ne peuvent être créés qu'au moment de l'exécution.
Enfin, parlons du stockage des objets String dans la machine virtuelle JAVA (JVM) et de la relation entre le pool de chaînes et le tas et la pile. Examinons d'abord la différence entre tas et pile :
Pile : enregistre principalement les types de base (ou types intégrés) (char, byte, short, int, long, float, double, boolean) et les références d'objets peuvent être partagées, et leur vitesse est la deuxième plus rapide que celle d'enregistrement. tas.
Heap : utilisé pour stocker des objets.
Lorsque nous examinons le code source de la classe String, nous constaterons qu'elle possède un attribut value, qui stocke la valeur de l'objet String. Le type est char[], ce qui montre également qu'une chaîne est une séquence de caractères. Lors de l'exécution de String a="abc";, la machine virtuelle JAVA crée trois valeurs de caractères 'a', 'b' et 'c' dans la pile, puis crée un objet String dans le tas, sa valeur (value ) est un tableau de trois valeurs char qui vient d'être créée sur la pile {'a', 'b', 'c'} Enfin, l'objet String nouvellement créé sera ajouté au pool de chaînes.
Si nous exécutons ensuite le code String b=new String("abc"); puisque "abc" a été créé et enregistré dans le pool de chaînes, la machine virtuelle JAVA créera uniquement un nouvel objet String dans le tas, mais son value correspond aux trois valeurs de type char « a », « b » et « c » créées sur la pile lors de l'exécution de la ligne de code précédente.
À ce stade, nous sommes déjà assez clairs sur la question de savoir pourquoi String str=new String("abc") soulevée au début de cet article crée deux objets.
Cet article provient du blog CSDN Veuillez indiquer la source lors de la réimpression : http://blog.csdn.net/yakihappy/archive/2009/03/10/3977169.aspx.
Cet article provient du blog CSDN Veuillez indiquer la source lors de la réimpression : http://blog.csdn.net/Foxalien/archive/2009/12/18/5029470.aspx.
-