Differenza tra String, StringBuffer e StringBuilder in Java – Esempio allegato

Pubblicato: 2022-01-30
Differenza tra String, StringBuffer e StringBuilder in Java - Confronto ed esempio allegati

In questo tutorial Java esamineremo la differenza tra Java String, StringBuffer e StringBuilder.

Iniziamo:

Corda:

La classe String rappresenta le stringhe di caratteri. Tutte le stringhe letterali nei programmi Java, come "crunchify", sono implementate come istanze di questa classe. Le stringhe sono costanti; i loro valori non possono essere modificati dopo la loro creazione.

StringBuffer:

Una sequenza di caratteri thread-safe e mutevole. Un buffer di stringa è come una stringa, ma può essere modificato.

In qualsiasi momento contiene una particolare sequenza di caratteri, ma la lunghezza e il contenuto della sequenza possono essere modificati tramite determinate chiamate di metodo.

I buffer di stringa sono sicuri per l'uso da più thread.

Costruttore di stringhe:

Una sequenza mutevole di caratteri. Questa classe fornisce un'API compatibile con StringBuffer, ma senza garanzia di sincronizzazione.

Questa classe è progettata per essere utilizzata come sostituto drop-in di StringBuffer in luoghi in cui il buffer di stringa veniva utilizzato da un singolo thread (come generalmente accade).

Ove possibile, si consiglia di utilizzare questa classe al posto di StringBuffer poiché sarà più veloce nella maggior parte delle implementazioni.

Confrontiamo tutte le caratteristiche seguenti di String, StringBuffer e StringBuilder.

Corda StringBuffer Costruttore di stringhe
Thread sicuro? sì sì No
Sincronizzato? sì sì No
Modificabile? No (immutabile) Sì (mutabile) Sì (mutabile)
Conservazione Piscina di stringhe Mucchio Mucchio
Prestazione Lento Veloce Più veloce

codice Java:

  • Crea classe: CrunchifyStringVsStringBufferVsStringBuilder.java
  • Inserisci sotto il codice al suo interno
  • Salvare il file

In questo tutorial, stiamo aggiungendo l'aggiunta, aggiungendo il totale della stringa 199999 volte.

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 ) ;
     }
}
 

Risultato della console IntelliJ IDEA:

Esegui il programma sopra come un'applicazione Java in IntelliJ IDEA o in Eclipse Console e otterrai il risultato seguente.

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
 

Fammi sapere se riscontri problemi con l'esecuzione del programma sopra o hai domande tra String, StringBuffer e StringBuilder.