Différence entre String et StringBuilder
Dans cet article String vs StringBuilder, les deux représentent la séquence de caractères, la première différence entre eux est que la classe String est dans l'espace de noms System alors que StringBuilder est dans System. Espace de noms de texte.
La principale différence est:
La chaîne est immuable : une fois que vous avez créé une instance de chaîne, vous ne pouvez pas la modifier. Si vous modifiez la valeur de la chaîne, cela conservera l'ancienne instance et créera une nouvelle instance avec une nouvelle valeur dans la mémoire.
StringBuilder est modifiable : si vous modifiez la valeur de la chaîne à l'aide de StringBuilder, il ne créera pas de nouvelle instance mais mettra à jour la valeur dans l'instance existante.
Comparaison directe entre String et StringBuilder (infographie)
Voici les 8 meilleures comparaisons entre String et StringBuilder :
Différences clés entre String et StringBuilder
Laissez-nous discuter de certaines différences clés entre String vs StringBuilder dans les points suivants:
1. Lorsque vous travaillez avec la classe String, chaque fois que vous effectuez des opérations sur votre chaîne, vous recréez la chaîne entière dans la mémoire encore et encore tandis que StringBuilder alloue un espace tampon dans la mémoire et applique des modifications dans cet espace tampon.
2. Étant donné que l'objet StringBuilder est modifiable, il offre de meilleures performances par rapport à l'objet String lorsque de lourdes manipulations de chaînes sont impliquées.
Comprenons les points ci-dessus à l'aide d'un exemple donné ci-dessous:
Code:
using System;
using System.Text;
using System.Diagnostics;
public class StringAndStringBuilder
(
static void Main()
(
//using Stopwatch to calculate time
Stopwatch stopWatch = new Stopwatch();
string str = string.Empty;
//starting stop watch
stopWatch.Start();
for (int i = 0; i < 1000; i++)
(
str += i.ToString();
)
stopWatch.Stop();
Console.WriteLine("Time taken by string : (0)", stopWatch.Elapsed);
StringBuilder stringBuilder= new StringBuilder(string.Empty);
//restarting stop watch for StringBuilder
stopWatch.Restart();
for (int i = 0; i < 1000; i++)
(
stringBuilder.Append(i.ToString());
)
stopWatch.Stop();
Console.WriteLine("Time taken by StringBuilder : (0)", stopWatch.Elapsed);
)
)
Production:
3. Les opérations String utilisent plus de mémoire que StringBuilder car String crée des instances de mémoire intermédiaires après chaque opération. Voyons cela dans l'exemple ci-dessous:
Code:
using System;
using System.Text;
using System.Runtime.Serialization;
public class StringAndStringBuilder
(
public static void Main()
(
//using ObjectIDGenerator to generate ID for objects
ObjectIDGenerator idGenerator1 = new ObjectIDGenerator();
bool flag = new bool();
String str = "Sun";
Console.WriteLine("String = (0)", str);
Console.WriteLine("Instance Id : (0)", idGenerator1.GetId(str, out flag));
//flag will be True for new instance otherwise it will be False
Console.WriteLine("This instance is new : (0)\n", flag);
//concatenating strings
str += " rises";
Console.WriteLine("String = (0)", str);
Console.WriteLine("Instance Id : (0)", idGenerator1.GetId(str, out flag));
Console.WriteLine("this instance is new : (0)\n", flag);
str += " in";
Console.WriteLine("String = (0)", str);
Console.WriteLine("Instance Id : (0)", idGenerator1.GetId(str, out flag));
Console.WriteLine("this instance is new : (0)\n", flag);
str += " the";
Console.WriteLine("String = (0)", str);
Console.WriteLine("Instance Id : (0)", idGenerator1.GetId(str, out flag));
Console.WriteLine("this instance is new : (0)\n", flag);
str += " east";
Console.WriteLine("String = (0)", str);
Console.WriteLine("Instance Id : (0)", idGenerator1.GetId(str, out flag));
Console.WriteLine("this instance is new : (0)\n", flag);
//initializing string using StringBuilder
StringBuilder stringBuilder = new StringBuilder("Sun");
ObjectIDGenerator idGenerator2 = new ObjectIDGenerator();
Console.WriteLine("StringBuilder = (0)", stringBuilder);
Console.WriteLine("Instance Id : (0)", idGenerator2.GetId(stringBuilder, out flag));
Console.WriteLine("This instance is new : (0)\n", flag);
stringBuilder.Append(" rises");
Console.WriteLine("StringBuilder = (0)", stringBuilder);
Console.WriteLine("Instance Id : (0)", idGenerator2.GetId(stringBuilder, out flag));
Console.WriteLine("This instance is new : (0)\n", flag);
stringBuilder.Append(" in");
Console.WriteLine("StringBuilder = (0)", stringBuilder);
Console.WriteLine("Instance Id : (0)", idGenerator2.GetId(stringBuilder, out flag));
Console.WriteLine("This instance is new : (0)\n", flag);
stringBuilder.Append(" the");
Console.WriteLine("StringBuilder = (0)", stringBuilder);
Console.WriteLine("Instance Id : (0)", idGenerator2.GetId(stringBuilder, out flag));
Console.WriteLine("This instance is new : (0)\n", flag);
stringBuilder.Append(" east");
Console.WriteLine("StringBuilder = (0)", stringBuilder);
Console.WriteLine("Instance Id : (0)", idGenerator2.GetId(stringBuilder, out flag));
Console.WriteLine("This instance is new : (0)\n", flag);
Console.ReadKey();
)
)
Production:
Représentation graphique du fonctionnement interne du programme ci-dessus:
4. Les objets chaîne peuvent être utilisés sur des threads alors que les objets StringBuilder ne sont pas thread-safe. Ainsi, deux threads ou plus peuvent appeler simultanément des méthodes StringBuilder.
5. Comme les objets String sont thread-safe, ils assurent la synchronisation tandis que StringBuilder ne fournit pas la synchronisation.
6. La classe String est utilisée lorsque la valeur de la chaîne va rester constante tout au long du programme ou lorsqu'il y a très peu de modifications requises, alors que StringBuilder est utilisé lorsque de nombreuses modifications répétées ou opérations lourdes sont nécessaires pour effectuer sur la chaîne.
7. Pour un nombre de concaténations très inférieur, la classe String fonctionne plus rapidement que StringBuilder, car le fait d'accueillir des caractères dans l'espace tampon et de convertir à nouveau la valeur entière en chaîne crée une surcharge. Ainsi, pour le petit nombre de concaténations, StringBuilder fonctionne plus lentement par rapport au comportement de copie par valeur de la classe String.
8. Pour convertir l'objet String en objet StringBuilder, nous devons passer l'objet String au constructeur de classe StringBuilder tandis que l'objet StringBuilder peut être converti en String à l'aide de la méthode ToString ().
String str = “abc”;
StringBuilder StringBuilder = new StringBuilder(str);
StringBuilder StringBuilder = new StringBuilder(“abc”);
String str = StringBuilder.ToString();
Tableau de comparaison de String vs StringBuilder
Le tableau ci-dessous résume les comparaisons entre String et StringBuilder :
| Paramètre | Chaîne | StringBuilder |
| Espace de noms | La classe de chaîne se trouve dans l'espace de noms System. | La classe StringBuilder se trouve dans l'espace de noms System Text. |
| Mutabilité | La chaîne créée à l'aide de la classe String est immuable. | La chaîne créée à l'aide de StringBuilder est modifiable. |
| Performance | Lent par rapport à StringBuilder. | Rapide par rapport à String. Comme il est plus rapide que String tout en concaténant plusieurs chaînes ensemble dans une boucle. |
| Sécurité des fils | Thread-safe. | Pas thread-safe. |
| Synchronisation | Fournit la synchronisation. | Il ne fournit pas de synchronisation. |
| Utilisation de la mémoire | Nécessite plus de mémoire pour créer une nouvelle instance si les opérations effectuées sur la chaîne changent sa valeur. | Il nécessite moins de mémoire car il met à jour l'instance existante. |
| Nature de l'objet | L'objet de chaîne est de nature en lecture seule. | L'objet de StringBuilder est de nature dynamique. |
| Efficacité | La classe de chaînes est moins efficace que StringBuilder tout en travaillant avec un grand nombre de concaténations de chaînes. | StringBuilder est plus efficace que String tout en travaillant avec un grand nombre de concaténations de chaînes. |
Conclusion
La chaîne crée une nouvelle instance uniquement lorsque la valeur de la chaîne change. Si vous effectuez certaines opérations sur une chaîne qui ne change pas sa valeur, il n'y aura pas de nouvelle création d'instance par String. Deux littéraux de chaîne ou plus avec le même contenu peuvent avoir le même emplacement de mémoire.
Articles recommandés
Ceci est un guide pour la principale différence entre String et StringBuilder. Ici, nous discutons également des principales différences entre String et StringBuilder avec des infographies et un tableau de comparaison. Vous pouvez également consulter les articles suivants pour en savoir plus -
- 7 principaux types de chiffrement
- Avantages de StringBuilder en C #
- StringBuffer vs StringBuilder | Comparaison des 4 meilleurs
- Meilleures différences - Jira vs Github