Différence entre String, StringBuffer et StringBuilder en Java – Exemple joint

Publié: 2022-01-30
Différence entre String, StringBuffer et StringBuilder en Java - Comparaison et exemple joint

Dans ce tutoriel Java, nous allons passer en revue la différence entre Java String, StringBuffer et StringBuilder.

Commençons:

Chaîne de caractères:

La classe String représente des chaînes de caractères. Tous les littéraux de chaîne dans les programmes Java, tels que "crunchify", sont implémentés en tant qu'instances de cette classe. Les chaînes sont constantes ; leurs valeurs ne peuvent pas être modifiées après leur création.

StringBuffer & #160;:

Une séquence de caractères mutable et sécurisée pour les threads. Un tampon de chaîne est comme une chaîne, mais peut être modifié.

À tout moment, il contient une séquence particulière de caractères, mais la longueur et le contenu de la séquence peuvent être modifiés via certains appels de méthode.

Les tampons de chaînes peuvent être utilisés en toute sécurité par plusieurs threads.

Générateur de chaînes :

Une suite de caractères mutable. Cette classe fournit une API compatible avec StringBuffer, mais sans garantie de synchronisation.

Cette classe est conçue pour être utilisée en remplacement de StringBuffer aux endroits où le tampon de chaîne était utilisé par un seul thread (comme c'est généralement le cas).

Dans la mesure du possible, il est recommandé d'utiliser cette classe de préférence à StringBuffer car elle sera plus rapide dans la plupart des implémentations.

Comparons toutes les caractéristiques ci-dessous de String, StringBuffer et StringBuilder.

Chaîne de caractères StringBuffer Générateur de chaînes
Thread safe ? Oui Oui Non
Synchronisé ? Oui Oui Non
Modifiable ? Non (immuable) Oui (modifiable) Oui (modifiable)
Espace de rangement Piscine à cordes Tas Tas
Performance Lent Vite Plus rapide

Code Java :

  • Créer une classe : CrunchifyStringVsStringBufferVsStringBuilder.java
  • Mettez-y le code ci-dessous
  • Enregistrer le fichier

Dans ce didacticiel, nous ajoutons l'ajout, l'ajout d'un total de chaînes 199999 fois.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
package crunchify . com . tutorial ;
 
/**
* @author Crunchify.com
* Program: Difference between String, StringBuffer and StringBuilder in Java - Example attached
*/
 
public class CrunchifyStringVsStringBufferVsStringBuilder {
 
     public static void main ( String [ ] args ) {
 
         // String: The String class represents character strings. All string literals
         // in Java programs, such as "abc", are implemented as instances of this class.
         // Strings are constant; their values cannot be changed after they are created. String buffers support mutable strings.
         // Because String objects are immutable they can be shared.
         String crunchifyString = "" ;
         long crunchifyBefore = System . currentTimeMillis ( ) ;
         for ( int i = 0 ; i < 199999 ; i ++ ) {
             crunchifyString = crunchifyString + "crunchify.com" ;
         }
 
         long crunchifyAfter = ( System . currentTimeMillis ( ) ) ;
         crunchifyPrint ( "Task Completion Time for String: " + ( crunchifyAfter - crunchifyBefore ) ) ;
 
         // StringBuffer: A thread-safe, mutable sequence of characters. A string buffer is like a String,
         // but can be modified. At any point in time it contains some particular sequence of characters, but the length
         // and content of the sequence can be changed through certain method calls.
         //
         // String buffers are safe for use by multiple threads. The methods are synchronized where necessary so that all
         // the operations on any particular instance behave as if they occur in some serial order that is consistent with the order
         // of the method calls made by each of the individual threads involved.
         //
         // The principal operations on a StringBuffer are the append and insert methods,
         // which are overloaded so as to accept data of any type. Each effectively converts a given datum to a string and then appends
         // or inserts the characters of that string to the string buffer.
         // The append method always adds these characters at the end of the buffer;
         // the insert method adds the characters at a specified point.
 
         crunchifyBefore = System . currentTimeMillis ( ) ;
         StringBuffer crunchifyStringBuffer = new StringBuffer ( ) ;
         for ( int i = 0 ; i < 199999 ; i ++ ) {
             crunchifyStringBuffer . append ( "crunchify.com" ) ;
         }
 
         crunchifyAfter = ( System . currentTimeMillis ( ) ) ;
         crunchifyPrint ( "Task Completion Time for StringBuffer: " + ( crunchifyAfter - crunchifyBefore ) ) ;
 
         // StringBuilder: A mutable sequence of characters.
         // This class provides an API compatible with StringBuffer, but with no guarantee of synchronization.
         // This class is designed for use as a drop-in replacement for StringBuffer in places where the string buffer was being used by a single thread
         // (as is generally the case). Where possible,
         // it is recommended that this class be used in preference to StringBuffer as it will be faster under most implementations.
         //
         // The principal operations on a StringBuilder are the append and insert methods,
         // which are overloaded so as to accept data of any type. Each effectively converts a given datum to a string and then appends
         // or inserts the characters of that string to the string builder.
         // The append method always adds these characters at the end of the builder; the insert method adds the characters at a specified point.
 
         crunchifyBefore = System . currentTimeMillis ( ) ;
         StringBuilder crunchifyStringBuilder ;
         crunchifyStringBuilder = new StringBuilder ( ) ;
 
         for ( int i = 0 ; i < 199999 ; i ++ ) {
             crunchifyStringBuilder . append ( "crunchify.com" ) ;
         }
         // OR using repeat().
         // crunchifyStringBuilder.append("crunchify.com".repeat(199999));
         // repeat(): Returns a string whose value is the concatenation of this string repeated count times.
 
         crunchifyAfter = ( System . currentTimeMillis ( ) ) ;
         crunchifyPrint ( "Task Completion Time for StringBuilder: " + ( crunchifyAfter - crunchifyBefore ) ) ;
 
     }
 
     private static void crunchifyPrint ( String s ) {
         System . out . println ( s ) ;
     }
}
 

Résultat de la console IntelliJ IDEA :

Exécutez le programme ci-dessus en tant qu'application Java dans IntelliJ IDEA ou dans la console Eclipse et vous obtiendrez le résultat ci-dessous.

1
2
3
4
5
6
7
8
/ Users / app / app / Installation / jdk - 17.0.2.jdk / Contents / Home / bin / java - javaagent : / Applications / IntelliJ IDEA . app / Contents / lib / idea_rt . jar = 50109 : / Applications / IntelliJ IDEA . app / Contents / bin - Dfile . encoding = UTF - 8 - classpath : / Users / app / . m2 / repository / org / slf4j / log4j - over - slf4j / 1.7.32 / log4j - over - slf4j - 1.7.32.jar crunchify . com . tutorial . CrunchifyStringVsStringBuffer
 
Task Completion Time for String : 19648
Task Completion Time for StringBuffer : 7
Task Completion Time for StringBuilder : 3
 
Process finished with exit code 0
 

Faites-moi savoir si vous rencontrez un problème lors de l'exécution du programme ci-dessus ou si vous avez une question entre String, StringBuffer et StringBuilder.