Dans l'exemple donné, un seul objet sera créé. Premièrement, JVM ne trouvera aucun objet chaîne avec la valeur Welcome dans le pool de constantes chaîne, elle créera donc un nouvel objet. Après cela, il trouvera la chaîne avec la valeur Welcome dans le pool, il ne créera pas de nouvel objet mais renverra la référence à la même instance. Dans cet article, nous découvrirons les chaînes Java.

Que sont les chaînes en Java ?

Les chaînes sont le type d'objets qui peuvent stocker le caractère des valeurs et en Java, chaque caractère est stocké sur 16 bits, c'est-à-dire en utilisant le codage UTF 16 bits. Une chaîne agit de la même manière qu’un tableau de caractères en Java.

Exemple:

String name = 'Geeks';>

Exemple de chaîne en Java

Vous trouverez ci-dessous un exemple de chaîne en Java :

// Java Program to demonstrate // String public class StringExample {  // Main Function  public static void main(String args[])  {  String str = new String('example');  // creating Java string by new keyword  // this statement create two object i.e  // first the object is created in heap  // memory area and second the object is  // created in String constant pool.  System.out.println(str);  } }>

example>

Façons de créer une chaîne

Il existe deux manières de créer une chaîne en Java :

alphabet sous forme de chiffres

• Chaîne littérale
• Utilisation d'un nouveau mot-clé

Syntaxe:

 = '';>

1. Chaîne littérale

Pour rendre Java plus efficace en termes de mémoire (car aucun nouvel objet n'est créé s'il existe déjà dans le pool de constantes de chaîne).

Exemple:

String demoString = techcodeview.com;>

2. Utilisation d'un nouveau mot-clé

• String s = new String (Bienvenue);
• Dans un tel cas, JVM créera un nouvel objet chaîne dans la mémoire de tas normale (non pool) et le littéral Welcome sera placé dans le pool de constantes de chaîne. La variable s fera référence à l'objet dans le tas (non-pool)

Exemple:

String demoString = new String (techcodeview.com);>

Interfaces et classes dans les chaînes en Java

CharBuffer : Cette classe implémente l'interface CharSequence. Cette classe est utilisée pour permettre l'utilisation de tampons de caractères à la place de CharSequences. Un exemple d'une telle utilisation est le package d'expression régulière java.util.regex.

Chaîne : C'est une séquence de caractères. En Java, les objets String sont immuables, ce qui signifie une constante et ne peuvent pas être modifiés une fois créés.

Interface CharSequence

L'interface CharSequence est utilisée pour représenter la séquence de caractères en Java.
Les classes implémentées à l'aide de l'interface CharSequence sont mentionnées ci-dessous et fournissent de nombreuses fonctionnalités telles que la sous-chaîne, la dernière occurrence, la première occurrence, la concaténation, le topper, le tolower, etc.

1. Chaîne
2. StringBuffer
3. Générateur de chaînes

1. Chaîne

String est une classe immuable qui signifie une constante et ne peut pas être modifiée une fois créée et si nous souhaitons changer, nous devons créer un nouvel objet et même les fonctionnalités qu'il fournit comme toupper, tolower, etc., tout cela renvoie un nouvel objet, ce n'est pas modifié l'objet d'origine. Il est automatiquement thread-safe.

Syntaxe

String str= 'geeks';  or String str= new String('geeks')>

2. StringBuffer

StringBuffer est une classe homologue de Chaîne , il est de nature mutable et il s'agit d'une classe thread-safe, nous pouvons l'utiliser lorsque nous avons un environnement multi-thread et un objet partagé de tampon de chaîne, c'est-à-dire utilisé par plusieurs threads. Comme il est thread-safe, il y a donc une surcharge supplémentaire, il est donc principalement utilisé pour les programmes multithread.

Syntaxe:

StringBuffer demoString = new StringBuffer('techcodeview.com');>

3. Générateur de chaînes

Générateur de chaînes en Java représente une alternative aux classes String et StringBuffer, car elle crée une séquence de caractères mutable et n'est pas thread-safe. Il est utilisé uniquement dans le thread, il n'y a donc pas de surcharge supplémentaire, il est donc principalement utilisé pour les programmes à thread unique.

Syntaxe:

StringBuilder demoString = new StringBuilder(); demoString.append('GFG');>

StringTokenizer

StringTokenizer la classe en Java est utilisée pour diviser une chaîne en jetons.

Exemple:

Un objet StringTokenizer maintient en interne une position actuelle dans la chaîne à tokeniser. Certaines opérations avancent cette position actuelle au-delà des caractères traités. Un jeton est renvoyé en prenant une sous-chaîne de la chaîne utilisée pour créer l'objet StringTokenizer.

Menuisier de chaînes est une classe dans java.util package qui est utilisé pour construire une séquence de caractères (chaînes) séparés par un délimiteur et commençant éventuellement par un préfixe fourni et se terminant par un suffixe fourni. Bien que cela puisse également être fait à l'aide de la classe StringBuilder pour ajouter un délimiteur après chaque chaîne, StringJoiner fournit un moyen simple de le faire sans beaucoup de code à écrire.

Syntaxe:

public StringJoiner(CharSequence delimiter)>

Ci-dessus, nous avons vu que nous pouvons créer une chaîne par String Literal.

Chaîne demoString =Bienvenue ;

Ici, la JVM vérifie le pool de constantes de chaîne. Si la chaîne n'existe pas, une nouvelle instance de chaîne est créée et placée dans un pool. Si la chaîne existe, elle ne créera pas de nouvel objet. Au lieu de cela, il renverra la référence à la même instance. Le cache qui stocke ces instances de chaîne est appelé pool de constantes de chaîne ou pool de chaînes. Dans les versions antérieures de Java, le pool de chaînes JDK 6 était situé dans l'espace PermGen (Permanent Generation). Mais dans le JDK 7, il est déplacé vers la zone de tas principale.

Chaîne immuable en Java

En Java, les objets chaîne sont immuables. Immuable signifie simplement non modifiable ou immuable. Une fois qu'un objet chaîne est créé, ses données ou son état ne peuvent pas être modifiés mais un nouvel objet chaîne est créé.

Ci-dessous la mise en œuvre du sujet :

// Java Program to demonstrate Immutable String in Java import java.io.*; class GFG {  public static void main(String[] args)  {  String s = 'Sachin';    // concat() method appends  // the string at the end  s.concat(' Tendulkar');    // This will print Sachin  // because strings are  // immutable objects  System.out.println(s);  } }>

Sachin>

Ici, Sachin n'est pas modifié mais un nouvel objet est créé avec Sachin Tendulkar. C'est pourquoi une chaîne est dite immuable.

Comme vous pouvez le voir sur la figure donnée, deux objets sont créés mais la variable de référence fait toujours référence à Sachin et non à Sachin Tendulkar. Mais si nous l'attribuons explicitement à la variable de référence, elle fera référence à l'objet Sachin Tendulkar.

Par exemple:

différence en python

// Java Program to demonstrate Explicitly assigned strings import java.io.*; class GFG {  public static void main(String[] args)  {  String name = 'Sachin';  name = name.concat(' Tendulkar');  System.out.println(name);  } }>

Sachin Tendulkar>

Allocation de mémoire de chaîne

Chaque fois qu'un objet String est créé en tant que littéral, l'objet sera créé dans le pool de constantes String. Cela permet à JVM d'optimiser l'initialisation du littéral String.

Exemple:

String demoString = 'Geeks';>

La chaîne peut également être déclarée à l'aide d'un nouveau opérateur, c’est-à-dire alloué dynamiquement. Dans le cas où des chaînes sont allouées dynamiquement, un nouvel emplacement mémoire leur est attribué dans le tas. Cette chaîne ne sera pas ajoutée au pool de constantes String.

Exemple:

String demoString = new String('Geeks');>

Si vous souhaitez stocker cette chaîne dans le pool constant, vous devrez l'interner.

Exemple:

String internedString = demoString.intern();  // this will add the string to string constant pool.>

Il est préférable d'utiliser des littéraux de chaîne car cela permet à JVM d'optimiser l'allocation de mémoire.

Un exemple qui montre comment déclarer une chaîne

// Java code to illustrate String import java.io.*; import java.lang.*; class Test {  public static void main(String[] args)  {  // Declare String without using new operator  String name = 'techcodeview.com';  // Prints the String.  System.out.println('String name = ' + name);  // Declare String using new operator  String newString = new String('techcodeview.com');  // Prints the String.  System.out.println('String newString = ' + newString);  } }>

String name = techcodeview.com String newString = techcodeview.com>

Note: L'objet chaîne est créé dans la zone du tas et les littéraux sont stockés dans une zone de mémoire spéciale appelée pool de constantes de chaîne.

Pourquoi le pool String est-il passé de PermGen à le zone de tas normale ?

L'espace PermGen est limité, la taille par défaut n'est que de 64 Mo. c'était un problème de création et de stockage d'un trop grand nombre d'objets chaîne dans l'espace PermGen. C'est pourquoi le pool String a été déplacé vers une zone de tas plus grande. Pour rendre Java plus efficace en termes de mémoire, le concept de chaîne littérale est utilisé. En utilisant le mot-clé « new », la JVM créera un nouvel objet chaîne dans la zone de tas normale même si le même objet chaîne est présent dans le pool de chaînes.

Par exemple:

String demoString = new String('Bhubaneswar');>

Jetons un coup d'œil au concept avec un programme Java et visualisons la structure réelle de la mémoire JVM :

Vous trouverez ci-dessous la mise en œuvre de l’approche ci-dessus :

// Java program and visualize the // actual JVM memory structure // mentioned in image class StringStorage {  public static void main(String args[])  {  // Declaring Strings  String s1 = 'TAT';  String s2 = 'TAT';  String s3 = new String('TAT');  String s4 = new String('TAT');  // Printing all the Strings  System.out.println(s1);  System.out.println(s2);  System.out.println(s3);  System.out.println(s4);  } }>

TAT TAT TAT TAT>

Pool de chaînes en Java

Note: Tous les objets en Java sont stockés dans un tas. La variable de référence concerne l'objet stocké dans la zone de pile ou elle peut être contenue dans d'autres objets qui les placent également dans la zone de tas.

Exemple 1:

// Construct String from subset of char array // Driver Class class GFG {  // main function  public static void main(String args[])  {  byte ascii[] = { 71, 70, 71 };  String firstString = new String(ascii);  System.out.println(firstString);  String secondString = new String(ascii, 1, 2);  System.out.println(secondString);  } }>

GFG FG>

Exemple 2 :

// Construct one string from another class GFG {  public static void main(String args[])  {  char characters[] = { 'G', 'f', 'g' };  String firstString = new String(characters);  String secondString = new String(firstString);  System.out.println(firstString);  System.out.println(secondString);  } }>

Gfg Gfg>

Questions fréquemment posées

1. Que sont les chaînes en Java ?

Les chaînes sont les types d'objets qui peuvent stocker des caractères en tant qu'éléments.

2. Pourquoi les objets chaîne sont immuables en Java ?

Parce que Java utilise le concept de chaîne littérale. Supposons qu'il y ait 5 variables de référence, toutes font référence à un seul objet Sachin. Si une variable de référence modifie la valeur de l'objet, elle sera affectée par toutes les variables de référence. C'est pourquoi les objets chaîne sont immuables en Java.

3. Pourquoi Java utilise le concept de chaîne littérale ?

Pour rendre Java plus efficace en termes de mémoire (car aucun nouvel objet n'est créé s'il existe déjà dans le pool de constantes de chaîne).