Initialisation de chaîne en Java

1. Introduction

Java String est l'une des classes les plus importantes et nous avons déjà couvert beaucoup de ses aspects dans notre série de didacticiels liés à String .

Dans ce didacticiel, nous allons nous concentrer sur l' initialisation de chaîne en Java.

2. Création

Tout d'abord, nous devons nous rappeler comment les chaînes sont créées en Java.

Nous pouvons utiliser le nouveau mot-clé ou la syntaxe littérale:

String usingNew = new String("baeldung"); String usingLiteral = "baeldung";

Et, il est également important que nous comprenions comment les chaînes sont gérées dans un pool spécialisé.

3. Déclaration de chaîne uniquement

Tout d'abord, déclarons simplement une chaîne , sans affecter explicitement une valeur.

Nous pouvons le faire soit localement, soit en tant que variable membre:

public class StringInitialization { String fieldString; void printDeclaredOnlyString() { String localVarString; // System.out.println(localVarString); -> compilation error System.out.println(fieldString); } }

Comme nous pouvons le voir, si nous essayons d'utiliser localVarString avant de lui donner une valeur, nous obtiendrons une erreur de compilation. D'un autre côté, la console affichera « null» pour la valeur de fieldString .

Voir, les variables membres sont initialisées avec une valeur par défaut lorsque la classe est construite, null dans le cas de String . Mais nous devons initialiser nous-mêmes les variables locales.

Si nous donnons à localVarString une valeur nulle , nous verrons que les deux sont, en effet, maintenant égaux:

String localVarString = null; assertEquals(fieldString, localVarString);

4. Initialisation de chaîne à l' aide de littéraux

Créons maintenant deux String en utilisant le même littéral:

String literalOne = "Baeldung"; String literalTwo = "Baeldung";

Nous confirmerons qu'un seul objet est créé en comparant les références:

assertTrue(literalOne == literalTwo);

La raison en est que les String sont stockés dans un pool. literalOne ajoute la chaîne «baeldung» au pool et literalTwo la réutilise.

5. Initialisation de chaîne à l' aide de new

Nous verrons cependant un comportement différent si nous utilisons le nouveau mot-clé.

String newStringOne = new String("Baeldung"); String newStringTwo = new String("Baeldung");

Bien que la valeur des deux String soit la même que précédemment, nous aurons à différents objets cette fois:

assertFalse(newStringOne == newStringTwo);

6. Chaîne vide s

Créons maintenant trois chaînes vides :

String emptyLiteral = ""; String emptyNewString = new String(""); String emptyNewStringTwo = new String();

Comme nous le savons maintenant, le emptyLiteral sera ajouté au pool String , tandis que les deux autres iront directement sur le tas.

Bien que ce ne soient pas les mêmes objets, tous auront la même valeur:

assertFalse(emptyLiteral == emptyNewString) assertFalse(emptyLiteral == emptyNewStringTwo) assertFalse(emptyNewString == emptyNewStringTwo) assertEquals(emptyLiteral, emptyNewString); assertEquals(emptyNewString, emptyNewStringTwo);

7. Valeurs nulles

Enfin, voyons comment se comportent les chaînes null .

Déclarons et initialisons une chaîne nulle :

String nullValue = null;

Si nous imprimions nullValue , nous verrions le mot «null», comme nous l'avons vu précédemment. Et, si nous essayions d'appeler des méthodes sur nullValue, nous obtiendrions une NullPointerException, comme prévu.

Mais, pourquoi «null» est-il imprimé? Qu'est-ce que nul en fait?

Eh bien, la spécification JVM indique que null est la valeur par défaut pour toutes les références, elle n'est donc pas spécifiquement liée à la chaîne . Et en fait, la spécification n'impose aucun codage de valeur concret pour null .

Alors, d'où vient "null" pour imprimer une chaîne ?

Si nous examinons l' implémentation PrintStream # println , nous verrons qu'elle appelle String # valueOf :

public void println(Object x) { String s = String.valueOf(x); synchronized (this) { print(s); newLine(); } }

Et, si nous regardons String # valueOf, nous obtenons notre réponse:

public static String valueOf(Object obj) { return (obj == null) ? "null" : obj.toString(); }

Et, évidemment, c'est la raison de «null».

8. Conclusion

Dans cet article, nous avons exploré l' initialisation des chaînes . Nous avons expliqué la différence entre la déclaration et l'initialisation. Nous avons également abordé l'utilisation de new et l'utilisation de la syntaxe littérale.

Enfin, nous avons examiné ce que signifie attribuer une valeur nulle à une chaîne , comment la valeur nulle est représentée en mémoire et à quoi elle ressemble lorsque nous l'imprimons.

Tous les exemples de code utilisés dans l'article sont disponibles à l'adresse over sur Github.